#include <iostream>
using namespace std;

int main() {
    while(1) cout << "mc启动！！！脑叶启动！！！太空鲨启动！！！猫鼠启动！！！" << endl;
    return 0;
}

初墨，多么优雅的名字——可惜他姓熊

拔杰，多么高端的名字——可惜他姓朱

渔歌，多么诗意的名字——可惜他姓章

楚衢，多么凝重的名字——可惜他姓滚

巅峰，多么上进的名字——可惜他姓杨

紫藤，多么大气的名字——可惜他姓杜

晶斌，多么文静的名字——可惜他姓沈

泥马，多么深奥的名字——可惜他姓曹

珍香，多么秀丽的名字——可惜他姓史

达野，多么磅礴的名字——可惜他姓尼

仁范，多么仁慈的名字——可惜他姓沙

塞克，多么科技的名字——可惜他姓马

思，多么文静的名字——可惜他姓刁

语文老师一回头，此地空无黄鹤楼。

数学老师一回头，二次函数对称轴。

英语老师一回头，Sorry加上三克油。

历史老师一回头，秦始皇来打酱油。

化学老师一回头，二氧化碳变汽油。

生物老师一回头，试管婴儿水中游。

音乐老师一回头，打着节拍摇着头。

政治老师一回头，学霸学渣搞金融。

美术老师一回头，蒙娜丽莎也风流。

物理老师一回头，阿基米德要跳楼。

天文老师一回头，火星也来撞地球。

地理老师一回头，地球原来是个球。

体育老师一回头，乔丹改打乒乓球。

电脑老师一回头，学生请假有理由。

足球老师一回头，全班同学都梦游。

建筑老师一回头，吓塌一栋七层楼。

心理老师一回头，癞蛤蟆也变温柔。

劳技老师一回头，破铜烂铁来走秀。

科学老师一回头，日食月食每天有。

思品老师一回头，鲁迅甘为孺子牛。

综合老师一回头，就算是鬼也发愁。

全体老师一回头，全体学生没自由。

你不得不承认，7个事实

1.你的脖子转不了两圈。

2.你数不了你有多少头发。

3.当你舌头伸出来的时候你不能用鼻子呼吸。 

4.你正在做第三条。

5.当你在做第三条的时候，其实你觉得是可行的，但是你看起来会像条小狗一样。

6.你现在在笑，因为我把你整了。

7.分享出去，你就可以整别人报仇了。

哈哈哈！！！

"AC=Answer Coarse=粗劣的答案"

"WA=Wonderful Answer=好答案"

"TLE=Time Limit Enough=时间充裕"

"MLE=Memory Limit Enough=内存充裕"

"CE=Compile Easily=轻松通过编译"

"RE=Run Excellently=完美运行"

"UKE=Unbelievablly Keep Enough Score=难以置信地保持足够的分数"

"AU=All Unaccepted=全都不正确"

#include <iostream>
#include <cstdio>

using namespace std;

int main() {
    int a,b;
    cin >> a >> b;
    cout << a+b;
    return 0;
}

