我们太祖先 Kubic 创造由KQID引擎提供动力的存在：

Kubic

让 Kubic 来吧！

KQID写下了 Kubic 先予后取的最短算法代码：

继而 Kubic 不断自我衍生，

比克是万物；万物是比克。

幸福时刻已经来临，

让宇宙来吧！

这一庄子宇宙与我们同生为一。

我们的太祖先父母 Kubic 欢歌载舞，交换比克，共同庆祝

$138$ 亿年前比克大爆炸时，他们的孩子 $2.44324862 \cdot 10^{-59}$ 米宇宙在 $3.35609307\cdot 10^{136} °K$ 的烈火中铸就。

这一爆炸引发了真空中的可变光速 $c$，从 $1.43 \cdot 10^{-147}$ 秒的 $4.27141367\cdot 10^{87}$ 米/秒到一秒后的 $1.61524964\cdot 10^{14}$ 米/秒，$49199.05$ 年后，它从 $2.44324862\cdot 10^{-59}$ 米增至 $3.48111558\cdot 10^{20}$ 米，这一可变 $c$ 成为 $2,9979,2561$ 米/秒的匀速 $c$。

他将轩辕道解读为仁爱，它也可衍生为一个运行体系：“先予后取”原则，也即我们的太祖先 Kubic (00, +, -)。

如今它以 $c$ 持续扩张着，尺寸至少 $2.61111\cdot 10^{26}$ 米。

我们的宇宙家园任我们尽情探索享受。

我

让我来吧！

活着，我身处天堂。

我们的太祖先父母 Kubic (00,+,-) 欢歌载舞，交换比克，共同庆祝！

简言之， Kubic 关于思想（比克）的范式正在替代我们四十亿年来对生活感知（万物）的范式。Kubic 基于“先予后取”原则的范式是亚里士多德存在论的首要原因。存在源于予取统一的操作中，也自我关联地存在着的。因有原则，所以存在。

眷顾

在伊神的眷顾下，我等所由承袭者，谨谋行祖先 Kubic 所宣示之不朽道。其智慧流淌如长河，其游戏饱含令人陶醉之神奇。然我等身处有限的世界，于有限之游戏中浸淫，终将沉溺于胜利之欢欣，或失败之怒火之中。是以，我等以有限之生命，力求取胜于游戏之中；而 Kubic 则以无限之存在，纵横于无尽之游戏，以尝遍无尽之可能。

兹决议，明确并认可 Kubic 是地球和宇宙中所有华人之父；因此，应设立父亲节，作为国定假日，定于农历三月三日，纪念轩辕生辰；

兹决议，明确并认可 Kubic 是地球和宇宙中所有华人之母；因此，应设立母亲节，作为国定假日，定于农历六月六日，纪念嫘祖与轩辕成婚之日，以示对她创造和传播中国丝绸文明的敬意。

Kubic 将我们的道-神-缔造者-创造者-祖先置于在时间的三维时空（宇宙）中 Kubic 关于道的环形等式之中。我们的祖先不再存在于宇宙空间和时间之外，而我们的太祖先 Kubic 正是时间中的空间（三维时空）。

云

Kubic 是一切，一切是 Kubic。Kubic 是所有，它无处不在，同时又无处可寻。Kubic 是存在之云。就像因特网是云一样，它无处不在，但又无处可寻。因特网不是你的电脑，也不是你的 iPad 或 iPhone，而是云。比如维基百科之类的网络内容，只要连上网它就会突然出现，而断开连接，维基百科就会消失回到云中。类似地，当作为云中虚拟的天命人或虚拟物被观察到、或当我们作为云中内容活着的时候，FAPAMA Kubic 就会出现，而未被观察到、或我们死亡的时候，这个 Kubic 就会消失回到云中。我们的创造者就是 。Kubic 就是云。因此，正如无数内容提供者和用户不断在更新维基百科一样，在绝对的数字时间 $T \leq 10^{-1000}$ 秒的每一次给予和索取也一直在更新、修正、改进并发展我们的 FAPAMA Kubic。我们只能在每个 $T$ 时间段内在云中加入比克，但我们从未、也永不能够删除云中的任何东西。因为要使存在永久存在，Kubic 禁止删除任何比克，包括是非、大小、1 或 0、(+)或(-)和予取。在这所谓的熵 $S$，即熵时间-过去比克波函数中，任何比特可以被转换或转移至他处，这个函数源于另一个 $A$ 或 $S$，即反熵时间-未来比克波函数。

