Vous êtes passionné de billard, et souhaitez programmer le meilleur jeu de billard jamais créé. Vous souhaitez cependant faire les choses petit à petit, en commençant par une version simplifiée. Votre toute première version est très limitée : une seule boule (la blanche) est placée sur un billard américain. Il s'agit d'une table rectangulaire autour de laquelle se trouvent 6 trous : un dans chaque coin, et deux au milieu de chacun des bords horizontaux. Le joueur n'a pour l'instant que quatre directions de tir possibles : il tire toujours à un angle de 45 degrés par rapport aux bords de la table. Il ne peut pas appliquer le moindre effet sur la boule, mais peut régler la quantité d'énergie transmise à la boule lors du tir.

Votre objectif est d'écrire un programme qui détermine où s'arrête la boule de billard, soit parce qu'elle tombe dans un trou, soit parce qu'elle n'a plus d'énergie.

On vous décrit la table de billard en vous donnant les distances Hx et Hy entre le centre et les bords verticaux et horizontaux, respectivement. Les coordonnées initiales (Px,Py) de la boule blanche vous sont données dans un repère dont l'origine (0,0) est le centre de la table. Ainsi, le trou situé en haut à gauche du billard a pour coordonnées (-Hx, Hy), et le trou situé en haut et au milieu, a pour coordonnées (0, Hy), et ainsi de suite.

La direction de tir vous est donnée sous la forme d'un vecteur (Dx, Dy), indiquant le nombre d'unités Dx et Dy dont la balle se déplace respectivement horizontalement et verticalement juste après le départ, à chaque étape. Dx comme Dy ne peuvent valoir que -1 ou 1 : Dx vaut 1 si la boule se déplace plutôt vers la droite, et -1 si elle se déplace vers la gauche. De même, Dy vaut 1 si la boule se déplace plutôt vers le haut, et -1 vers le bas.

Lorsque la boule touche un bord (que son centre se trouve exatement sur le bord), elle rebondit contre celui-ci, et change de direction, en repartant toujours à un angle de 45 degrés par rapport à celui-ci.

Une fois le tir effectué, la boule blanche avance case par case en les traversant en diagonale, jusqu'à-ce qu'elle ait épuisé son énergie ou qu'elle atteigne exactement l'un des 6 trous de la table de billard, et y tombe. L'énergie initiale de la boule vous est donnée sous la forme du nombre de cases que peut traverser la boule avant de s'arrêter.

Étant donné la position initiale de la boule, sa direction son énergie initiale, vous devez indiquer les coordonnées exactes de la boule lorsqu'elle s'arrête, que ce soit parce qu'elle a épuisé son énergie, ou parce qu'elle est tombée dans un trou.

• 1 <= Hx,Hy <= 100 000, où Hx est la distance du centre de la table aux bords verticaux et Hy est la distance du centre aux bords horizontaux.
• -Hx < Px < +Hx, où Px est l'abscisse initiale de la boule blanche.
• -Hy < Py < +Hy, où Py est l'ordonnée initiale de la boule blanche.
• 1 <= L <= 1 000 000, où L est l'énergie initiale de la boule, donc le nombre maximal de cases qu'elle peut traverser.

• La première ligne contient deux entiers séparés par des espaces : Hx et Hy.
• La deuxième ligne contient deux entiers séparés par des espaces : Px et Py.
• La troisième ligne contient deux entiers séparés par des espaces : Dx et Dy.
• La quatrième et dernière ligne contient un seul entier : L.

Vous devez afficher deux entiers séparés par des espaces : l'abscisse puis l'ordonnée de la position finale de la boule.

Squelette de code C++ :

#include <cstdio>
#include <cstdlib>

int main()
{
   int Hx, Hy, Px, Py, Dx, Dy, L;
   scanf("%d%d%d%d%d%d%d", &Hx, &Hy, &Px, &Py, &Dx, &Dy, &L);
   // votre code ici, qui modifie en particulier Px et Py
   printf("%d %d\n", Px, Py);
   return 0;
}

let scan_int () = Scanf.scanf " %d" (fun x -> x)

let hx = scan_int()
let hy = scan_int()
let px = ref (scan_int())
let py = ref (scan_int())
let dx = ref (scan_int())
let dy = ref (scan_int())
let dist = ref (scan_int())

let _ =
   (* votre code ici, qui modifie en particulier px et py *)
   Printf.printf "%d %d\n" !px !py

   (* Attention : il est déconseillé d'utiliser une fonction
      récursive pour ce sujet (risque de stack overflow);
      préferrez donc une structure de boucle. *)