—— Summon, Light!

while pre.time != now.time:

aware_time = naive_time.replace(tzinfo=utc)

from datetime import datetime
date_published = datetime.strptime(date_published, "%a, %d %b %Y %H:%M:%S %z")

from datetime import datetime, timedelta, tzinfo

ZERO_TIME_DELTA = timedelta(0)
LOCAL_TIME_DELTA = timedelta(hours=8)  # 本地时区偏差


class LocalTimezone(tzinfo):
    """实现北京时间的类"""

    def utcoffset(self, dt):
        return LOCAL_TIME_DELTA

    def dst(self, dt):
        return ZERO_TIME_DELTA

    def tzname(self, dt):
        return '+08:00'


forma = "%Y-%m-%d %H:%M"
now.time = datetime.strptime(time_str, forma).replace(tzinfo=LocalTimezone())

#include <bits/stdc++.h>
using namespace std;

int main()
{
    for (int i=1;i<=33;i++) {
        for (int j=i;j<=33;j++) {
            for (int k=j;k<=33;k++) {
                if (i*i+j*j+k*k==1000) {
                    printf("%d %d %d\n",i,j,k);
                }
            }
        }
    }
    return 0;
}

#include <iostream>
using namespace std;

// ...冲突记录: Compact[i][j]=false代表点数为i的面与点数为j的面存在冲突
bool Compact[7][7];

// ...Parner[i]=j代表 点数为i的面 的对立面点数为j
const int Parner[7]={ 0,4,5,6,1,2,3 };
const long long MOD = 1000000007;

