#include <cmath>
#include <iostream>
#include <iomanip>
#include <algorithm>

using namespace std;

const double kEps = 1e-10;
const double kInf = 1e15;

int dcmp(double x) {
  if (fabs(x) < kEps) return 0;
  return x < 0 ? -1 : 1;
}

struct Vector {
  double x, y;
  Vector() {}
  Vector(double x, double y): x(x), y(y) {}
  // Vector(const Point & p1, const Point & p2): x(p2.x - p1.x), y(p2.y - p1.y) {}
  Vector(const Vector & v);

  double Norm() const { return hypot(x, y); }
  double NormSquared() const { return x * x + y * y; }
  Vector Normalize() const {
    return *this / this->Norm();
  }
  Vector operator-() const {
    return Vector(-x, -y);
  }
  Vector operator+(const Vector & rhs) const {
    return Vector(x + rhs.x, y + rhs.y);
  }
  Vector operator-(const Vector & rhs) const {
    return *this + (-rhs);
  }
  Vector operator*(const double rhs) const {
    return Vector(rhs * x, rhs * y);
  }
  Vector operator/(const double rhs) const {
    return *this * (1.0 / rhs);
  }
  double Dot(const Vector & rhs) const {
    return x * rhs.x + y * rhs.y;
  }
  double Cross(const Vector & rhs) const {
    return x * rhs.y - y * rhs.x;
  }
  bool operator==(const Vector & rhs) const {
    return dcmp(x - rhs.x) == 0 && dcmp(y - rhs.y) == 0;
  }
  bool operator<(const Vector & rhs) const {
    return dcmp(x - rhs.x) < 0 || (dcmp(x - rhs.x) == 0 && dcmp(y - rhs.y) < 0);
  }
};

struct Point {
  Point() {}
  Point(double x, double y): x(x), y(y) {}
  Point(const Point & p);

  double x, y;

  Point operator-() {
    return Point(-x, -y);
  }
  Point operator+(const Vector & rhs) const {
    return Point(x + rhs.x, y + rhs.y);
  }
  Point operator-(const Vector & rhs) const {
    return *this + (-rhs);
  }
  bool operator==(const Point & rhs) const {
    return dcmp(x - rhs.x) == 0 && dcmp(y - rhs.y) == 0;
  }
  bool operator<(const Point & rhs) const {
    return dcmp(x - rhs.x) < 0 || (dcmp(x - rhs.x) == 0 && dcmp(y - rhs.y) < 0);
  }
};

struct Line {
  Line() {}
  Line(const Point & p1, const Point & p2): p1(p1), p2(p2) {
    a = p2.y - p1.y;
    b = p1.x - p2.x;
    c = (p2.x - p1.x) * p1.y + (p1.y - p2.y) * p1.x;
    if (dcmp(p2.x - p1.x) == 0) {
      k = kInf;
    } else {
      k = (p2.y - p1.y) / (p2.x - p1.x);
    }
  }
  Line(double x1, double y1, double x2, double y2): p1(x1, y1), p2(x2, y2) {
    a = y2 - y1;
    b = x1 - x2;
    c = (p2.x - p1.x) * p1.y + (p1.y - p2.y) * p1.x;
    if (dcmp(x2 - x1) == 0) {
      k = kInf;
    } else {
      k = (y2 - y1) / (x2 - x1);
    }
  }
  Line(const Line & l);

  Point p1, p2;
  double a, b, c;
  double k;
};

// minus: left, plus: right, 0: colinear
int Direction(const Point & p0, const Point & p1, const Point & p2) {
  Vector v1(p1.x - p0.x, p1.y - p0.y);
  Vector v2(p2.x - p0.x, p2.y - p0.y);
  return dcmp(v2.Cross(v1));
}

// minus: back, plus: front, 0: on
int SegmentDirection(const Point & p0, const Point & p1, const Point & p2) {
  if (p2.x >= min(p0.x, p1.x) && p2.x <= max(p0.x, p1.x)
      && p2.y >= min(p0.y, p1.y) && p2.y <= max(p0.y, p1.y)) { return 0; }
  if ((p2.x - p0.x) * (p1.x - p0.x) > 0
      || (p2.y - p0.y) * (p1.y - p0.y) > 0) { return 1; }
  return -1;
}

Point Intersection(const Line & l1, const Line & l2) {
  auto x = (l1.b * l2.c - l2.b * l1.c) / (l1.a * l2.b - l2.a * l1.b);
  auto y = (l1.a * l2.c - l2.a * l1.c) / (l1.b * l2.a - l2.b * l1.a);
  // if (signbit(x) && dcmp(x) == 0) {
  //   x = 0;
  // }
  // if (signbit(y) && dcmp(y) == 0) {
  //   y = 0;
  // }
  return Point(x, y);
}

ostream & operator<<(ostream & os, const Point & p) {
  os << p.x << " " << p.y;
  return os;
}

ostream & operator<<(ostream & os, const Vector & v) {
  os << v.x << " " << v.y;
  return os;
}

ostream & operator<<(ostream & os, const Line & l) {
  os << l.p1.x << " " << l.p1.y << " " << l.p2.x << " " << l.p2.y;
  return os;
}

int main(int argc, char const *argv[]) {
  double x0, y0, x1, y1;
  Point p0(x0, y0);
  Point p1(x1, y1);

  int q;
  cin >> q;
  for (unsigned i = 0; i < q; ++i) {
    double x0, y0, x1, y1, x2, y2, x3, y3;
    cin >> x0 >> y0 >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
    cout << fixed << setprecision(10);
    cout << Intersection(Line(x0, y0, x1, y1), Line(x2, y2, x3, y3)) <<  "\n";
  }
  return 0;
}

Measured memory_bytes: 3284