#include <cstdio>

 #include <cstring>

 #include <iostream>

 #include <algorithm>

 #include <cmath>

 #include <vector>

 using namespace std;

 const double EPS = 1e-;

 template<class T> T sqr(T x) { return x * x;}

 inline int sgn(double x) { return (x > EPS) - (x < -EPS);}

 struct Point {

     double x, y;

     Point() {}

     Point(double x, double y) : x(x), y(y) {}

     bool operator < (Point a) const { return sgn(x - a.x) <  || sgn(x - a.x) ==  && y < a.y;}

     bool operator == (Point a) const { return sgn(x - a.x) ==  && sgn(y - a.y) == ;}

     Point operator + (Point a) { return Point(x + a.x, y + a.y);}

     Point operator - (Point a) { return Point(x - a.x, y - a.y);}

     Point operator * (double p) { return Point(x * p, y * p);}

     Point operator / (double p) { return Point(x / p, y / p);}

 } ;

 typedef Point Vec;

 inline double cross(Vec a, Vec b) { return a.x * b.y - a.y * b.x;}

 inline double cross(Point o, Point a, Point b) { return cross(a - o, b - o);}

 inline double dot(Vec a, Vec b) { return a.x * b.x + a.y * b.y;}

 inline double dot(Point o, Point a, Point b) { return dot(a - o, b - o);}

 inline double veclen(Vec x) { return sqrt(dot(x, x));}

 inline Vec normal(Vec x) { return Vec(-x.y, x.x) / veclen(x);}

 struct Line {

     Point s, t;

     Line() {}

     Line(Point s, Point t) : s(s), t(t) {}

     Vec vec() { return t - s;}

     Point pt(double x) { return s + vec() * x;}

     Line move(double x) {

         Vec nor = normal(vec());

         return Line(s + nor * x, t + nor * x);

     }

 } ;

 inline Point llint(Point P, Vec v, Point Q, Vec w) { return P + v * (cross(w, P - Q) / cross(v, w));}

 inline Point llint(Line a, Line b) { return llint(a.s, a.vec(), b.s, b.vec());}

 struct Circle {

     Point c;

     double r;

     Circle() {}

     Circle(Point c, double r) : c(c), r(r) {}

 } ;

 void lcint(Line L, Circle C, vector<Point> &sol) {

     Point ip = llint(L, Line(C.c, C.c + normal(L.vec())));

     double dis = veclen(ip - C.c);

     if (sgn(dis - C.r) >= ) return ;

     Vec u = L.vec() / veclen(L.vec());

     double d = sqrt(sqr(C.r) - sqr(dis));

     sol.push_back(ip + u * d);

     sol.push_back(ip - u * d);

 }

 Point reflect(Point x, Line L) {

     Vec nor = normal(L.vec());

     Point ip = llint(L, Line(x, x + nor));

     return ip + ip - x;

 }

 vector<Circle> rec;

 Point src;

 Vec dir;

 const double FINF = 1e100;

 inline bool onCircle(Point p, Circle c) { return sgn(veclen(p - c.c) - c.r) == ;}

 void work() {

     int cnt = , sz = rec.size();

     vector<Point> tmp;

     Point ip;

     while (true) {

         tmp.clear();

         double d = FINF;

         for (int i = ; i < sz; i++) lcint(Line(src, src + dir), rec[i], tmp);

         for (int i = , sz = tmp.size(); i < sz; i++) {

             double t = (tmp[i].x - src.x) / dir.x;

             if (t > EPS) d = min(d, t);

         }

         if (sgn(d - FINF) >= ) break;

         cnt++;

         if (cnt > ) break;

         ip = src + dir * d;

         int mk = -;

         for (int i = ; i < sz; i++) if (onCircle(ip, rec[i])) { mk = i; break;}

         if (mk == -) { puts("shit!!"); while () ;}

         printf("%d ", mk + );

         dir = reflect(src, Line(ip, rec[mk].c)) - ip;

         src = ip;

     }

     if (cnt > ) puts("...");

     else puts("inf");

 }

 int main() {

 //    freopen("in", "r", stdin);

     int cas = , n;

     double x, y, r;

     while (cin >> n && n) {

         rec.clear();

         while (n--) {

             cin >> x >> y >> r;

             rec.push_back(Circle(Point(x, y), r));

         }

         cin >> src.x >> src.y;

         cin >> dir.x >> dir.y;

         dir = dir / veclen(dir);

         printf("Scene %d\n", cas++);

         work();

         puts("");

     }

     return ;

 }