Codeforces Round #478 (Div. 2) ABCDE

A. Aramic script

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

In Aramic language words can only represent objects.

Words in Aramic have special properties:

• A word is a root if it does not contain the same letter more than once.
• A root and all its permutations represent the same object.
• The root $\mathrm{xx of\; a\; word yy is\; the\; word\; that\; contains\; all\; letters\; that\; appear\; in yy in\; a\; way\; that\; each\; letter\; appears\; once.\; For\; example,\; theroot of\; "aaaa",\; "aa",\; "aaa"\; is\; "a",\; the root of\; "aabb",\; "bab",\; "baabb",\; "ab"\; is\; "ab".}$
• Any word in Aramic represents the same object as its root.

You have an ancient script in Aramic. What is the number of different objects mentioned in the script?

Input

The first line contains one integer $\mathrm{nn (1\le n\le 1031\le n\le 103) —\; the\; number\; of\; words\; in\; the\; script.}$

The second line contains $\mathrm{nn words s1,s2,\dots ,sns1,s2,\dots ,sn —\; the\; script\; itself.\; The\; length\; of\; each\; string\; does\; not\; exceed 103103.}$

It is guaranteed that all characters of the strings are small latin letters.

Output

Output one integer — the number of different objects mentioned in the given ancient Aramic script.

Examples

input

Copy

5
a aa aaa ab abb

output

Copy

2

input

Copy

3
amer arem mrea

output

Copy

1

Note

In the first test, there are two objects mentioned. The roots that represent them are "a","ab".

In the second test, there is only one object, its root is "amer", the other strings are just permutations of "amer".

---

题意：对于每个字符串，他的根是他所有不同字符组成的字符串组成的任意排列，其中所有都排列代表的都是同一个根。然后让你对所有字符串输出不同的根的个数。题解：对于一个字符串的根我们可以用一个最大为$ 2^{27} -1 $ 的数表示，那我们每次检查这个数在之前是否出现过。没有则标记该数并答案+1。