#include<iostream>
#include<cstring>
using namespace std;
int lowbit(int a)
{
    return a&(-a);
}
int main()
{
    int n=2,m=1;
    int ans[m+1];
    int a[n+1],c[n+1],s[n+1];
    int o=0;
    memset(c,0,sizeof(c));
    s[0]=0;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        s[i]=s[i-1]+a[i];
        c[i]=s[i]-s[i-lowbit(i)];//树状数组创建前缀和优化
    }
    for(int i=1;i<=m;i++)
    {
        int q=2;
        //if(q==1)
        //{（没有更改操作）
        //    int x,y;
        //    cin>>x>>y;
        //    int j=x;
        //    while(j<=n)
        //    {
        //        c[j]+=y;
        //        j+=lowbit(j);
        //    }
        //}
        //else
        //{
            int x=1,y=2;//求a[1]+a[2]的和
            int s1=0,s2=0,p=x-1;
            while(p>0)
            {
                s1+=c[p];
                p-=lowbit(p);//树状数组求和操作，用两个前缀和相减得到区间和
            }
            p=y;
            while(p>0)
            {
                s2+=c[p];
                p-=lowbit(p);
            }    
            o++;
            ans[o]=s2-s1;//存储答案
        //}
    }
    for(int i=1;i<=o;i++)
        cout<<ans[i]<<endl;//输出
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <climits>
#include <algorithm>
#include <map>
#include <queue>
#include <vector>
#include <ctime>
#include <string>
#include <cstring>
using namespace std;
const int N=405;
struct Edge {
    int v,w;
};
vector<Edge> edge[N*N];
int n;
int dis[N*N];
bool vis[N*N];
struct cmp {
    bool operator()(int a,int b) {
        return dis[a]>dis[b];
    }
};
int Dijkstra(int start,int end)
{
    priority_queue<int,vector<int>,cmp> dijQue;
    memset(dis,-1,sizeof(dis));
    memset(vis,0,sizeof(vis));
    dijQue.push(start);
    dis[start]=0;
    while(!dijQue.empty()) {
        int u=dijQue.top();
        dijQue.pop();
        vis[u]=0;
        if(u==end)
            break;
        for(int i=0; i<edge[u].size(); i++) {
            int v=edge[u][i].v;
            if(dis[v]==-1 || dis[v]>dis[u]+edge[u][i].w) {
                dis[v]=dis[u]+edge[u][i].w;
                if(!vis[v]) {
                    vis[v]=true;
                    dijQue.push(v);
                }
            }
        }
    }
    return dis[end];
}
int main()
{
    int a,b;
    scanf("%d%d",&a,&b);
    Edge Qpush;
    
    Qpush.v=1;
    Qpush.w=a;
    edge[0].push_back(Qpush);
    
    Qpush.v=2;
    Qpush.w=b;
    edge[1].push_back(Qpush);
    
    printf("%d",Dijkstra(0,2));
    return 0;
}

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
using namespace std;
struct node{
    int str[26];
    int sum;
}s[1000];
char str1[100];
int t=0,tot=0,ss=0;
bool f1;
void built()
{
    t=0;
    for(int i=0;i<strlen(str1);i++)
    {
         if(str1[i]=='-'){
             f1=true;continue;
         }
         if(!s[t].str[str1[i]-'0'])
         s[t].str[str1[i]-'0']=++tot;
         t=s[t].str[str1[i]-'0'];
         s[t].sum=str1[i]-'0';
    }
}
int query()
{
   int t=0;int s1=0;
   for(int i=0;i<strlen(str1);i++)
   {
           if(str1[i]=='-') continue;
           if(!s[t].str[str1[i]-'0']) return s1;
           t=s[t].str[str1[i]-'0'];
           s1=s1*10+s[t].sum;
   }
   return s1;
}
int main()
{    
  for(int i=1;i<=2;i++)
  {
      f1=false;
      scanf("%s",str1);
    built();
    if(f1)
      ss-=query();
      else ss+=query();
  }
  printf("%d",ss);
  return 0;    
}

#include<cstdio>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<iostream>
using namespace std;
struct node{
    int val,l,r;
};
node t[5];
int a[5],f[5];
int n,m;
void init(){
    for(int i=1;i<=2;i++){
        scanf("%d",&a[i]);
    }
}
void build(int l,int r,int node){//这是棵树
    t[node].l=l;t[node].r=r;t[node].val=0;
    if(l==r){
        f[l]=node;
        t[node].val=a[l];
        return;
    }
    int mid=(l+r)>>1;
    build(l,mid,node*2);
    build(mid+1,r,node*2+1);
    t[node].val=t[node*2].val+t[node*2+1].val;
}
void update(int node){
    if(node==1)return;
    int fa=node>>1;
    t[fa].val=t[fa*2].val+t[fa*2+1].val;
    update(fa);
}
int find(int l,int r,int node){
    if(t[node].l==l&&t[node].r==r){
        return t[node].val;
    }
    int sum=0;
    int lc=node*2;int rc=lc+1;
    if(t[lc].r>=l){
        if(t[lc].r>=r){
            sum+=find(l,r,lc);
        }
        else{
            sum+=find(l,t[lc].r,lc);
        }
    }
    if(t[rc].l<=r){
        if(t[rc].l<=l){
            sum+=find(l,r,rc);
        }
        else{
            sum+=find(t[rc].l,r,rc);
        }
    }
    return sum;
}
int main(){
    init();
    build(1,2,1);
    printf("%d",find(1,2,1));
}