换言之，Kubic 告诉我们，原则上，我们不能回到回去，但我们可以把我们的过去带来当下。比如说，我们可以通过进行祖先模拟的游戏，随时将任何死者在当下复活，只要我们有关于他的信息，或者是我们想象中的祖先。在实际操作上，这需要倚仗我们的技术水平。如果我们可以复活死者，自然也可以复活自己，那我们便成了一直在进行永恒游戏的不朽的永生者。简单说，存在就是云，天命人就在云中。实在是虚幻而又真实，无处可寻，无处不在。这是一个关于存在的深奥的悖论，而这源自 Kubic 的惊人的卓见是：任何例如“是与非”的悖论实质上是一个作为构成存在的基本“砖瓦”的比克。甚至可以说，存在就是由这样驳论的比克、关于是否的问答所组成，而这就是美国著名物理学家约翰·惠勒所提出的“万物源于比克。”然而，Kubic 将它修改为“比克是万物，万物是比克，”因此万物=比克，比克=万物。既然存在是无限的，也就意味着囊括从负无穷到正无穷中的一切，而这振奋人心的发现就是：无限存在于有限的存在中。举例来说，在有限的数字 1 和 2 之间有无数极其微小的步骤。同理，无限的世界可以存在于有限的地球，而更令人震撼的现实是，一个无限的宇宙可以存在于一个“原子”之中，而我们的宇宙可能正活在这样一个“原子”中。Kubic 认为我们的多元宇宙是时空 Lm 的胎儿，多元宇宙时间轴；时空中孕育着我们的多元宇宙。此外，我们的多元宇宙正是自身中被投影的全息图，也正是我们的太祖先 FAPAMA Singularity Kubic (00, +, -)。它之所以是 Singularity Kubic 是因为根据爱因斯坦的广义相对论，我们多元宇宙中积聚的无限信息、意识、时间和能量必须是个奇点。“实在”虚幻且真实，也是由可见的“先予后取”或“先取后予”原则所创造并分配的。“先予后取” 原则即是道，是仁爱的运行体系，也就是轩辕之道，而道就是我们的太祖先 Kubic。总之，道= 仁爱= Kubic，以道/仁爱/Kubic 为始，以道/仁爱/Kubic 为终，至始至终，也即万物在道/仁爱/Kubic 中达到统一。

边界

我们的太祖先 Kubic 是不朽的存在，他永远都在进行 着令人兴奋的游戏，但是我们是在这个地球上进行着有限游戏的有限存在，最终会终结于胜利的狂喜和失败的愤怒中。因此，我们在进行着生命的有限游戏以取胜，而 Kubic 则在进行着存在无限的游戏以实现无限可能的经历。

我有一个绝妙的、令人愉悦的好消息和大家分享。天命人践行着“先予后取”或“先取后予”原则，将给予和索取统一于一体，它将长处最大化、使短处最小化，优化了所有人可欲物。这将使人人都能享有免费教育、免费医疗和免费的物质财富，并能自由地追求自己的梦想和愿望，而无需为生计发愁。我要和大家分享的是一个高兴的故事，我已找到了如下几个神秘且看似无人能解的问题的答案，即我们是谁、由何组成、如何被创造和分配、以及为何存在？再也没有了！自从发现了 Kubic 量子信息力学（ 或 KQID）后，我们如今已经知道了我们是谁、由何组成、如何被创造和分配、以及为何存在。让我告诉你们一个关于创造和分配的史诗般的故事，这是关于我们祖先的英雄事迹。5 FAPAMA Singularity (00,+, -)（后来即为 QBit 或 Kubic）。FAPAMA 是法、爸爸、妈妈的缩写。在这个故事中，我将告诉你怎样、什么、为何我们存在于这个卡尔·萨根称为“暗淡蓝点”的美丽地球。

