#include <cstdio>
#include <vector>
#include <cmath>
#include <cstdlib>

using namespace std;

struct Point {
  double x, y, z;
  Point(double a, double b, double c) : x(a), y(b), z(c) {}
  Point() {x=y=z=0;}
  void Normalize() {
    double d = sqrt(x*x + y*y + z*z);
    x/=d; y/=d; z/=d;
  }
};

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

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

Point operator*(double a, Point b) {
  return Point(a*b.x, a*b.y, a*b.z);
}

struct Triangle {
  int ind[3];
};

Point Cross(Point a, Point b) {
  return Point(a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x);
}

double Dot(Point a, Point b) {
  return a.x*b.x + a.y*b.y + a.z*b.z;
}

class Model {
 public:
  void LoadFromFile(FILE *f) {
    int point_count;
    fscanf(f, "%d", &point_count);
    points_.resize(point_count);
    for (int i = 0; i < point_count; i++) {
      fscanf(f, "%lf %lf %lf", &points_[i].x, &points_[i].y, &points_[i].z);
    }
    int triangle_count;
    fscanf(f, "%d", &triangle_count);
    triangles_.resize(triangle_count);
    for (int i = 0; i < triangle_count; i++) {
      fscanf(f, "%d %d %d", &triangles_[i].ind[0], &triangles_[i].ind[1], &triangles_[i].ind[2]);
    }
  }
  vector<Point> points_;
  vector<Triangle> triangles_;
};

vector<Model> models;

class Object {
 public:
  void LoadFromFile(FILE *f) {
    fscanf(f, "%d %lf %lf %lf %lf", &model_, &rot_axis_.x, &rot_axis_.y, 
           &rot_axis_.z, &rot_angle_);
    fscanf(f, "%lf %lf %lf", &position_.x, &position_.y, &position_.z);
    double rs = sqrt(rot_axis_.x*rot_axis_.x + rot_axis_.y*rot_axis_.y + rot_axis_.z*rot_axis_.z);
    rot_axis_.x /= rs;
    rot_axis_.y /= rs;
    rot_axis_.z /= rs;
    rot_angle_ /= 180;
    rot_angle_ *= 3.141592653;
    for (int i = 0; i < models[model_].points_.size(); i++) {
      Point px = RotatePoint(models[model_].points_[i]);
      Point ppz = px+position_;
      pp.push_back(ppz);
    }
  }

  vector<Point> pp;
  Point RotatePoint(Point p) {
    double c = cos(rot_angle_);
    double s = sin(rot_angle_);
    return Point(
        p.x*(rot_axis_.x*rot_axis_.x*(1-c)+c) + 
        p.y*(rot_axis_.x*rot_axis_.y*(1-c)-rot_axis_.z*s) +
        p.z*(rot_axis_.x*rot_axis_.z*(1-c)+rot_axis_.y*s),

        p.x*(rot_axis_.y*rot_axis_.x*(1-c)+rot_axis_.z*s) + 
        p.y*(rot_axis_.y*rot_axis_.y*(1-c)+c) +
        p.z*(rot_axis_.y*rot_axis_.z*(1-c)-rot_axis_.x*s),

        p.x*(rot_axis_.x*rot_axis_.z*(1-c)-rot_axis_.y*s) + 
        p.y*(rot_axis_.y*rot_axis_.z*(1-c)+rot_axis_.x*s) +
        p.z*(rot_axis_.z*rot_axis_.z*(1-c)+c));
  }

  double PickDistance(Point click_dir, Point click_start) {
    bool in = false;
    double dist = -1;
    for (int i = 0; i < models[model_].triangles_.size(); i++) {
      Point a = pp[models[model_].triangles_[i].ind[0]];
      Point b = pp[models[model_].triangles_[i].ind[1]];
      Point c = pp[models[model_].triangles_[i].ind[2]];

      Point u = b-a; Point v = c-a;
      Point n = Cross(u,v);
      Point w0 = click_start - a;
      double aa = -Dot(n, w0);
      double bb = Dot(n, click_dir);
      if (fabs(bb) < 0.0000000001)
        continue;   // Parallel pick
      double r = aa/bb;
      if (r < 0) // Other direction
        continue;
      Point I = click_start + r*click_dir;
      double uu = Dot(u,u);
      double uv = Dot(u,v);
      double vv = Dot(v,v);
      Point w = I - a;
      double wu = Dot(w,u);
      double wv = Dot(w,v);
      double D = uv * uv - uu * vv;
      double s = (uv * wv - vv * wu) / D;
      double t = (uv * wu - uu * wv) / D;
      if (s < 0.0 || s > 1.0)
        continue;
      if (t < 0.0 || (s+t) > 1.0)
        continue;
      if (in == false || dist > r) {
        in = true;
        dist = r;
      }
    }
    return dist;
  }

  int model_;
  Point rot_axis_;
  double rot_angle_;
  Point position_;
};

vector<Object> objects;

class CameraAndClick {
 public:
  void LoadFromFile(FILE *f) {
    fscanf(f, "%lf %lf %lf", &position_.x, &position_.y, &position_.z);
    fscanf(f, "%lf %lf %lf", &direction_.x, &direction_.y, &direction_.z);
    fscanf(f, "%lf %lf %lf", &up_.x, &up_.y, &up_.z);
    fscanf(f, "%d %d", &clickx_, &clicky_);
    direction_.Normalize();
    up_.Normalize();
  }

  Point GetClickVector() {
    Point left_right = Cross(direction_, up_);  
    return direction_ + -1.0/250*(clicky_-250)*up_ + 1.0/250*(clickx_-250)*left_right;
  }

  Point position_, direction_, up_;
  int clickx_, clicky_;
};

vector<CameraAndClick> clicks;

void LoadInput(char *inputfile) {
  FILE *f = fopen(inputfile, "r");
  int model_count;
  fscanf(f, "%d", &model_count);
  models.resize(model_count);
  for (int i = 0; i < model_count; i++)
    models[i].LoadFromFile(f);
  int object_count;
  fscanf(f, "%d", &object_count);
  objects.resize(object_count);
  for (int i = 0; i < object_count; i++)
    objects[i].LoadFromFile(f);
  int click_count;
  fscanf(f, "%d", &click_count);
  clicks.resize(click_count);
  for (int i = 0; i < click_count; i++)
    clicks[i].LoadFromFile(f);

  fclose(f);
}

int main(int argc, char **argv) {
  if (argc < 2) return 0;
  LoadInput(argv[1]);
  for (int i = 0; i < clicks.size(); i++) {
    Point dir = clicks[i].GetClickVector();
//    printf("%lf %lf %lf\n", dir.x, dir.y, dir.z);
    double mind = -1; int mino = -1;
    for (int j = 0; j < objects.size(); j++) {
      double x = objects[j].PickDistance(dir, clicks[i].position_);
      if (x < 0) continue;
      if (x < mind || mind < 0) {
        mind = x; mino = j;
      }
    }
    printf("%d\n", mino);
    fprintf(stderr, "done %d\n", i);
  }
}