#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define mod 1000000007
#define clr_1(x) memset(x,-1,sizeof(x))
#define INF 0x3f3f3f3f
#define LL long long
#define pb push_back
#define pbk pop_back
using namespace std;
const int N=1e3+10;
const int type=26;
int pt[N];
bool num[type];
int n,m,k,nub,p,i;
char s[N];
int main()
{
    int n;
    scanf("%d",&n);
    k=0;
    for(int t=1;t<=n;t++)
    {
        scanf("%s",s);
        clr(num);
        nub=0;
        for(i=0;s[i];i++)
        {
            p=s[i]-'a';
            if(!num[p])
                nub^=(1<<p),num[p]=1;
        }
        for(i=1;i<=k;i++)
        {
            if(nub==pt[i])
                break;
        }
        if(i>k)
            pt[++k]=nub;
    }
    printf("%d
",k);
    return 0;
}

B. Mancala

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Mancala is a game famous in the Middle East. It is played on a board that consists of 14 holes.

Initially, each hole has ${\mathrm{aiai stones.\; When\; a\; player\; makes\; a\; move,\; he\; chooses\; a\; hole\; which\; contains\; a positive number\; of\; stones.\; He\; takes\; all\; the\; stones\; inside\; it\; and\; then\; redistributes\; these\; stones\; one\; by\; one\; in\; the\; next\; holes\; in\; a\; counter-clockwise\; direction.}}^{}$

Note that the counter-clockwise order means if the player takes the stones from hole $\mathrm{ii,\; he\; will\; put\; one\; stone\; in\; the (i+1)(i+1)-th\; hole,\; then\; in\; the (i+2)(i+2)-th,\; etc.\; If\; he\; puts\; a\; stone\; in\; the 1414-th\; hole,\; the\; next\; one\; will\; be\; put\; in\; the\; first\; hole.}$

After the move, the player collects all the stones from holes that contain even number of stones. The number of stones collected by player is the score, according to Resli.

Resli is a famous Mancala player. He wants to know the maximum score he can obtain after one move.

Input

The only line contains 14 integers ${\mathrm{a1,a2,\dots ,a14a1,a2,\dots ,a14 (0\le ai\le 1090\le ai\le 109) —\; the\; number\; of\; stones\; in\; each\; hole.}}^{}$

It is guaranteed that for any $\mathrm{ii (1\le i\le 141\le i\le 14) aiai is\; either\; zero\; or\; odd,\; and\; there\; is\; at\; least\; one\; stone\; in\; the\; board.}$

Output

Output one integer, the maximum possible score after one move.

Examples

input

Copy

0 1 1 0 0 0 0 0 0 7 0 0 0 0

output

Copy

4

input

Copy

5 1 1 1 1 0 0 0 0 0 0 0 0 0

output

Copy

8

Note

In the first test case the board after the move from the hole with $\mathrm{77 stones\; will\; look\; like 1\; 2\; 2\; 0\; 0\; 0\; 0\; 0\; 0\; 0\; 1\; 1\; 1\; 1.\; Then\; the\; player\; collects\; the\; even\; numbers\; and\; ends\; up\; with\; a\; score\; equal\; to 44.}$

---

题意:有14个洞，每个洞里有一定数量的石头。然后现在让你选择一个洞里有石头的洞i，把里面石头都取出来，然后按照$ i,i+1,i+2……14,1,2……14,1,2…… $不断循环地一个一个放石头。最后放完后吧偶数颗石头的洞里的石头都取出来。问这样操作一次最多获得多少石头。题解:按照题意模拟一下取14个洞每个洞的情况取最大值。

#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define mod 1000000007
#define clr_1(x) memset(x,-1,sizeof(x))
#define INF 0x3f3f3f3f
#define LL long long
#define pb push_back
#define pbk pop_back
using namespace std;
const int N=20;
const int type=26;
LL p[N],evey[N];
LL ans,maxn,allo,t;
int n,m;
int main()
{
    for(int i=0;i<14;i++)
        scanf("%I64d",p+i);
    maxn=0;
    for(int i=0;i<14;i++)
    if(p[i])
    {
        allo=p[i];
        for(int j=0;j<14;j++)
            if(i!=j)
                evey[j]=p[j];
            else
                evey[j]=0;
        t=allo%14;
        for(int j=i+1;j<t+i+1;j++)
            evey[j%14]++;
        t=allo/14;
        for(int j=0;j<14;j++)
            evey[j]+=t;
        ans=0;
        for(int j=0;j<14;j++)
            if(evey[j]%2==0)
                ans+=evey[j];
        maxn=max(ans,maxn);
    }
    printf("%I64d
",maxn);
    return 0;
}

C. Valhalla Siege

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Ivar the Boneless is a great leader. He is trying to capture Kattegat from Lagertha. The war has begun and wave after wave Ivar's warriors are falling in battle.

Ivar has $\mathrm{nn warriors,\; he\; places\; them\; on\; a\; straight\; line\; in\; front\; of\; the\; main\; gate,\; in\; a\; way\; that\; the ii-th\; warrior\; stands\; right\; after (i-1)(i-1)-th\; warrior.\; The\; first\; warrior\; leads\; the\; attack.}$

Each attacker can take up to ${\mathrm{aiai arrows\; before\; he\; falls\; to\; the\; ground,\; where aiai is\; the ii-th\; warrior\text{'}s\; strength.}}^{}$

Lagertha orders her warriors to shoot ${\mathrm{kiki arrows\; during\; the ii-th\; minute,\; the\; arrows\; one\; by\; one\; hit\; the\; first\; still\; standing\; warrior.\; After\; all\; Ivar\text{'}s\; warriors\; fall\; and\; all\; the\; currently\; flying\; arrows\; fly\; by,\; Thor\; smashes\; his\; hammer\; and\; all\; Ivar\text{'}s\; warriors\; get\; their\; previous\; strengths\; back\; and\; stand\; up\; to\; fight\; again.\; In\; other\; words,\; if\; all\; warriors\; die\; in\; minute tt,\; they\; will\; all\; be\; standing\; to\; fight\; at\; the\; end\; of\; minute tt.}}^{}$

The battle will last for $\mathrm{qq minutes,\; after\; each\; minute\; you\; should\; tell\; Ivar\; what\; is\; the\; number\; of\; his\; standing\; warriors.}$

Input

The first line contains two integers $\mathrm{nn and qq (1\le n,q\le 2000001\le n,q\le 200000) —\; the\; number\; of\; warriors\; and\; the\; number\; of\; minutes\; in\; the\; battle.}$

The second line contains $\mathrm{nn integers a1,a2,\dots ,ana1,a2,\dots ,an (1\le ai\le 1091\le ai\le 109)\; that\; represent\; the\; warriors\text{'}\; strengths.}$

The third line contains $\mathrm{qq integers k1,k2,\dots ,kqk1,k2,\dots ,kq (1\le ki\le 10141\le ki\le 1014),\; the ii-th\; of\; them\; represents\; Lagertha\text{'}s\; order\; at\; the ii-th\; minute: kikiarrows\; will\; attack\; the\; warriors.}$

Output

Output $\mathrm{qq lines,\; the ii-th\; of\; them\; is\; the\; number\; of\; standing\; warriors\; after\; the ii-th\; minute.}$

Examples

input

Copy

5 5
1 2 1 2 1
3 10 1 1 1

output

Copy

3
5
4
4
3

input

Copy

4 4
1 2 3 4
9 1 10 6

output

Copy

1
4
4
1

Note

In the first example:

• after the 1-st minute, the 1-st and 2-nd warriors die.
• after the 2-nd minute all warriors die (and all arrows left over are wasted), then they will be revived thus answer is 5 — all warriors are alive.
• after the 3-rd minute, the 1-st warrior dies.
• after the 4-th minute, the 2-nd warrior takes a hit and his strength decreases by 1.
• after the 5-th minute, the 2-nd warrior dies.

---

题意：有n个士兵，每个士兵都有一定的承受伤害值，表示他能承受几根箭的攻击。然后有q轮攻击，每轮攻击会发射$ k_i $根箭，若有士兵存活则一定命中最左侧存活士兵。当在某一轮中所有士兵全中箭死亡时，在这轮末尾也就是箭全部发射完毕时所有士兵都会复活。问每轮攻击后也就是轮末有多少士兵存活。题解：维护一个士兵承受伤害的前缀和，每次二分（lower_bound）查找总承受攻击p下最左侧士兵。当总承受攻击p大于等于最右也就是n的前缀和时，p清零并存活人数为n。

#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define mod 1000000007
#define clr_1(x) memset(x,-1,sizeof(x))
#define INF 0x3f3f3f3f
#define LL long long
#define pb push_back
#define pbk pop_back
#define itn int 
#define mian main
using namespace std;
const int N=2e5+10;
const int type=26;
int n,m,q,pos;
LL so[N],pre[N];
LL now,att;
int main()
{
    scanf("%d%d",&n,&q);
    for(int i=1;i<=n;i++)
        scanf("%I64d",so+i);
    pre[0]=0;
    now=0;
    for(int i=1;i<=n;i++)
        pre[i]=pre[i-1]+so[i];
    for(int i=1;i<=q;i++)
    {
        scanf("%I64d",&att);
        now+=att;
        if(now>=pre[n])
        {
            printf("%d
",n);
            now=0;
        }
        else
        {
            pos=upper_bound(pre+1,pre+n+1,now)-pre;
            printf("%d
",n-pos+1);
        }
    }
    return 0;
}

D. Ghosts

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Ghosts live in harmony and peace, they travel the space without any purpose other than scare whoever stands in their way.

There are $\mathrm{nn ghosts\; in\; the\; universe,\; they\; move\; in\; the OXYOXY plane,\; each\; one\; of\; them\; has\; its\; own\; velocity\; that\; does\; not\; change\; in\; time: \to V=Vx\to i+Vy\to jV\to =Vxi\to +Vyj\to where VxVx is\; its\; speed\; on\; the xx-axis\; and VyVy is\; on\; the yy-axis.}$

A ghost $\mathrm{ii has\; experience\; value EXiEXi,\; which\; represent\; how\; many\; ghosts\; tried\; to\; scare\; him\; in\; his\; past.\; Two\; ghosts\; scare\; each\; other\; if\; they\; were\; in\; the\; same\; cartesian\; point\; at\; a\; moment\; of\; time.}$

As the ghosts move with constant speed, after some moment of time there will be no further scaring (what a relief!) and the experience of ghost kind $\mathrm{GX=\sum ni=1EXiGX=\sum i=1nEXi will\; never\; increase.}$

Tameem is a red giant, he took a picture of the cartesian plane at a certain moment of time $\mathrm{TT,\; and\; magically\; all\; the\; ghosts\; were\; aligned\; on\; a\; line\; of\; the\; form y=a\cdot x+by=a\cdot x+b.\; You\; have\; to\; compute\; what\; will\; be\; the\; experience\; index\; of\; the\; ghost\; kind GXGX in\; the\; indefinite\; future,\; this\; is\; your\; task\; for\; today.}$

Note that when Tameem took the picture, $\mathrm{GXGX may\; already\; be\; greater\; than 00,\; because\; many\; ghosts\; may\; have\; scared\; one\; another\; at\; any\; moment\; between [-\infty ,T][-\infty ,T].}$

Input

The first line contains three integers $\mathrm{nn, aa and bb (1\le n\le 2000001\le n\le 200000, 1\le |a|\le 1091\le |a|\le 109, 0\le |b|\le 1090\le |b|\le 109) —\; the\; number\; of\; ghosts\; in\; the\; universe\; and\; the\; parameters\; of\; the\; straight\; line.}$

Each of the next $\mathrm{nn lines\; contains\; three\; integers xixi, VxiVxi, VyiVyi (-109\le xi\le 109-109\le xi\le 109, -109\le Vxi,Vyi\le 109-109\le Vxi,Vyi\le 109),\; where xixi is\; the\; current xx-coordinate\; of\; the ii-th\; ghost\; (and yi=a\cdot xi+byi=a\cdot xi+b).}$

It is guaranteed that no two ghosts share the same initial position, in other words, it is guaranteed that for all $(i,j)(i,j) xi\ne xjxi\ne xj for i\ne ji\ne j.$

Output

Output one line: experience index of the ghost kind $\mathrm{GXGX in\; the\; indefinite\; future.}$

Examples

input

Copy

4 1 1
1 -1 -1
2 1 1
3 1 1
4 -1 -1

output

Copy

8

input

Copy

3 1 0
-1 1 0
0 0 -1
1 -1 -2

output

Copy

6

input

Copy

3 1 0
0 0 0
1 0 0
2 0 0

output

Copy

0

---

题意:就是有一些鬼，他们都有各自的横向速度vx和纵向速度vy，他们会一直按照这个速度走。然后在题目给出的时刻，他们全部在y=ax+b这条直线上，并给出每个鬼所处的x。然后问这些鬼每一个和其他鬼相遇的次数，并求相遇次数的总和。

题解：你可以列一个方程，其中$ x_i ,y_i $ 代表 i 在直线y=ax+b的x坐标、y坐标，$ v_{ix},v_{iy} $分别代表i的横向速度和纵向速度。对于另一个鬼j也类似。那么我们可以列出方程组：
$ x_i+t v_{ix} = x_j +v_{jx} $

$ y_i+t v_{iy} = y_j +v_{jy} $

即：

$x_i+t v_{ix} = x_j +v_{jx} $

$ a x_i+t v_{iy} = a x_j +v_{jy} $

上下两式相减可得：

$ a v_{ix} - v_{iy} = a v_{jy} - v_{jy} $

那么我们只有$ a v_{ix} - v_{iy} $相同的点才可能相遇。

因此我们要统计上式的值得点数。

但满足上式，其速度v一样的点是不可能相遇的。

因此我们在统计完上式值以后还要统计不同v下的点数。

然后对于每个相同的上式值，不同v的点对答案的贡献则是速度为v的点乘上速度不为v的点的个数。

因此写个map<LL,map<LL,LL> >是坠好的。

#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define mod 1000000007
#define clr_1(x) memset(x,-1,sizeof(x))
#define INF 0x3f3f3f3f
#define LL long long
#define pb push_back
#define pbk pop_back
using namespace std;
const int N=2e5+10;
map<LL,LL> ct;
map<LL,map<LL,LL> > num;
int n;
LL k,b,x,vx,vy;
LL ans;
int main()
{
    scanf("%d%I64d%I64d",&n,&k,&b);
    ct.clear();
    for(int i=1;i<=n;i++)
    {
        scanf("%I64d%I64d%I64d",&x,&vx,&vy);
        ct[k*vx-vy]++;
        num[k*vx-vy][vx]++;
    }
    ans=0;
    for( auto t:num)
    {
        x=t.first;
        for(auto pt:t.second)
        {
            ans+=pt.second*(ct[x]-pt.second);
        }
    }
    printf("%I64d
",ans);
    return 0;
}

E. Hag's Khashba

time limit per test

3 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Hag is a very talented person. He has always had an artist inside him but his father forced him to study mechanical engineering.

Yesterday he spent all of his time cutting a giant piece of wood trying to make it look like a goose. Anyway, his dad found out that he was doing arts rather than studying mechanics and other boring subjects. He confronted Hag with the fact that he is a spoiled son that does not care about his future, and if he continues to do arts he will cut his 25 Lira monthly allowance.

Hag is trying to prove to his dad that the wooden piece is a project for mechanics subject. He also told his dad that the wooden piece is astrictly convex polygon with $\mathrm{nn vertices.}$

Hag brought two pins and pinned the polygon with them in the $\mathrm{11-st\; and 22-nd\; vertices\; to\; the\; wall.\; His\; dad\; has qq queries\; to\; Hag\; of\; two\; types.}$

• $\mathrm{11 ff tt:\; pull\; a\; pin\; from\; the\; vertex ff,\; wait\; for\; the\; wooden\; polygon\; to\; rotate\; under\; the\; gravity\; force\; (if\; it\; will\; rotate)\; and\; stabilize.\; And\; then\; put\; the\; pin\; in\; vertex tt.}$
• $\mathrm{22 vv:\; answer\; what\; are\; the\; coordinates\; of\; the\; vertex vv.}$

Please help Hag to answer his father's queries.

You can assume that the wood that forms the polygon has uniform density and the polygon has a positive thickness, same in all points. After every query of the 1-st type Hag's dad tries to move the polygon a bit and watches it stabilize again.

Input

The first line contains two integers $\mathrm{nn and qq (3\le n\le 100003\le n\le 10000, 1\le q\le 2000001\le q\le 200000) —\; the\; number\; of\; vertices\; in\; the\; polygon\; and\; the\; number\; of\; queries.}$

The next $\mathrm{nn lines\; describe\; the\; wooden\; polygon,\; the ii-th\; line\; contains\; two\; integers xixi and yiyi (|xi|,|yi|\le 108|xi|,|yi|\le 108) —\; the\; coordinates\; of\; the ii-th\; vertex\; of\; the\; polygon.\; It\; is\; guaranteed\; that\; polygon\; is\; strictly\; convex\; and\; the\; vertices\; are\; given\; in\; the\; counter-clockwise\; order\; and\; all\; vertices\; are\; distinct.}$

The next $\mathrm{qq lines\; describe\; the\; queries,\; one\; per\; line.\; Each\; query\; starts\; with\; its\; type 11 or 22.\; Each\; query\; of\; the\; first\; type\; continues\; with\; two\; integers ff and tt (1\le f,t\le n1\le f,t\le n) —\; the\; vertex\; the\; pin\; is\; taken\; from,\; and\; the\; vertex\; the\; pin\; is\; put\; to\; and\; the\; polygon\; finishes\; rotating.\; It\; is\; guaranteed\; that\; the\; vertex ff contains\; a\; pin.\; Each\; query\; of\; the\; second\; type\; continues\; with\; a\; single\; integer vv (1\le v\le n1\le v\le n) —\; the\; vertex\; the\; coordinates\; of\; which\; Hag\; should\; tell\; his\; father.}$

It is guaranteed that there is at least one query of the second type.

Output

The output should contain the answer to each query of second type — two numbers in a separate line. Your answer is considered correct, if its absolute or relative error does not exceed ${\mathrm{10-410-4.}}^{}$

Formally, let your answer be $\mathrm{aa,\; and\; the\; jury\text{'}s\; answer\; be bb.\; Your\; answer\; is\; considered\; correct\; if |a-b|max(1,|b|)\le 10-4|a-b|max(1,|b|)\le 10-4}$

Examples

input

Copy

3 4
0 0
2 0
2 2
1 1 2
2 1
2 2
2 3

output

Copy

3.4142135624 -1.4142135624
2.0000000000 0.0000000000
0.5857864376 -1.4142135624

input

Copy

3 2
-1 1
0 0
1 1
1 1 2
2 1

output

Copy

1.0000000000 -1.0000000000

Note

In the first test note the initial and the final state of the wooden polygon.

---

题意：给定一个多边形木板（质量均匀）的所有顶点在墙上初始坐标，并把这个多边形用两个钉子钉在墙上。初始钉子在顶点1和2的位置。然后有执行q个操作，每个操作是如下一种：1是把其中一个在顶点u的钉子拔起来，等木板自然下落稳定后把钉子按在顶点v处。2是询问当前某个顶点u的坐标。

题解：我的做法是在操作的时候保存当前两个钉子所在的顶点的真实坐标，以及他们对应哪个顶点。并保存当前和重心在一条垂线上的顶点是哪个。然后刚开始的时候预处理出多边形重心。接下来按照同垂线的顶点的真实坐标，来推重心的真实位置，并求出询问顶点的坐标和更新稳定后钉子所钉顶点的真实坐标。

这题其实不卡精度，不写_float128也行。

#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define mod 1000000007
#define clr_1(x) memset(x,-1,sizeof(x))
#define INF 0x3f3f3f3f
#define LL long long
#define pb push_back
#define pbk pop_back
#define __float128 double
using namespace std;
const int N=2e5+10;
 struct point
{
    __float128 x,y;
    point() {x=0;y=0;}
    point operator + (point b)
    {
        b.x=b.x+x;
        b.y=b.y+y;
        return b;
    }
    point operator - (point b)
    {
        b.x=x-b.x;
        b.y=y-b.y;
        return b;
    }
    point operator * (point b)
    {
        b.x=x*b.x;
        b.y=y*b.y;
        return b;
    }
    point operator * (__float128 b)
    {
        point pt;
        pt.x=x*b;
        pt.y=y*b;
        return pt;
    }
    __float128 dot(point b)//点积
    {
        return x*b.x+y*b.y;
    }
    __float128 det(point b)//叉积
    {
        return x*b.y-y*b.x;
    }
    point operator / (__float128 t)
    {
        point pt;
        pt.x=x/t;
        pt.y=y/t;
        return pt;
    }
    __float128 mo()
    {
        return x*x+y*y;
    }
};
int now;
int p[2];
point pos[N],z,zb[2],vecon,zx,tp,ans,t,cx[N];
int n,q,dd,u,v;
double x,y;
__float128 s[N],sall;
bool flag;
int op;
int main()
{
    scanf("%d%d",&n,&q);
    for(int i=0;i<n;i++)
    {
        scanf("%lf%lf",&x,&y);
        pos[i].x=(__float128)x;
        pos[i].y=(__float128)y;
    }
    z.x=0;
    z.y=0;
    sall=0;
    for(int i=1;i<n-1;i++)
    {
        cx[i]=(pos[0]+pos[i]+pos[i+1])/3;
        s[i]=(pos[i]-pos[0]).det(pos[i+1]-pos[0]);
            z=z*(sall/(sall+s[i]))+cx[i]*(s[i]/(sall+s[i]));
        sall+=s[i];
    }
    zb[0]=pos[0];
    zb[1]=pos[1];
    p[0]=0;
    p[1]=1;
    now=0;
    flag=0;
    for(int i=1;i<=q;i++)
    {
        scanf("%d",&op);
        if(op==2)
        {
            scanf("%d",&dd);
            dd--;
            if(!flag)
                printf("%.13f %.13f
",(double)pos[dd].x,(double)pos[dd].y);
            else
            {
                t=pos[p[now]]-z;
                tp=pos[dd]-z;
                vecon.x=0;
                vecon.y=sqrtl(t.mo());
                zx=zb[now]-vecon;
                ans.x=zx.x*vecon.mo()+tp.x*t.dot(vecon)-tp.y*t.det(vecon);
                ans.x/=vecon.mo();
                ans.y=zx.y*vecon.mo()+tp.x*t.det(vecon)+tp.y*t.dot(vecon);
                ans.y/=vecon.mo();
                printf("%.13f %.13f
",(double)ans.x,(double)ans.y);
            }
        }
        else
        {
            flag=1;
            scanf("%d%d",&u,&v);
            u--;
            v--;
            for(int j=0;j<2;j++)
                if(p[j]==u)
                {
                    now=j^1;
                    p[j]=v;
                    break;
                }
                t=pos[p[now]]-z;
                tp=pos[p[now^1]]-z;
                vecon.x=0;
                vecon.y=sqrtl(t.mo());
                zx=zb[now]-vecon;
                zb[now^1].x=zx.x*vecon.mo()+tp.x*t.dot(vecon)-tp.y*t.det(vecon);
                zb[now^1].x/=vecon.mo();
                zb[now^1].y=zx.y*vecon.mo()+tp.x*t.det(vecon)+tp.y*t.dot(vecon);
                zb[now^1].y/=vecon.mo();
        }
    }
    return 0;
}