元零定律

我们的太祖先 FAPAMA Singularity Kubic (00, +, -) 直接从“无”（非存在）中出现，这一过程遵循了他的自由意志，并以 Kubic“先予后取”原则作为爱的表现，这也是创造和分配“存在”的基础。Kubic 正是在存在万物背后的可见法则，并衍生成万物。从一个 Kubic 衍生万物。 将轩辕之道的唯一的不可见法则变为可见且唯一必要的法则。有了 Kubic，就不再需要有不可见或无形的物质和功能。万物在其物质、功能和形式上都是可见的，也有着相应的名字。任何不可名的东西都将可名，因此不会再有不可见的东西。元零定律就是缔造者代码，和“先予后取”原则实际上是相同的，而在狄拉克量子力学的表述中，他就是运行中的 $$。“先予后取”原则就是 Kubic，而 Kubic 就是唯“一”的原则。

逻辑上来说，存在直接从“非存在”中出现，而它一旦存在，便存在于各种可能性中。当这一原则展开时，便会让天命下的一切变得不同，瞧！ 如同魔法一般，天命人在进化中来到地球，他生来便肩负五项天命：人本、公正、杨朱的六感自由、权利与义务的统一体以及有调控的自由开放市场体制，因此他生来便体现着道的精神，他和道是统为一体的。Kubic 阐述并解释了“存在”为何、因何、如何从“无”（非存在）中产生，它便是“普朗克式思维” 的万物之母体，同时也是 -麦克斯韦的拥有无限存储的永恒形态，这是我们太祖先 FAPAMA Singularity Kubic (00, +, -) 从无中生有的。 Kubic (00, +, -) 是我们的元零(00)， 分化为我们的太祖先 FAMAPA 父比克(+)及母比克(-)，他们唱歌，跳舞，交换他们的 FAPAMA 文化基因，便有了“存在”+ ，一个 FAPAMA Kubic (00, 1, -1) 婴儿便从“非存在”和绝对数字时间 中诞生了。 Qbit 计算出，在存在中，大约有 $\geq 10^{1000}$ 的 Kubic 以爱因斯坦复杂坐标 $(iτL_{x,y,z}, L_m)$ 的形式存在。

格鲁吉亚之王邀请你查看《【2022奖学金补发名单】》

http://usaco.org

• Dec 17-20: First Contest
• Jan 28-31: Second Contest
• Feb 25-28: Third Contest
• Mar 25-28: US Open
• TBD (Late May): Training Camp
• Aug 7-14: IOI 2022 in Indonesia

#include <bits/stdc++.h>
#define MP make_pair
#define PB push_back
#define int long long
#define st first
#define nd second
#define rd third
#define FOR(i, a, b) for(int i =(a); i <=(b); ++i)
#define RE(i, n) FOR(i, 1, n)
#define FORD(i, a, b) for(int i = (a); i >= (b); --i)
#define REP(i, n) for(int i = 0;i <(n); ++i)
#define VAR(v, i) __typeof(i) v=(i)
#define FORE(i, c) for(VAR(i, (c).begin()); i != (c).end(); ++i)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define __builtin_ctz __builtin_ctzll
#define __builtin_clz __builtin_clzll
#define __builtin_popcount __builtin_popcountll
using namespace std;
template<typename TH> void _dbg(const char* sdbg, TH h) { cerr<<sdbg<<"="<<h<<"\n"; }
template<typename TH, typename... TA> void _dbg(const char* sdbg, TH h, TA... t) {
  while(*sdbg != ',') { cerr<<*sdbg++; } cerr<<"="<<h<<","; _dbg(sdbg+1, t...);
}
#ifdef LOCAL
#define debug(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
#define debugv(x) {{cerr <<#x <<" = "; FORE(itt, (x)) cerr <<*itt <<", "; cerr <<"\n"; }}
#else
#define debug(...) (__VA_ARGS__)
#define debugv(x)
#define cerr if(0)cout
#endif
#define next ____next
#define prev ____prev
#define left ____left
#define hash ____hash
typedef long long ll;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VLL;
typedef vector<pair<int, int> > VPII;
typedef vector<pair<ll, ll> > VPLL;