int main(int argc, char** argv)
{
    long long  N; // 骰子高度
    int M; // 冲突组数
    int s1,s2;
    cin >> N >> M;
    for( int i = 0; i < 7; ++i)
        for( int j = 0; j < 7;++j)
            Compact[i][j]=true;

    for( int i = 0; i < M; ++i ) {
        cin >> s1 >> s2;
        // ...点数为s1的面与点数为s2的面存在冲突
        Compact[s1][s2] = Compact[s2][s1] = false;
    }
    long long dp[2][7]; // 滚动数组
    long long C = 4;
    int e = 0;          // 滚动标志
    for( int i = 1; i < 7; ++i )
        dp[e][i] = 1;

    // dp[i][j]代表高度为i的,顶面点数为j的叠骰子方案数
    // 在这里忽略每个骰子可以四面转向的情况, 把该情况留到最后乘上去就可以了
    int j,k;
    for( long long i = 2; i <= N; ++i ){
        e = 1-e;    // ...滚动处理
        C = (C*4)%MOD;
        for( j = 1; j < 7; ++j ){
            dp[e][j] = 0;
            for( k = 1; k < 7; ++k)
                if( Compact[ Parner[j] ][k] )
                    dp[e][j] += dp[1-e][k];
            dp[e][j]%=MOD;
        }

    }
    int sum=0;
    for( int i = 1; i < 7; ++i)
        sum = (sum+dp[e][i])%MOD;
    sum = (sum*C)%MOD;
    cout << sum;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const int MO=1e9+7;
const int opps[]={0,4,5,6,1,2,3};

struct Mat {
    int r,c;
    ll el[10][10];
    Mat() {}
    Mat(ll x) {
        r=c=6;
        memset(el,0,sizeof(el));
        for (int i=1;i<=r;i++) {
            el[i][i]=x;
        }
    }
    Mat(int _r,int _c,ll x) {
        r=_r;c=_c;
        for (int i=1;i<=r;i++) {
            for (int j=1;j<=c;j++) {
                el[i][j]=x;
            }
        }
    }
    Mat operator *(const Mat &b) {
        Mat res(r,b.c,0);
        for (int i=1;i<=r;i++) {
            for (int j=1;j<=b.c;j++) {
                for (int k=1;k<=c;k++) {
                    res.el[i][j]+=el[i][k]*b.el[k][j];
                }
            }
        }
        return res;
    }
    Mat operator %(const int Mo) {
        for (int i=1;i<=r;i++) {
            for (int j=1;j<=c;j++) {
                el[i][j]=el[i][j]%Mo;
            }
        }
        return (*this);
    }
    void print() {
        for (int i=1;i<=r;i++) {
            for (int j=1;j<=c;j++) {
                printf("%I64d ",el[i][j]);
            }
            puts("");
        }
    }
};

template <class DataType>
DataType fpow(DataType x,int n)
{
    DataType res(1);
    while (n) {
        if (n&1) {
            res=x*res%MO;
        }
        x=x*x%MO;
        n>>=1;
    }
    return res;
}

int main()
{
    int n,m;
    Mat coop(6,6,1);
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++) {
        int x,y;
        scanf("%d%d",&x,&y);
        coop.el[x][opps[y]]=0;
        coop.el[y][opps[x]]=0;
    }
    coop=fpow(coop,n-1);
    Mat cnt(6,1,1);
    cnt=coop*cnt%MO;
    ll ans=0,fo=4;
    for (int i=1;i<=6;i++) {
        ans=(ans+cnt.el[i][1])%MO;
    }
    ans=ans*fpow(fo,n)%MO;
    printf("%I64d\n",ans);
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<int,int> PII;
PII a[6],b[6];

inline void input(PII a[],int &n)
{
    scanf("%d",&n);
    for (int i=0;i<n;i++) {
        int x,y;
        scanf("%d%d",&x,&y);
        a[i]=PII(x,y);
    }
}

inline void check(PII a[],int n,int &X,int &x,int &Y,int &y,int &strt)
{
    X=x=Y=y=strt=0;
    for (int i=0;i<n;i++) {
        if (a[i].first==a[(i+1)%n].first) {
            strt++;
            int tmp=abs(a[i].second-a[(i+1)%n].second);
            if (tmp>Y) y=Y,Y=tmp;
            else y=tmp;
        } else if (a[i].second==a[(i+1)%n].second) {
            strt++;
            int tmp=abs(a[i].first-a[(i+1)%n].first);
            if (tmp>X) x=X,X=tmp;
            else x=tmp;
        }
    }
}

inline bool penta(int n,int m)
{
    int x,X,y,Y,strt;
    check(b,m,X,x,Y,y,strt);
    if (strt!=m-1) return false;
    int A=Y-y,B=X-x;
    check(a,n,X,x,Y,y,strt);
    if (strt!=n-1) return false;
    return (X==A&&Y==B)||(X==B&&Y==A);
}

bool quaqua()
{
    int x,X,y,Y,strt;
    check(b,4,X,x,Y,y,strt);
    if (strt<3) return false;
    if (strt==4) {
        int A=X,B=Y;
        check(a,4,X,x,Y,y,strt);
        if (strt!=4) return false;
        return A==X||A==Y||B==X||B==Y;
    }
    int height,A,B;
    if (y==0) {
        height=Y;A=X;B=x;
    } else {
        height=X;A=Y;B=y;
    }
    check(a,4,X,x,Y,y,strt);
    if (strt<3) return false;
    if (y==0) {
        return height==Y&&x+A==X+B;
    } else {
        return height==X&&y+A==Y+B;
    }
}

int main()
{
    int T,n,m;
    scanf("%d",&T);
    while (T--) {
        input(a,n);
        input(b,m);
        if (n>m) {
            swap(n,m);
            swap(a,b);
        }
        bool f=false;
        if (n==4&&m==4) f=quaqua();
        else f=penta(n,m);
        puts(f?"YES":"NO");
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const int N=110;
const ll MAX=1000000000000;
ll a[N];

ll gcd(ll a,ll b)
{
    if (!b) return a;
    return gcd(b,a%b);
}

struct Frac
{
    ll up,dw;
    Frac() {}
    Frac(ll a,ll b) {
        if (a==0) {
            up=0;dw=1;
            return;
        }
        ll g=gcd(a,b);
        up=a/g;dw=b/g;
    }
    bool operator <(const Frac &b) const {
        return up*b.dw<dw*b.up;
    }
    bool operator ==(const Frac &b) const {
        return !((*this)<b)&&!(b<(*this));
    }
    Frac operator /(const Frac &b) {
        return Frac(up*b.dw,dw*b.up);
    }
    void print() {
        printf("%I64d/%I64d\n",up,dw);
    }
} f[N];

int main()
{
    int n;
    scanf("%d",&n);
    for (int i=0;i<n;i++) {
        scanf("%I64d",&a[i]);
    }
    sort(a,a+n);
    n=unique(a,a+n)-a-1;
    for (int i=0;i<n;i++) {
        f[i]=Frac(a[i+1],a[i]);
    }
    Frac ans(MAX,1);
    while (n>1) {
        sort(f,f+n);
        if (f[0]<ans) ans=f[0];
        n=unique(f,f+n)-f-1;
        for (int i=0;i<n;i++) {
            f[i]=f[i+1]/f[i];
        }
    }
    if (f[0]<ans) ans=f[0];
    ans.print();
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main()
{
    for (int i=1;i<=100;i++) {
        int sum=0,j=i;
        while (sum<236) {
            sum+=j++;
        }
        if (sum==236) {
            printf("%d %d\n",i,j);
        }
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
const double PI=acos(-1.0);
const int MO=313;
const int N=100010;
struct Complex {
    double x,y;
    Complex(double _x = 0.0,double _y = 0.0)
    {
        x = _x;
        y = _y;
    }
    Complex operator -(const Complex &b)const
    {
        return Complex(x-b.x,y-b.y);
    }
    Complex operator +(const Complex &b)const
    {
        return Complex(x+b.x,y+b.y);
    }
    Complex operator *(const Complex &b)const
    {
        return Complex(x*b.x-y*b.y,x*b.y+y*b.x);
    }
} x[280000],y[280000];
int a[N],dp[N];

void change(Complex y[],int len)
{
    int i,j,k;
    for(i = 1, j = len/2; i <len-1; i++) {
        if(i < j)swap(y[i],y[j]);
        k = len/2;
        while(j >= k) {
            j -= k;
            k /= 2;
        }
        if(j < k)j += k;
    }
}
void fft(Complex y[],int len,int on)
{
    change(y,len);
    for(int h = 2; h <= len; h <<= 1) {
        Complex wn(cos(-on*2*PI/h),sin(-on*2*PI/h));
        for(int j = 0; j < len; j+=h) {
            Complex w(1,0);
            for(int k = j; k < j+h/2; k++) {
                Complex u = y[k];
                Complex t = w*y[k+h/2];
                y[k] = u+t;
                y[k+h/2] = u-t;
                w = w*wn;
            }
        }
    }
    if(on == -1) {
        for(int i = 0; i < len; i++)
            y[i].x /= len;
    }
}

void cdq(int l,int r)
{
    if (l==r) {
        dp[l]+=a[l];
        dp[l]%=MO;
        return;
    }
    int mid=(l+r)>>1;
    cdq(l,mid);
    int len1=mid-l+1;
    int len2=r-l+1;
    int len=1;
    while (len<=len2) len<<=1;
    for (int i=0;i<len1;i++) {
        x[i]=Complex(dp[l+i],0);
    }
    for (int i=len1;i<len;i++) {
        x[i]=Complex(0,0);
    }
    for (int i=0;i<len2;i++) {
        y[i]=Complex(a[i],0);
    }
    for (int i=len2;i<len;i++) {
        y[i]=Complex(0,0);
    }
    fft(x,len,1);
    fft(y,len,1);
    for (int i=0;i<len;i++) {
        x[i]=x[i]*y[i];
    }
    fft(x,len,-1);
    for (int i=mid+1;i<=r;i++) {
        dp[i]+=round(x[i-l].x);
        dp[i]%=MO;
    }
    cdq(mid+1,r);
}

int main()
{
    int n;
    while (scanf("%d",&n),n) {
        for (int i=1;i<=n;i++) {
            scanf("%d",&a[i]);
            a[i]%=MO;
        }
        memset(dp,0,sizeof(dp));
        dp[0]=1;
        cdq(1,n);
        printf("%d\n",dp[n]);
    }
    return 0;
}