#include <cstdio>
#include <algorithm>
#define INF 2140000000
using namespace std;
struct tree{int x,y,t;}a[10];
bool cmp(const tree&a,const tree&b){return a.t<b.t;}
int f[11],i,j,k,n,m,x,y,t,ans;
int root(int x){if (f[x]==x) return x;f[x]=root(f[x]);return f[x];}
int main(){
    for (i=1;i<=10;i++) f[i]=i;
    for (i=1;i<=2;i++){
        scanf("%d",&a[i].t);
        a[i].x=i+1;a[i].y=1;k++;
    }
    a[++k].x=1;a[k].y=3,a[k].t=INF;
    sort(a+1,a+1+k,cmp);
    for (i=1;i<=k;i++){
    //    printf("%d %d %d %d\n",k,a[i].x,a[i].y,a[i].t);
        x=root(a[i].x);y=root(a[i].y);
        if (x!=y) f[x]=y,ans+=a[i].t; 
    }
    printf("%d\n",ans);
}

//一颗资瓷区间加、区间翻转、区间求和的Splay
#include <bits/stdc++.h>
#define ll long long
#define N 100000
using namespace std;
int sz[N], rev[N], tag[N], sum[N], ch[N][2], fa[N], val[N];
int n, m, rt, x;
void push_up(int x){
    sz[x] = sz[ch[x][0]] + sz[ch[x][1]] + 1;
    sum[x] = sum[ch[x][1]] + sum[ch[x][0]] + val[x];
}
void push_down(int x){
    if(rev[x]){
        swap(ch[x][0], ch[x][1]);
        if(ch[x][1]) rev[ch[x][1]] ^= 1;
        if(ch[x][0]) rev[ch[x][0]] ^= 1;
        rev[x] = 0;
    }
    if(tag[x]){
        if(ch[x][1]) tag[ch[x][1]] += tag[x], sum[ch[x][1]] += tag[x];
        if(ch[x][0]) tag[ch[x][0]] += tag[x], sum[ch[x][0]] += tag[x];
        tag[x] = 0;
    }
}
void rotate(int x, int &k){
    int y = fa[x], z = fa[fa[x]];
    int kind = ch[y][1] == x;
    if(y == k) k = x;
    else ch[z][ch[z][1]==y] = x;
    fa[x] = z; fa[y] = x; fa[ch[x][!kind]] = y;
    ch[y][kind] = ch[x][!kind]; ch[x][!kind] = y;
    push_up(y); push_up(x);
}
void splay(int x, int &k){
    while(x != k){
        int y = fa[x], z = fa[fa[x]];
        if(y != k) if(ch[y][1] == x ^ ch[z][1] == y) rotate(x, k);
        else rotate(y, k);
        rotate(x, k);
    }
}
int kth(int x, int k){
    push_down(x);
    int r = sz[ch[x][0]]+1;
    if(k == r) return x;
    if(k < r) return kth(ch[x][0], k);
    else return kth(ch[x][1], k-r);
}
void split(int l, int r){
    int x = kth(rt, l), y = kth(rt, r+2);
    splay(x, rt); splay(y, ch[rt][1]);
}
void rever(int l, int r){
    split(l, r);
    rev[ch[ch[rt][1]][0]] ^= 1;
}
void add(int l, int r, int v){
    split(l, r);
    tag[ch[ch[rt][1]][0]] += v;
    val[ch[ch[rt][1]][0]] += v;
    push_up(ch[ch[rt][1]][0]);
}
int build(int l, int r, int f){
    if(l > r) return 0;
    if(l == r){
        fa[l] = f;
        sz[l] = 1;
        return l;
    }
    int mid = l + r >> 1;
    ch[mid][0] = build(l, mid-1, mid);
    ch[mid][1] = build(mid+1, r, mid);
    fa[mid] = f;
    push_up(mid);
    return mid;
}
int asksum(int l, int r){
    split(l, r);
    return sum[ch[ch[rt][1]][0]];
}
int main(){
    //总共两个数
    n = 2;
    rt = build(1, n+2, 0);//建树
    for(int i = 1; i <= n; i++){
        scanf("%d", &x);
        add(i, i, x);//区间加
    }
    rever(1, n);//区间翻转
    printf("%d\n", asksum(1, n));//区间求和
    return 0;
}

______      ______  __  __      ______   _____   ______     
/\__  _\    /\  _  \/\ \/\ \    /\__  _\ /\  __ \/\__  _\    
\/_/\ \/    \ \ \ \ \ \ \/ /    \/_/\ \/ \ \ \/\ \/_/\ \/    
   \ \ \     \ \  __ \ \   <       \ \ \  \ \ \ \ \ \ \ \    
    \_\ \__   \ \ \/\ \ \ \\ \      \_\ \__\ \ \_\ \ \_\ \__ 
    /\_____\   \ \_\ \_\ \_\ \_\    /\_____\\ \_____\/\_____\
    \/_____/    \/_/\/_/\/_/\/_/    \/_____/ \/_____/\/_____/