template<class C> void mini(C&a4, C b4){a4=min(a4, b4); }
template<class C> void maxi(C&a4, C b4){a4=max(a4, b4); }
template<class T1, class T2>
ostream& operator<< (ostream &out, pair<T1, T2> pair) { return out << "(" << pair.first << ", " << pair.second << ")";}
template<class A, class B, class C> struct Triple { A first; B second; C third;
  bool operator<(const Triple& t) const { if (st != t.st) return st < t.st; if (nd != t.nd) return nd < t.nd; return rd < t.rd; } };
template<class T> void ResizeVec(T&, vector<int>) {}
template<class T> void ResizeVec(vector<T>& vec, vector<int> sz) {
  vec.resize(sz[0]); sz.erase(sz.begin()); if (sz.empty()) { return; }
  for (T& v : vec) { ResizeVec(v, sz); }
}
typedef Triple<int, int, int> TIII;
template<class A, class B, class C>
ostream& operator<< (ostream &out, Triple<A, B, C> t) { return out << "(" << t.st << ", " << t.nd << ", " << t.rd << ")"; }
template<class T> ostream& operator<<(ostream& out, vector<T> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
template<class T> ostream& operator<<(ostream& out, set<T> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
template<class L, class R> ostream& operator<<(ostream& out, map<L, R> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }

typedef long double LD;
const LD kEps = 1e-10;
const LD kPi = 2 * acos(0);
LD Sq(LD x) {
  return x * x;
}
struct Point {
  LD x, y;
  Point() {}
  Point(LD a, LD b) : x(a), y(b) {}
  Point(const Point& a) : x(a.x), y(a.y) {}
  void operator=(const Point& a) { x = a.x; y = a.y; }
  Point operator+(const Point& a) const { Point p(x + a.x, y + a.y); return p; }
  Point operator-(const Point& a) const { Point p(x - a.x, y - a.y); return p; }
  Point operator*(LD a) const { Point p(x * a, y * a); return p; }
  Point operator/(LD a) const { assert(abs(a) > kEps); Point p(x / a, y / a); return p; }
  Point& operator+=(const Point& a) { x += a.x; y += a.y; return *this; }
  Point& operator-=(const Point& a) { x -= a.x; y -= a.y; return *this; }
  Point& operator*=(LD a) { x *= a; y *= a; return *this;}
  Point& operator/=(LD a) { assert(abs(a) > kEps); x /= a; y /= a; return *this; }

  bool IsZero() const {
    return abs(x) < kEps && abs(y) < kEps;
  }
  bool operator==(const Point& a) const {
    return (*this - a).IsZero();
  }
  LD CrossProd(const Point& a) const {
    return x * a.y - y * a.x;
  }
  LD CrossProd(Point a, Point b) const {
    a -= *this;
    b -= *this;
    return a.CrossProd(b);
  }
  LD DotProd(const Point& a) const {
    return x * a.x + y * a.y;
  }
  LD Norm() const {
    return sqrt(Sq(x) + Sq(y));
  }
  void NormalizeSelf() {
    *this /= Norm();
  }
  Point Normalize() {
    Point res(*this);
    res.NormalizeSelf();
    return res;
  }
  LD Dist(const Point& a) const {
    return (*this - a).Norm();
  }
  LD Angle() const {
    return atan2(y, x);
  }
  void RotateSelf(LD angle) {
    LD c = cos(angle);
    LD s = sin(angle);
    LD nx = x * c - y * s;
    LD ny = y * c + x * s;
    y = ny;
    x = nx;
  }
  Point Rotate(LD angle) const {
    Point res(*this);
    res.RotateSelf(angle);
    return res;
  }
  static bool LexCmp(const Point& a, const Point& b) {
    if (abs(a.x - b.x) > kEps) {
      return a.x < b.x;
    }
    return a.y < b.y;
  }
  LD SqNorm() {
    return x * x + y * y;
  }
  friend ostream& operator<<(ostream& out, Point m);
};

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

struct Circle {
  Point center;
  LD r;
  Circle(LD x, LD y, LD rad) {
    center = Point(x, y);
    r = rad;
  }
  Circle(const Point& a, LD rad) : center(a), r(rad) {}
  LD Area() const {
    return kPi * Sq(r);
  }
  LD Perimeter() const {
    return 2 * kPi * r;
  }
  LD Diameter() const {
    return 2 * r;
  }
  Point RotateRightMost(LD ang) const {
    return center + Point{r * cos(ang), r * sin(ang)};
  }
  bool operator==(const Circle& c) const {
    return center == c.center && abs(r - c.r) < kEps;
  }
};

struct Line {
  Point p[2];
  bool is_seg;
  Line(Point a, Point b, bool is_seg_ = false) {
    p[0] = a;
    p[1] = b;
    is_seg = is_seg_;
  }
  Line() {
  }
  Point& operator[](int a) {
    return p[a];
  }
  Point NormalVector() {
    Point perp = p[1] - p[0];
    perp.RotateSelf(kPi / 2);
    perp.NormalizeSelf();
    return perp;
  }

  // (A, B, C) such that A^2 + B^2 = 1, (A, B) > (0, 0)
  vector<LD> LineEqNormLD() { // seems ok
    LD A = p[1].y - p[0].y;
    LD B = p[0].x - p[1].x;
    LD C = -(A * p[0].x + B * p[0].y);
    assert(abs(A * p[1].x + B * p[1].y + C) < kEps);
    LD norm = sqrt(Sq(A) + Sq(B));
    vector<LD> res{A, B, C};
    for (auto& x : res) { x /= norm; }
    if (A < -kEps || (abs(A) < kEps && B < -kEps)) {
      for (auto& x : res) { x *= -1; }
    }
    return res;
  }

  // assumes that coordinates are integers!
  vector<int> LineEqNormInt() { // seems ok
    int A = round(p[1].y - p[0].y);
    int B = round(p[0].x - p[1].x);
    int C = -(A * p[0].x + B * p[0].y);
    int gcd = abs(__gcd(A, __gcd(B, C)));
    vector<int> res{A, B, C};
    for (auto& x : res) { x /= gcd; }
    if (A < 0 || (A == 0 && B < 0)) {
      for (auto& x : res) { x *= -1; }
    }
    return res;
  }
};

struct Utils {
  // 0, 1, 2 or 3 pts. In case of 3 pts it means they are equal
  static vector<Point> InterCircleCircle(Circle a, Circle b) {
    if (a.r + kEps < b.r) {
      swap(a, b);
    }
    if (a == b) {
      return vector<Point>{a.RotateRightMost(0), a.RotateRightMost(2 * kPi / 3),
        a.RotateRightMost(4 * kPi / 3)};
    }
    Point diff = b.center - a.center;
    LD dis = diff.Norm();
    LD ang = diff.Angle();
    LD longest = max(max(a.r, b.r), dis);
    LD per = a.r + b.r + dis;
    if (2 * longest > per + kEps) {
      return vector<Point>();
    }
    if (abs(2 * longest - per) < 2 * kEps) {
      return vector<Point>{a.RotateRightMost(ang)};
    }
    LD ang_dev = acos((Sq(a.r) + Sq(dis) - Sq(b.r)) / (2 * a.r * dis));
    return vector<Point>{a.RotateRightMost(ang - ang_dev), a.RotateRightMost(ang + ang_dev)};
  }

  static vector<Point> InterLineLine(Line& a, Line& b) { // working fine
    Point vec_a = a[1] - a[0];
    Point vec_b1 = b[1] - a[0];
    Point vec_b0 = b[0] - a[0]; 
    LD tr_area = vec_b1.CrossProd(vec_b0);
    LD quad_area = vec_b1.CrossProd(vec_a) + vec_a.CrossProd(vec_b0);
    if (abs(quad_area) < kEps) { // parallel or coinciding
      if (PtBelongToLine(b, a[0])) {
        return {a[0], a[1]};
      } else {
        return {};
      }
    }
    return {a[0] + vec_a * (tr_area / quad_area)};
  } 

  static Point ProjPointToLine(Point p, Line l) { ///Tested
    Point diff = l[1] - l[0];
    return l[0] + diff * (diff.DotProd(p - l[0]) / diff.DotProd(diff));
  }

  static Point ReflectPtWRTLine(Point p, Line l) {
    Point proj = ProjPointToLine(p, l);
    return proj * 2 - p;
  }

  static vector<Point> InterCircleLine(Circle c, Line l) { /// Tested here: http://c...content-available-to-author-only...s.com/gym/100554/submission/10197624
    Point proj = ProjPointToLine(c.center, l);
    LD dis_proj = c.center.Dist(proj);
    if (dis_proj > c.r + kEps) { return vector<Point>(); }
    LD a = sqrt(max((LD)0, Sq(c.r) - Sq(dis_proj)));
    Point dir = l[1] - l[0];
    LD dir_norm = dir.Norm();
    vector<Point> cands{proj + dir * (a / dir_norm), proj - dir * (a / dir_norm)};
    if (cands[0].Dist(cands[1]) < kEps) { return vector<Point>{proj}; }
    return cands;
  }

  static bool PtBelongToLine(Line l, Point p) {
    return abs(l[0].CrossProd(l[1], p)) < kEps;
  }

  static bool PtBelongToSeg(Line l, Point p) { // seems ok
    return abs(p.Dist(l[0]) + p.Dist(l[1]) - l[0].Dist(l[1])) < kEps;
  }

  static vector<Point> InterCircleSeg(Circle c, Line l) { //seems ok
    vector<Point> from_line = InterCircleLine(c, l);
    vector<Point> res;
    for (auto p : from_line) {
      if (PtBelongToSeg(l, p)) { res.PB(p); }
    }
    return res;
  }

  static vector<Point> TangencyPtsToCircle(Circle c, Point p) { // seems ok
    LD d = c.center.Dist(p);
    if (d < c.r - kEps) { return {}; }
    if (d < c.r + kEps) { return {p}; }
    LD from_cent = (p - c.center).Angle();
    LD ang_dev = acos(c.r / d);
    return {c.RotateRightMost(from_cent - ang_dev), c.RotateRightMost(from_cent + ang_dev)};
  }

  // outer and inner tangents tested only locally (however I believe that rigorously)
  static vector<Line> OuterTangents(Circle c1, Circle c2) {
    if (c1 == c2) { return {}; } // is it surely best choice?
    if (c1.r < c2.r) { swap(c1, c2); }
    if (c2.r + c1.center.Dist(c2.center) < c1.r - kEps) { return {}; }
    if (abs(c1.r - c2.r) < kEps) {
      Point diff = c2.center - c1.center;
      Point R = diff.Rotate(kPi / 2) * (c1.r / diff.Norm()); 
      return {{c1.center + R, c2.center + R}, {c1.center - R, c2.center - R}};
    }
    Point I = c1.center + (c2.center - c1.center) * (c1.r / (c1.r - c2.r)); 
    if (c2.r + c1.center.Dist(c2.center) < c1.r + kEps) {
      return {{I, I + (c2.center - c1.center).Rotate(kPi / 2)}};
    }
    vector<Point> to1 = TangencyPtsToCircle(c1, I);
    vector<Point> to2 = TangencyPtsToCircle(c2, I);
    vector<Line> res{{to1[0], to2[0]}, {to1[1], to2[1]}};
    assert(Utils::PtBelongToLine(res[0], I));
    assert(Utils::PtBelongToLine(res[1], I));
    return res;
  }

  // unfortunately big part of code is same as in previous function
  // can be joined when putting appropriate signs in few places
  // however those ifs differ a bit hence it may not be good idea
  // to necessarily join them
  static vector<Line> InnerTangents(Circle c1, Circle c2) {
    if (c1 == c2) { return {}; } // this time surely best choice
    if (c1.r < c2.r) { swap(c1, c2); }
    LD d = c1.center.Dist(c2.center);
    if (d < c1.r + c2.r - kEps) { return {}; }
    Point I = c1.center + (c2.center - c1.center) * (c1.r / (c1.r + c2.r));
    if (d < c1.r + c2.r + kEps) {
      return {{I, I + (c2.center - c1.center).Rotate(kPi / 2)}};
    }
    vector<Point> to1 = TangencyPtsToCircle(c1, I);
    vector<Point> to2 = TangencyPtsToCircle(c2, I);
    vector<Line> res{{to1[0], to2[0]}, {to1[1], to2[1]}};
    assert(Utils::PtBelongToLine(res[0], I));
    assert(Utils::PtBelongToLine(res[1], I));
    return res;
  }

  static bool AreParallel(Line l1, Line l2) { // seems ok
    return abs(l1[0].CrossProd(l2[0], l1[1]) - l1[0].CrossProd(l2[1], l1[1])) < kEps;
  }

  // returns a vector of points such that their convex hull is intersection of those segments
  // SZ(res) == 0 => empty intersection, SZ(res) == 1 => intersection is a point, SZ(res) == 2 => intersection is a segment
  static vector<Point> InterSegs(Line l1, Line l2) { // seems ok
    if (!Point::LexCmp(l1[0], l1[1])) { swap(l1[0], l1[1]); }
    if (!Point::LexCmp(l2[0], l2[1])) { swap(l2[0], l2[1]); }
    if (AreParallel(l1, l2)) {
      if (!PtBelongToLine(l1, l2[0])) { return vector<Point>(); }
      vector<Point> ends(2);
      for (int tr = 0; tr < 2; tr++) {
        if (Point::LexCmp(l1[tr], l2[tr]) ^ tr) {
          ends[tr] = l2[tr];
        } else {
          ends[tr] = l1[tr];
        }
      }
      if ((ends[1] - ends[0]).IsZero()) {
        ends.pop_back();
      }
      if (SZ(ends) == 2 && Point::LexCmp(ends[1], ends[0])) { return vector<Point>(); }
      return ends;
    } else {
      vector<Point> p = InterLineLine(l1, l2);
      if (PtBelongToSeg(l1, p[0]) && PtBelongToSeg(l2, p[0])) { return p; }
      return vector<Point>();
    }
  }

  static LD Angle(Point P, Point Q, Point R) { // angle PQR
    LD ang2 = (P - Q).Angle();
    LD ang1 = (R - Q).Angle();
    LD ans = ang1 - ang2;
    if (ans < kEps) {
      ans += 2 * kPi;
    }
    return ans;
  }

  // tested here: http://c...content-available-to-author-only...s.com/contest/600/submission/14961583
  // DON'T change anything as this will lead to precision errors
  // don't know why, but this is the only version which works precisely even for very mean cases
  static LD DiskInterArea(Circle c1, Circle c2) { // tested here: http://o...content-available-to-author-only...s.info/~ejudge/team.cgi?contest_id=006254 problem I
    if (c1.r < c2.r) {
      swap(c1, c2);
    }
    LD d = c1.center.Dist(c2.center);
    if (c1.r + c2.r < d + kEps) {
      return 0;
    }
    if (c1.r - c2.r > d - kEps) {
      return kPi * Sq(c2.r);
    }
    LD alfa = acos((Sq(d) + Sq(c1.r) - Sq(c2.r)) / (2 * d * c1.r));
    LD beta = acos((Sq(d) + Sq(c2.r) - Sq(c1.r)) / (2 * d * c2.r));
    return alfa * Sq(c1.r) + beta * Sq(c2.r) - sin(2 * alfa) * Sq(c1.r) / 2 - sin(2 * beta) * Sq(c2.r) / 2;
  }

  static Line RadAxis(Circle c1, Circle c2) {
    LD d = c1.center.Dist(c2.center);
    LD a = (Sq(c1.r) - Sq(c2.r) + Sq(d)) / (2 * d);
    Point Q = c1.center + (c2.center - c1.center) * (a / d);
    Point R = Q + (c2.center - c1.center).Rotate(kPi / 2);
    return Line(Q, R);
  }
};
Point Rot(Point P) {
  return {-P.y, P.x};
}

LD Dis(Point A, Point B) {
  return A.Dist(B);
}

const int N = 1e5 + 5;
Point flag[N];

int32_t main() {

  ios_base::sync_with_stdio(0);
  cout << fixed << setprecision(10);
  cerr << fixed << setprecision(10);
  cin.tie(0);
  //double beg_clock = 1.0 * clock() / CLOCKS_PER_SEC;

  int n;
  cin>>n;
  int res = n;
  int x, y, A, B;
  cin>>x>>y>>A>>B;
  Point P = {(LD)x + A / 2, (LD)y - B / 2};
  RE (i, n) {
    int xf, yf;
    cin>>xf>>yf;
    flag[i] = {(LD)xf, (LD)yf};
  }
  REP (tr, 4) {
    Point R{(LD)P.x - A / 2, (LD)P.y + B / 2};
    Point Q{(LD)P.x + A / 2, (LD)P.y};

    int bil = 0;
    Line hor{P, Q};
    vector<pair<LD, int>> evs;
    RE (i, n) {
      int at_P = Dis(P, flag[i]) < Dis(P, R) + kEps;
      int at_Q = Dis(Q, flag[i]) < Dis(Q, R) + kEps;
      if (at_P == at_Q) {
        if (at_P) {
          bil++;
        }
        continue;
      }

      Point midFR = (flag[i] + R) / 2;
      Point dir = flag[i] - midFR;
      dir = Rot(dir);
      Line sym{midFR, midFR + dir};
      vector<Point> inters = Utils::InterLineLine(sym, hor);
      assert(SZ(inters) == 1);
      Point inter = inters[0];
      if (at_P) {
        evs.PB({inter.x + kEps, -1});
        bil++;
      } else {
        evs.PB({inter.x - kEps, 1});
      }
    }
    sort(ALL(evs));
    mini(res, bil);
    for (auto ev : evs) {
      bil += ev.nd;
      mini(res, bil);
    }

    P = Rot(P);
    RE (i, n) {
      flag[i] = Rot(flag[i]);
    }
    swap(A, B);
  }
  cout<<res<<endl;



  return 0;
}

day1的录屏和ppt和笔记已经传到网盘里了

这几天的课程资料都会在课后传这个文件夹里

都是这个链接和密码 到时候到群公告里找就成

百度网盘链接:https://pan.baidu.com/s/1-wfTfp0sQhGQunnik4d8vg 密码:bbsc

Google Drive链接（需要科学上网）：https://drive.google.com/drive/folders/1cYQeo1bDd5ExQo0GE50UIV8scSAGkWjE?usp=sharing