Latex代码测试

最新推荐文章于 2021-09-04 21:02:58 发布

原创最新推荐文章于 2021-09-04 21:02:58 发布 · 1.5k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#latex #扩展的灰

这篇博客主要介绍了如何使用LaTeX进行字符串匹配算法的实现，包括SAM、AAM和BAM算法，并展示了大整数的加减乘除运算。通过代码示例，阐述了字符串匹配的原理以及大整数运算的处理方法，适合对算法和数学计算感兴趣的读者阅读。

$#include<queue>\#include<queue>$
$#include<stdio.h>\#include<stdio.h>$
$#include<string.h>\#include<string.h>$
$#include<algorithm>\#include<algorithm>$
$4010\#define\ N\ 4010$
$std;using\ namespace\ std;$
$struct\ V\{\ int\ x,y,d;\ \}\ z;$
$q;char\ A[N],B[N];\ int\ n,m,l[N],f[N][N];\ queue<V>\ q;$
${namespace\ SAM\{$
$s[N][26],mx[N],f[N],cnt=1,lst=1;\quad int\ s[N][26],mx[N],f[N],cnt=1,lst=1;$
$c){\quad inline\ int\ extend(int\ c)\{$
$p=lst,np=lst=++cnt,q,nq;\quad \quad int\ p=lst,np=lst=++cnt,q,nq;$
$mx[np]=mx[p]+1;\quad \quad mx[np]=mx[p]+1;$
$s[p][c]=np;\quad \quad for(;p\&\&!s[p][c];p=f[p])\ s[p][c]=np;$
$f[np]=1;\quad \quad if(!p)\ return\ f[np]=1;$
$q=s[p][c];\quad \quad q=s[p][c];$
$f[np]=q;\quad \quad if(mx[q]==mx[p]+1)\ f[np]=q;$
$else{\quad \quad else\{$
$nq=++cnt;\quad \quad \quad nq=++cnt;$
$mx[nq]=mx[p]+1;\quad \quad \quad mx[nq]=mx[p]+1;$
$f[q]=f[np]=nq;\quad \quad \quad f[nq]=f[q];\ f[q]=f[np]=nq;$
$memcpy(s[nq],s[q],26<<2);\quad \quad \quad memcpy(s[nq],s[q],26<<2);$
$s[p][c]=nq;\quad \quad \quad for(;p\&\&s[p][c]==q;p=f[p])\ s[p][c]=nq;$
$}\quad \quad \}$
$}\quad \}$
$match(){\quad inline\ void\ match()\{$
$x=1,i=1,c=0;i<=n;++i){\quad \quad for(int\ x=1,i=1,c=0;i<=n;++i)\{$
$!s[x][A[i]−′a′];x=f[x]);\quad \quad \quad for(;x>1\ \&\&\ !s[x][A[i]-'a'];x=f[x]);$
$c=mx[x];\quad \quad \quad c=mx[x];$
$else{\quad \quad \quad if(!s[x][A[i]-'a'])\ l[i]=0;\ else\{$
$l[i]=++c;\quad \quad \quad \quad x=s[x][A[i]-'a'];\ l[i]=++c;$
$}\quad \quad \quad \}$
$}\quad \quad \}$
$}\quad \}$
$}\}$
${namespace\ AAM\{$
$s[N][26];\quad int\ s[N][26];$
$build(){\quad inline\ void\ build()\{$
$i=1;i<=n;++i)\quad \quad for(int\ i=1;i<=n;++i)$
$j=i−1;;−−j){\quad \quad \quad for(int\ j=i-1;;--j)\{$
$s[j][A[i]−′a′]=i;\quad \quad \quad \quad s[j][A[i]-'a']=i;$
$break;\quad \quad \quad \quad if(A[j]==A[i]\ ||\ !j)\ break;$
$}\quad \quad \quad \}$
$}\quad \}$
$}\}$
${namespace\ BAM\{$
$s[N][26];\quad int\ s[N][26];$
$build(){\quad inline\ void\ build()\{$
$i=1;i<=m;++i)\quad \quad for(int\ i=1;i<=m;++i)$
$j=i−1;;−−j){\quad \quad \quad for(int\ j=i-1;;--j)\{$
$s[j][B[i]−′a′]=i;\quad \quad \quad \quad s[j][B[i]-'a']=i;$
$break;\quad \quad \quad \quad if(B[j]==B[i]\ ||\ !j)\ break;$
$}\quad \quad \quad \}$
$}\quad \}$
$}\}$
${inline\ void\ dfs(int\ x,int\ y,int\ d)\{$
$i=0;i<26;++i)\quad for(int\ i=0;i<26;++i)$
$if(AAM::s[x][i]&&!SAM::s[y][i]){\quad \quad if(AAM::s[x][i]\&\&!SAM::s[y][i])\{$
$return;\quad \quad \quad *l=min(*l,d+1);\ return;$
$}\quad \quad \}$
$i=0;i<26;++i)\quad for(int\ i=0;i<26;++i)$
$if(AAM::s[x][i]&&SAM::s[y][i])\quad \quad if(AAM::s[x][i]\&\&SAM::s[y][i])$
$dfs(AAM::s[x][i],SAM::s[y][i],d+1);\quad \quad \quad dfs(AAM::s[x][i],SAM::s[y][i],d+1);$
$}\}$
${int\ main()\{$
$scanf("%s%s",A+1,B+1);\quad scanf("\%s\%s",A+1,B+1);$
$m=strlen(B+1);\quad n=strlen(A+1);\ m=strlen(B+1);$
$SAM::extend(B[i]−′a′);\quad for(int\ i=1;i<=n;++i)\ SAM::extend(B[i]-'a');$
$SAM::match();\quad SAM::match();$
$BAM::build();\quad AAM::build();\ BAM::build();$
$∗l=min(∗l,l[i]+1);\quad *l=n;\ for(int\ i=1;i<=n;++i)\ if(l[i]<i)\ *l=min(*l,l[i]+1);$
$printf("%d\n",∗l); ∗l=n;\quad printf("\%d\backslash n",*l);\ *l=n;$
$i=1;i<=n;++i){\quad for(int\ i=1;i<=n;++i)\{$
$x=0;\quad \quad int\ x=0;$
$j=i;j<=n;++j){\quad \quad for(int\ j=i;j<=n;++j)\{$
$x=BAM::s[x][A[j]−′a′];\quad \quad \quad x=BAM::s[x][A[j]-'a'];$
$}\quad \quad \quad if(!x)\{\ *l=min(*l,j-i+1);\ break;\ \}$
$}\quad \quad \}$
$}\quad \}$
$printf("%d\n",∗l); dfs(0,1,0);\quad printf("\%d\backslash n",*l);\ dfs(0,1,0);$
$printf("%d\n",∗l); ∗l=n;\quad printf("\%d\backslash n",*l);\ *l=n;$
$q.push((V){0,0,0});\quad q.push((V)\{0,0,0\});$
$x,y,d;!q.empty();q.pop()){\quad for(int\ x,y,d;!q.empty();q.pop())\{$
$z=q.front();\quad \quad z=q.front();$
$i=0;i<26;++i)if(x=AAM::s[z.x][i]){\quad \quad for(int\ i=0;i<26;++i)if(x=AAM::s[z.x][i])\{$
$printf("%d\n",z.d+1); return 0; }\quad \quad \quad if(!(y=BAM::s[z.y][i]))\{\ printf("\%d\backslash n",z.d+1);\ return\ 0;\ \}$
$}\quad \quad \quad else\ if(!f[x][y])\{\ f[x][y]=1;\ q.push((V)\{x,y,z.d+1\});\ \}$
$}\quad \quad \}$
$}\quad \}$
$}\}$

$<cstdio>\#include\ <cstdio>$
$<iostream>\#include\ <iostream>$
$<algorithm>\#include\ <algorithm>$
$<cstring>\#include\ <cstring>$
$<cstring>\#include\ <cstring>$
$<cmath>\#include\ <cmath>$

$ll;typedef\ long\ long\ ll;$

$moder)int\ powermod(int\ a,\ int\ exp,\ int\ moder)$
${\{$
$1;\ \ \ \ int\ ret\ =\ 1;$
$1)\ \ \ \ for\ (;\ exp;\ exp\ >>=\ 1)$
${\ \ \ \ \{$
$1)\ \ \ \ \ \ \ \ if\ (exp\ \&\ 1)$
${\ \ \ \ \ \ \ \ \{$
$moder;\ \ \ \ \ \ \ \ \ \ \ \ ret\ =\ 1ll\ *\ ret\ *\ a\ \%\ moder;$
$}\ \ \ \ \ \ \ \ \}$
$moder;\ \ \ \ \ \ \ \ a\ =\ 1ll\ *\ a\ *\ a\ \%\ moder;$
$}\ \ \ \ \}$
$ret;\ \ \ \ return\ ret;$
$}\}$

$type)void\ addminus(int\ *a,\ int\ *b,\ int\ \&lengtha,\ int\ \&lengthb,\ int\ type)$
${\{$
$lengthb);\ \ \ \ int\ length\ =\ std::max(lengtha,\ lengthb);$
$++i)\ \ \ \ for\ (int\ i\ =\ 0;\ i\ <\ length;\ ++i)$
${\ \ \ \ \{$
$−b[i];\ \ \ \ \ \ \ \ a[i]\ +=\ type\ ==\ 1\ ?\ b[i]\ :\ -b[i];$
$0;\ \ \ \ \ \ \ \ a[i]\ >=\ 10\ ?\ (a[i]\ -=\ 10,\ ++a[i\ +\ 1])\ :\ a[i]\ <\ 0\ ?\ (a[i]\ +=\ 10,\ --a[i\ +\ 1])\ :\ 0;$
$}\ \ \ \ \}$
$;\ \ \ \ for\ (lengtha\ =\ length\ +\ 1;\ lengtha\ \&\&\ !a[lengtha\ -\ 1];\ --lengtha)\ ;$
$}\}$

$BigIntegerstruct\ BigInteger$
${\{$
$19;\ \ \ \ const\ static\ int\ MAXN\ =\ 19;$
$998244353\ \ \ \ const\ static\ int\ MOD\ =\ (119\ <<\ 23)\ +\ 1;\ \ \ //\ \ 998244353$
$3;\ \ \ \ const\ static\ int\ root\ =\ 3;$
$332748118;\ \ \ \ const\ static\ int\ invroot\ =\ 332748118;$

$MAXN];\ \ \ \ int\ a[1\ <<\ MAXN];$
$sig;\ \ \ \ int\ length,\ sig;$

$BigInteger()\ \ \ \ BigInteger()$
${\ \ \ \ \{$
$sizeof(a));\ \ \ \ \ \ \ \ memset(a,\ 0,\ sizeof(a));$
$0;\ \ \ \ \ \ \ \ length\ =\ sig\ =\ 0;$
$}\ \ \ \ \}$

$clear()\ \ \ \ void\ clear()$
${\ \ \ \ \{$
$length);\ \ \ \ \ \ \ \ memset(a,\ 0,\ sizeof(int)\ *\ length);$
$0;\ \ \ \ \ \ \ \ length\ =\ sig\ =\ 0;$
$}\ \ \ \ \}$

$read()\ \ \ \ void\ read()$
${\ \ \ \ \{$
$clear();\ \ \ \ \ \ \ \ clear();$
$getchar();\ \ \ \ \ \ \ \ char\ ch\ =\ getchar();$
$;\ \ \ \ \ \ \ \ for\ (;\ (ch\ <\ '0'\ ||\ ch\ >\ '9')\ \&\&\ ch\ !=\ '-';\ ch\ =\ getchar())\ ;$
$1;\ \ \ \ \ \ \ \ ch\ ==\ '-'\ ?\ (sig\ =\ -1,\ ch\ =\ getchar())\ :\ sig\ =\ 1;$
$getchar())\ \ \ \ \ \ \ \ for\ (;\ ch\ >=\ '0'\ \&\&\ ch\ <=\ '9';\ ch\ =\ getchar())$
${\ \ \ \ \ \ \ \ \{$
$′0′;\ \ \ \ \ \ \ \ \ \ \ \ a[length\ ++]\ =\ ch\ -\ '0';$
$}\ \ \ \ \ \ \ \ \}$
$length);\ \ \ \ \ \ \ \ std::reverse(a,\ a\ +\ length);$
$;\ \ \ \ \ \ \ \ for\ (;\ length\ \&\&\ !a[length\ -\ 1];\ --length)\ ;$
$0;\ \ \ \ \ \ \ \ sig\ =\ length\ ?\ sig\ :\ 0;$
$}\ \ \ \ \}$

$write()\ \ \ \ void\ write()$
${\ \ \ \ \{$
$(!sig)\ \ \ \ \ \ \ \ if\ (!sig)$
${\ \ \ \ \ \ \ \ \{$
$(void)putchar(′0′);\ \ \ \ \ \ \ \ \ \ \ \ return\ (void)putchar('0');$
$}\ \ \ \ \ \ \ \ \}$
$0)\ \ \ \ \ \ \ \ if\ (sig\ <\ 0)$
${\ \ \ \ \ \ \ \ \{$
$putchar(′−′);\ \ \ \ \ \ \ \ \ \ \ \ putchar('-');$
$}\ \ \ \ \ \ \ \ \}$
$i−−)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ length\ -\ 1;\ i\ >=\ 0;\ i--)$
${\ \ \ \ \ \ \ \ \{$
$′0′);\ \ \ \ \ \ \ \ \ \ \ \ putchar(a[i]\ +\ '0');$
$}\ \ \ \ \ \ \ \ \}$
$}\ \ \ \ \}$

$T>\ \ \ \ template\ <typename\ T>$
$tointeger()\ \ \ \ T\ tointeger()$
${\ \ \ \ \{$
$0;\ \ \ \ \ \ \ \ T\ ret\ =\ 0;$
$++i)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ length\ -\ 1;\ i\ >=\ 0;\ ++i)$
${\ \ \ \ \ \ \ \ \{$
$a[i];\ \ \ \ \ \ \ \ \ \ \ \ ret\ =\ ret\ *\ 10\ +\ a[i];$
$}\ \ \ \ \ \ \ \ \}$
$sig;\ \ \ \ \ \ \ \ return\ ret\ *\ sig;$
$}\ \ \ \ \}$

$&p)\ \ \ \ bool\ equal(const\ BigInteger\ \&p)$
${\ \ \ \ \{$
$p.length)\ \ \ \ \ \ \ \ if\ (sig\ !=\ p.sig\ ||\ length\ !=\ p.length)$
${\ \ \ \ \ \ \ \ \{$
$false;\ \ \ \ \ \ \ \ \ \ \ \ return\ false;$
$}\ \ \ \ \ \ \ \ \}$
$++i)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ 0;\ i\ <\ length;\ ++i)$
${\ \ \ \ \ \ \ \ \{$
$p.a[i])\ \ \ \ \ \ \ \ \ \ \ \ if\ (a[i]\ !=\ p.a[i])$
${\ \ \ \ \ \ \ \ \ \ \ \ \{$
$false;\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ return\ false;$
$}\ \ \ \ \ \ \ \ \ \ \ \ \}$
$}\ \ \ \ \ \ \ \ \}$
$true;\ \ \ \ \ \ \ \ return\ true;$
$}\ \ \ \ \}$

$&p)\ \ \ \ bool\ greater(const\ BigInteger\ \&p)$
${\ \ \ \ \{$
$p.sig)\ \ \ \ \ \ \ \ if\ (sig\ !=\ p.sig)$
${\ \ \ \ \ \ \ \ \{$
$p.sig;\ \ \ \ \ \ \ \ \ \ \ \ return\ sig\ >\ p.sig;$
$}\ \ \ \ \ \ \ \ \}$
$p.length)\ \ \ \ \ \ \ \ if\ (length\ !=\ p.length)$
${\ \ \ \ \ \ \ \ \{$
$−1;\ \ \ \ \ \ \ \ \ \ \ \ return\ length\ >\ p.length\ \wedge \ sig\ ==\ -1;$
$}\ \ \ \ \ \ \ \ \}$
$−−i)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ length\ -\ 1;\ i\ >=\ 0;\ --i)$
${\ \ \ \ \ \ \ \ \{$
$p.a[i])\ \ \ \ \ \ \ \ \ \ \ \ if\ (a[i]\ >\ p.a[i])$
${\ \ \ \ \ \ \ \ \ \ \ \ \{$
$0;\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ return\ sig\ >\ 0;$
$}\ \ \ \ \ \ \ \ \ \ \ \ \}$
$p.a[i])\ \ \ \ \ \ \ \ \ \ \ \ else\ if\ (a[i]\ <\ p.a[i])$
${\ \ \ \ \ \ \ \ \ \ \ \ \{$
$0;\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ return\ sig\ <\ 0;$
$}\ \ \ \ \ \ \ \ \ \ \ \ \}$
$}\ \ \ \ \ \ \ \ \}$
$false;\ \ \ \ \ \ \ \ return\ false;$
$}\ \ \ \ \}$

$dis)\ \ \ \ void\ leftshift(int\ dis)$
${\ \ \ \ \{$
$−−i)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ length\ +\ dis\ -\ 1;\ i\ >=\ dis;\ --i)$
${\ \ \ \ \ \ \ \ \{$
$dis];\ \ \ \ \ \ \ \ \ \ \ \ a[i]\ =\ a[i\ -\ dis];$
$}\ \ \ \ \ \ \ \ \}$
$dis);\ \ \ \ \ \ \ \ memset(a,\ 0,\ sizeof(int)\ *\ dis);$
$dis;\ \ \ \ \ \ \ \ length\ +=\ dis;$
$}\ \ \ \ \}$

$dis)\ \ \ \ void\ rightshift(int\ dis)$
${\ \ \ \ \{$
$length)\ \ \ \ \ \ \ \ if\ (dis\ >=\ length)$
${\ \ \ \ \ \ \ \ \{$
$clear();\ \ \ \ \ \ \ \ \ \ \ \ return\ clear();$
$}\ \ \ \ \ \ \ \ \}$
$++i)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ 0;\ i\ <\ length\ -\ dis;\ ++i)$
${\ \ \ \ \ \ \ \ \{$
$dis];\ \ \ \ \ \ \ \ \ \ \ \ a[i]\ =\ a[i\ +\ dis];$
$}\ \ \ \ \ \ \ \ \}$
$dis);\ \ \ \ \ \ \ \ memset(a\ +\ length\ -\ dis,\ 0,\ sizeof(int)\ *\ dis);$
$0;\ \ \ \ \ \ \ \ length\ =\ length\ -\ dis\ >\ 0\ ?\ length\ -\ dis\ :\ 0;$
$}\ \ \ \ \}$

$addone()\ \ \ \ void\ addone()$
${\ \ \ \ \{$
$−−a[0];\ \ \ \ \ \ \ \ sig\ >=\ 0\ ?\ ++\ a[0]\ :\ --a[0];$
$++i)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ 0;\ i\ <\ length;\ ++i)$
${\ \ \ \ \ \ \ \ \{$
$0)\ \ \ \ \ \ \ \ \ \ \ \ if\ (a[i]\ <\ 10\ \&\&\ a[i]\ >=\ 0)$
${\ \ \ \ \ \ \ \ \ \ \ \ \{$
$break;\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ break;$
$}\ \ \ \ \ \ \ \ \ \ \ \ \}$
$1]);\ \ \ \ \ \ \ \ \ \ \ \ a[i]\ >=\ 10\ ?\ (a[i]\ -=\ 10,\ ++a[i\ +\ 1])\ :\ (a[i]\ +=\ 10,\ --a[i\ +\ 1]);$
$}\ \ \ \ \ \ \ \ \}$
$(a[length])\ \ \ \ \ \ \ \ if\ (a[length])$
${\ \ \ \ \ \ \ \ \{$
$++length;\ \ \ \ \ \ \ \ \ \ \ \ ++length;$
$}\ \ \ \ \ \ \ \ \}$
$1])\ \ \ \ \ \ \ \ if\ (!a[length\ -\ 1])$
${\ \ \ \ \ \ \ \ \{$
$−−length;\ \ \ \ \ \ \ \ \ \ \ \ --length;$
$}\ \ \ \ \ \ \ \ \}$
$0;\ \ \ \ \ \ \ \ sig\ =\ length\ ?\ (sig\ >=\ 0\ ?\ 1\ :\ -1)\ :\ 0;$
$}\ \ \ \ \}$

$minusone()\ \ \ \ void\ minusone()$
${\ \ \ \ \{$
$−sig;\ \ \ \ \ \ \ \ sig\ =\ -sig;$
$addone();\ \ \ \ \ \ \ \ addone();$
$−sig;\ \ \ \ \ \ \ \ sig\ =\ -sig;$
$}\ \ \ \ \}$

$&q)\ \ \ \ bool\ absgreaterequal(BigInteger\ \&q)$
${\ \ \ \ \{$
$q.length)\ \ \ \ \ \ \ \ if\ (length\ !=\ q.length)$
${\ \ \ \ \ \ \ \ \{$
$q.length;\ \ \ \ \ \ \ \ \ \ \ \ return\ length\ >\ q.length;$
$}\ \ \ \ \ \ \ \ \}$
$i)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ length\ -\ 1;\ i\ >=\ 0;\ --\ i)$
${\ \ \ \ \ \ \ \ \{$
$q.a[i])\ \ \ \ \ \ \ \ \ \ \ \ if\ (a[i]\ >\ q.a[i])$
${\ \ \ \ \ \ \ \ \ \ \ \ \{$
$true;\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ return\ true;$
$}\ \ \ \ \ \ \ \ \ \ \ \ \}$
$q.a[i])\ \ \ \ \ \ \ \ \ \ \ \ if\ (a[i]\ <\ q.a[i])$
${\ \ \ \ \ \ \ \ \ \ \ \ \{$
$false;\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ return\ false;$
$}\ \ \ \ \ \ \ \ \ \ \ \ \}$
$}\ \ \ \ \ \ \ \ \}$
$true;\ \ \ \ \ \ \ \ return\ true;$
$}\ \ \ \ \}$

$abs()\ \ \ \ void\ abs()$
${\ \ \ \ \{$
$std::abs(sig);\ \ \ \ \ \ \ \ sig\ =\ std::abs(sig);$
$}\ \ \ \ \}$

$neg()\ \ \ \ void\ neg()$
${\ \ \ \ \{$
$−sig;\ \ \ \ \ \ \ \ sig\ =\ -sig;$
$}\ \ \ \ \}$

$&q)\ \ \ \ void\ assign(BigInteger\ \&q)$
${\ \ \ \ \{$
$length);\ \ \ \ \ \ \ \ memset(a,\ 0,\ sizeof(int)\ *\ length);$
$q.length);\ \ \ \ \ \ \ \ memcpy(a,\ q.a,\ sizeof(int)\ *\ q.length);$
$q.length;\ \ \ \ \ \ \ \ length\ =\ q.length;$
$q.sig;\ \ \ \ \ \ \ \ sig\ =\ q.sig;$
$}\ \ \ \ \}$

$T>\ \ \ \ template\ <typename\ T>$
$q)\ \ \ \ void\ assign(T\ q)$
${\ \ \ \ \{$
$length);\ \ \ \ \ \ \ \ memset(a,\ 0,\ sizeof(int)\ *\ length);$
$(!q)\ \ \ \ \ \ \ \ if\ (!q)$
${\ \ \ \ \ \ \ \ \{$
$0);\ \ \ \ \ \ \ \ \ \ \ \ return\ (void)(sig\ =\ length\ =\ 0);$
$}\ \ \ \ \ \ \ \ \}$
$1;\ \ \ \ \ \ \ \ q\ <\ 0\ ?\ sig\ =\ -1,\ q\ =\ -q\ :\ sig\ =\ 1;$
$0;\ \ \ \ \ \ \ \ length\ =\ 0;$
$10)\ \ \ \ \ \ \ \ for\ (;\ q;\ q\ /=\ 10)$
${\ \ \ \ \ \ \ \ \{$
$10;\ \ \ \ \ \ \ \ \ \ \ \ a[length++]\ =\ q\ \%\ 10;$
$}\ \ \ \ \ \ \ \ \}$
$}\ \ \ \ \}$

$&q)\ \ \ \ void\ add(BigInteger\ \&q)$
${\ \ \ \ \{$
$aux;\ \ \ \ \ \ \ \ static\ BigInteger\ aux;$
$(!q.sig)\ \ \ \ \ \ \ \ if\ (!q.sig)$
${\ \ \ \ \ \ \ \ \{$
$;\ \ \ \ \ \ \ \ \ \ \ \ return\ ;$
$}\ \ \ \ \ \ \ \ \}$
$(!sig)\ \ \ \ \ \ \ \ if\ (!sig)$
${\ \ \ \ \ \ \ \ \{$
$assign(q);\ \ \ \ \ \ \ \ \ \ \ \ assign(q);$
$;\ \ \ \ \ \ \ \ \ \ \ \ return\ ;$
$}\ \ \ \ \ \ \ \ \}$
$q.sig)\ \ \ \ \ \ \ \ if\ (sig\ ==\ q.sig)$
${\ \ \ \ \ \ \ \ \{$
$1);\ \ \ \ \ \ \ \ \ \ \ \ addminus(a,\ q.a,\ length,\ q.length,\ 1);$
$;\ \ \ \ \ \ \ \ \ \ \ \ return\ ;$
$}\ \ \ \ \ \ \ \ \}$
$(absgreaterequal(q))\ \ \ \ \ \ \ \ if\ (absgreaterequal(q))$
${\ \ \ \ \ \ \ \ \{$
$−1);\ \ \ \ \ \ \ \ \ \ \ \ addminus(a,\ q.a,\ length,\ q.length,\ -1);$
$0;\ \ \ \ \ \ \ \ \ \ \ \ sig\ =\ length\ ?\ sig\ :\ 0;$
$;\ \ \ \ \ \ \ \ \ \ \ \ return\ ;$
$}\ \ \ \ \ \ \ \ \}$
$aux.assign(q);\ \ \ \ \ \ \ \ aux.assign(q);$
$−1);\ \ \ \ \ \ \ \ addminus(q.a,\ a,\ q.length,\ length,\ -1);$
$assign(q);\ \ \ \ \ \ \ \ assign(q);$
$q.assign(aux);\ \ \ \ \ \ \ \ q.assign(aux);$
$}\ \ \ \ \}$

$&q)\ \ \ \ void\ minus(BigInteger\ \&q)$
${\ \ \ \ \{$
$q.neg();\ \ \ \ \ \ \ \ q.neg();$
$add(q);\ \ \ \ \ \ \ \ add(q);$
$q.neg();\ \ \ \ \ \ \ \ q.neg();$
$}\ \ \ \ \}$

$type)\ \ \ \ void\ NTT(int\ *a,\ int\ length,\ int\ type)$
${\ \ \ \ \{$
$−1;\ \ \ \ \ \ \ \ int\ len\ =\ -1;$
$;\ \ \ \ \ \ \ \ for\ (int\ x\ =\ length;\ x;\ ++len,\ x\ >>=\ 1)\ ;$
$++i)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ 1,\ j\ =\ 0;\ i\ <\ length\ -\ 1;\ ++i)$
${\ \ \ \ \ \ \ \ \{$
$;\ \ \ \ \ \ \ \ \ \ \ \ for\ (int\ s\ =\ length;\ j\ \wedge =\ s\ >>=\ 1,\ ~j\ \&\ s;\ )\ ;$
$j)\ \ \ \ \ \ \ \ \ \ \ \ if\ (i\ <\ j)$
${\ \ \ \ \ \ \ \ \ \ \ \ \{$
$a[j]);\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ std::swap(a[i],\ a[j]);$
$}\ \ \ \ \ \ \ \ \ \ \ \ \}$
$}\ \ \ \ \ \ \ \ \}$

$i)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ 1;\ i\ <=\ len;\ ++\ i)$
${\ \ \ \ \ \ \ \ \{$
$1);\ \ \ \ \ \ \ \ \ \ \ \ int\ unit\ =\ powermod(type\ ==\ 1\ ?\ root\ :\ invroot,\ (MOD\ -\ 1)\ >>\ i,\ MOD),\ szk\ =\ 1\ <<\ (i\ -\ 1);$
$i)\ \ \ \ \ \ \ \ \ \ \ \ for\ (int\ j\ =\ 0;\ j\ <\ length;\ j\ +=\ 1\ <<\ i)$
${\ \ \ \ \ \ \ \ \ \ \ \ \{$
$++k)\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ for\ (int\ k\ =\ j,\ w\ =\ 1;\ k\ <\ j\ +\ szk;\ ++k)$
${\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \{$
$MOD;\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ int\ s\ =\ a[k],\ t\ =\ 1ll\ *\ w\ *\ a[k\ +\ szk]\ \%\ MOD;$
$t;\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ a[k]\ =\ s\ +\ t\ >=\ MOD\ ?\ s\ +\ t\ -\ MOD\ :\ s\ +\ t;$
$t;\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ a[k\ +\ szk]\ =\ s\ -\ t\ <\ 0\ ?\ s\ -\ t\ +\ MOD\ :\ s\ -\ t;$
$MOD;\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ w\ =\ 1ll\ *\ w\ *\ unit\ \%\ MOD;$
$}\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \}$
$}\ \ \ \ \ \ \ \ \ \ \ \ \}$
$}\ \ \ \ \ \ \ \ \}$
$1)\ \ \ \ \ \ \ \ if\ (type\ ==\ 1)$
${\ \ \ \ \ \ \ \ \{$
$;\ \ \ \ \ \ \ \ \ \ \ \ return\ ;$
$}\ \ \ \ \ \ \ \ \}$
$MOD);\ \ \ \ \ \ \ \ int\ inv\ =\ powermod(length,\ MOD\ -\ 2,\ MOD);$
$i)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ 0;\ i\ <\ length;\ ++\ i)$
${\ \ \ \ \ \ \ \ \{$
$MOD;\ \ \ \ \ \ \ \ \ \ \ \ a[i]\ =\ 1ll\ *\ a[i]\ *\ inv\ \%\ MOD;$
$}\ \ \ \ \ \ \ \ \}$
$}\ \ \ \ \}$

$&q)\ \ \ \ void\ mult(BigInteger\ \&q)$
${\ \ \ \ \{$
$MAXN];\ \ \ \ \ \ \ \ static\ int\ aux[1\ <<\ MAXN];$
$!q.sig)\ \ \ \ \ \ \ \ if\ (!sig\ ||\ !q.sig)$
${\ \ \ \ \ \ \ \ \{$
$clear();\ \ \ \ \ \ \ \ \ \ \ \ return\ clear();$
$}\ \ \ \ \ \ \ \ \}$
$q.length;\ \ \ \ \ \ \ \ int\ n\ =\ length\ +\ q.length;$
$1;\ \ \ \ \ \ \ \ int\ lengthans\ =\ 1;$
$;\ \ \ \ \ \ \ \ for\ (;\ lengthans\ <\ n;\ lengthans\ <<=\ 1)\ ;$
$lengthans);\ \ \ \ \ \ \ \ memcpy(aux,\ q.a,\ sizeof(int)\ *\ lengthans);$
$1);\ \ \ \ \ \ \ \ NTT(a,\ lengthans,\ 1);$
$1);\ \ \ \ \ \ \ \ NTT(aux,\ lengthans,\ 1);$
$i++)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ 0;\ i\ <\ lengthans;\ i++)$
${\ \ \ \ \ \ \ \ \{$
$MOD;\ \ \ \ \ \ \ \ \ \ \ \ a[i]\ =\ 1ll\ *\ a[i]\ *\ aux[i]\ \%\ MOD;$
$}\ \ \ \ \ \ \ \ \}$
$−1);\ \ \ \ \ \ \ \ NTT(a,\ lengthans,\ -1);$
$i++)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ 0;\ i\ <\ n\ -\ 1;\ i++)$
${\ \ \ \ \ \ \ \ \{$
$10;\ \ \ \ \ \ \ \ \ \ \ \ a[i\ +\ 1]\ +=\ a[i]\ /\ 10;$
$10;\ \ \ \ \ \ \ \ \ \ \ \ a[i]\ \%=\ 10;$
$}\ \ \ \ \ \ \ \ \}$
$n;\ \ \ \ \ \ \ \ length\ =\ n;$
$;\ \ \ \ \ \ \ \ for\ (;\ length\ \&\&\ !a[length\ -\ 1];\ --length)\ ;$
$q.sig;\ \ \ \ \ \ \ \ sig\ *=\ q.sig;$
$}\ \ \ \ \}$

$q)\ \ \ \ void\ mult(int\ q)$
${\ \ \ \ \{$
$!sig)\ \ \ \ \ \ \ \ if\ (!q\ ||\ !sig)$
${\ \ \ \ \ \ \ \ \{$
$clear();\ \ \ \ \ \ \ \ \ \ \ \ return\ clear();$
$}\ \ \ \ \ \ \ \ \}$
$0;\ \ \ \ \ \ \ \ ll\ x\ =\ std::abs(q),\ remain\ =\ 0;$
$++i)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ 0;\ i\ <\ length;\ ++i)$
${\ \ \ \ \ \ \ \ \{$
$x;\ \ \ \ \ \ \ \ \ \ \ \ remain\ +=\ a[i]\ *\ x;$
$10;\ \ \ \ \ \ \ \ \ \ \ \ a[i]\ =\ remain\ \%\ 10;$
$10;\ \ \ \ \ \ \ \ \ \ \ \ remain\ /=\ 10;$
$}\ \ \ \ \ \ \ \ \}$
$(int)remain;\ \ \ \ \ \ \ \ a[length]\ =\ (int)remain;$
$++length)\ \ \ \ \ \ \ \ for\ (;\ a[length];\ ++length)$
${\ \ \ \ \ \ \ \ \{$
$10;\ \ \ \ \ \ \ \ \ \ \ \ a[length\ +\ 1]\ =\ a[length]\ /\ 10;$
$10;\ \ \ \ \ \ \ \ \ \ \ \ a[length]\ \%=\ 10;$
$}\ \ \ \ \ \ \ \ \}$
$;\ \ \ \ \ \ \ \ for\ (;\ length\ \&\&\ !a[length\ -\ 1];\ --length)\ ;$
$1;\ \ \ \ \ \ \ \ sig\ *=\ q\ <\ 0\ ?\ -1\ :\ 1;$
$}\ \ \ \ \}$

$exp)\ \ \ \ void\ power(int\ exp)$
${\ \ \ \ \{$
$aux;\ \ \ \ \ \ \ \ static\ BigInteger\ aux;$
$(!sig)\ \ \ \ \ \ \ \ if\ (!sig)$
${\ \ \ \ \ \ \ \ \{$
$;\ \ \ \ \ \ \ \ \ \ \ \ return\ ;$
$}\ \ \ \ \ \ \ \ \}$
$(1);\ \ \ \ \ \ \ \ aux.assign<int>\ (1);$
$1)\ \ \ \ \ \ \ \ for\ (;\ exp;\ exp\ >>=\ 1)$
${\ \ \ \ \ \ \ \ \{$
$1)\ \ \ \ \ \ \ \ \ \ \ \ if\ (exp\ \&\ 1)$
${\ \ \ \ \ \ \ \ \ \ \ \ \{$
$aux.mult(∗this);\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ aux.mult(*this);$
$}\ \ \ \ \ \ \ \ \ \ \ \ \}$
$aux.mult(aux);\ \ \ \ \ \ \ \ \ \ \ \ aux.mult(aux);$
$}\ \ \ \ \ \ \ \ \}$
$assign(aux);\ \ \ \ \ \ \ \ assign(aux);$
$}\ \ \ \ \}$

$&q)\ \ \ \ void\ divide(BigInteger\ \&q)$
${\ \ \ \ \{$
$aux1;\ \ \ \ \ \ \ \ static\ BigInteger\ aux,\ aux1;$
$!q.sig)\ \ \ \ \ \ \ \ if\ (!sig\ ||\ !q.sig)$
${\ \ \ \ \ \ \ \ \{$
$;\ \ \ \ \ \ \ \ \ \ \ \ return\ ;$
$}\ \ \ \ \ \ \ \ \}$
$q.length)\ \ \ \ \ \ \ \ if\ (length\ <\ q.length)$
${\ \ \ \ \ \ \ \ \{$
$clear();\ \ \ \ \ \ \ \ \ \ \ \ return\ clear();$
$}\ \ \ \ \ \ \ \ \}$
$1;\ \ \ \ \ \ \ \ bool\ neg1\ =\ sig\ ==\ 1,\ neg2\ =\ q.sig\ ==\ 1;$
$q.abs();\ \ \ \ \ \ \ \ abs(),\ q.abs();$
$0;\ \ \ \ \ \ \ \ int\ num\ =\ 0;$
$−−i)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ q.length\ -\ 1;\ i\ >=\ q.length\ -\ 3;\ --i)$
${\ \ \ \ \ \ \ \ \{$
$0;\ \ \ \ \ \ \ \ \ \ \ \ (num\ *=\ 10)\ +=\ i\ >=\ 0\ ?\ q.a[i]\ :\ 0;$
$}\ \ \ \ \ \ \ \ \}$
$num;\ \ \ \ \ \ \ \ num\ =\ 100000\ /\ num;$
$1;\ \ \ \ \ \ \ \ int\ nowprecision\ =\ 1;$
$(num);\ \ \ \ \ \ \ \ aux.assign<int>\ (num);$
$1)\ \ \ \ \ \ \ \ for\ (;\ nowprecision\ <=\ length\ -\ q.length;\ nowprecision\ <<=\ 1)$
${\ \ \ \ \ \ \ \ \{$
$aux1.clear();\ \ \ \ \ \ \ \ \ \ \ \ aux1.clear();$
$1;\ \ \ \ \ \ \ \ \ \ \ \ aux1.length\ =\ (nowprecision\ <<\ 1)\ +\ 3,\ aux1.sig\ =\ 1;$
$++i)\ \ \ \ \ \ \ \ \ \ \ \ for\ (int\ i\ =\ q.length\ -\ aux1.length;\ i\ <\ q.length;\ ++i)$
${\ \ \ \ \ \ \ \ \ \ \ \ \{$
$0;\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ aux1.a[i\ -\ q.length\ +\ aux1.length]\ =\ i\ >=\ 0\ ?\ q.a[i]\ :\ 0;$
$}\ \ \ \ \ \ \ \ \ \ \ \ \}$
$2);\ \ \ \ \ \ \ \ \ \ \ \ aux1.mult(aux),\ aux1.rightshift(nowprecision\ +\ 2);$
$2);\ \ \ \ \ \ \ \ \ \ \ \ aux1.mult(aux),\ aux1.rightshift(nowprecision\ +\ 2);$
$aux.mult(2);\ \ \ \ \ \ \ \ \ \ \ \ aux.mult(2);$
$aux.leftshift(nowprecision);\ \ \ \ \ \ \ \ \ \ \ \ aux.leftshift(nowprecision);$
$aux.minus(aux1);\ \ \ \ \ \ \ \ \ \ \ \ aux.minus(aux1);$
$}\ \ \ \ \ \ \ \ \}$
$aux.mult(∗this);\ \ \ \ \ \ \ \ aux.mult(*this);$
$1);\ \ \ \ \ \ \ \ aux.rightshift(q.length\ +\ nowprecision\ +\ 1);$
$aux1.assign(aux);\ \ \ \ \ \ \ \ aux1.assign(aux);$
$aux1.mult(q);\ \ \ \ \ \ \ \ aux1.mult(q);$
$minus(aux1);\ \ \ \ \ \ \ \ minus(aux1);$
$0;\ \ \ \ \ \ \ \ int\ flag\ =\ absgreaterequal(q)\ ?\ 2\ :\ sig\ <\ 0\ ?\ 1\ :\ 0;$
$assign(aux);\ \ \ \ \ \ \ \ assign(aux);$
$(flag)\ \ \ \ \ \ \ \ if\ (flag)$
${\ \ \ \ \ \ \ \ \{$
$addone();\ \ \ \ \ \ \ \ \ \ \ \ flag\ ==\ 1\ ?\ minusone()\ :\ addone();$
$}\ \ \ \ \ \ \ \ \}$
$(!neg2)\ \ \ \ \ \ \ \ if\ (!neg2)$
${\ \ \ \ \ \ \ \ \{$
$q.neg();\ \ \ \ \ \ \ \ \ \ \ \ q.neg();$
$}\ \ \ \ \ \ \ \ \}$
$1;\ \ \ \ \ \ \ \ sig\ *=\ neg1\ \wedge \ neg2\ ?\ -1\ :\ 1;$
$}\ \ \ \ \}$

$q)\ \ \ \ int\ divide(int\ q)$
${\ \ \ \ \{$
$!q)\ \ \ \ \ \ \ \ if\ (!sig\ ||\ !q)$
${\ \ \ \ \ \ \ \ \{$
$0;\ \ \ \ \ \ \ \ \ \ \ \ return\ 0;$
$}\ \ \ \ \ \ \ \ \}$
$std::abs(q);\ \ \ \ \ \ \ \ ll\ remain\ =\ 0,\ x\ =\ std::abs(q);$
$−−i)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ length\ -\ 1;\ i\ >=\ 0;\ --i)$
${\ \ \ \ \ \ \ \ \{$
$a[i];\ \ \ \ \ \ \ \ \ \ \ \ remain\ =\ remain\ *\ 10\ +\ a[i];$
$x);\ \ \ \ \ \ \ \ \ \ \ \ a[i]\ =\ (int)(remain\ /\ x);$
$x;\ \ \ \ \ \ \ \ \ \ \ \ remain\ \%=\ x;$
$}\ \ \ \ \ \ \ \ \}$
$;\ \ \ \ \ \ \ \ for\ (;\ length\ \&\&\ !a[length\ -\ 1];\ --length)\ ;$
$sig;\ \ \ \ \ \ \ \ remain\ *=\ sig;$
$1;\ \ \ \ \ \ \ \ sig\ *=\ q\ <\ 0\ ?\ -1\ :\ 1;$
$(!length)\ \ \ \ \ \ \ \ if\ (!length)$
${\ \ \ \ \ \ \ \ \{$
$0;\ \ \ \ \ \ \ \ \ \ \ \ sig\ =\ 0;$
$}\ \ \ \ \ \ \ \ \}$
$(int)remain;\ \ \ \ \ \ \ \ return\ (int)remain;$
$}\ \ \ \ \}$

$sqrt()\ \ \ \ void\ sqrt()$
${\ \ \ \ \{$
$aux2;\ \ \ \ \ \ \ \ static\ BigInteger\ aux,\ aux1,\ aux2;$
$0)\ \ \ \ \ \ \ \ if\ (sig\ <=\ 0)$
${\ \ \ \ \ \ \ \ \{$
$;\ \ \ \ \ \ \ \ \ \ \ \ return\ ;$
$}\ \ \ \ \ \ \ \ \}$
$0;\ \ \ \ \ \ \ \ int\ num\ =\ 0;$
$−−i)\ \ \ \ \ \ \ \ for\ (int\ i\ =\ length\ -\ 1;\ i\ >=\ length\ -\ 8;\ --i)$
${\ \ \ \ \ \ \ \ \{$
$0;\ \ \ \ \ \ \ \ \ \ \ \ (num\ *=\ 10)\ +=\ i\ >=\ 0\ ?\ a[i]\ :\ 0;$
$}\ \ \ \ \ \ \ \ \}$
$100000000000000ll;\ \ \ \ \ \ \ \ ll\ x\ =\ length\ \&\ 1\ ?\ 10000000000000ll\ :\ 100000000000000ll;$
$num);\ \ \ \ \ \ \ \ num\ =\ std::sqrt(1.0\ *\ x\ /\ num);$
$2;\ \ \ \ \ \ \ \ int\ nowprecision\ =\ 2;$
$(num);\ \ \ \ \ \ \ \ aux.assign<int>\ (num);$
$1)\ \ \ \ \ \ \ \ for\ (;\ nowprecision\ <=\ (length\ >>\ 1)\ +\ 1;\ nowprecision\ =\ (nowprecision\ <<\ 1)\ -\ 1)$
${\ \ \ \ \ \ \ \ \{$
$aux2.clear();\ \ \ \ \ \ \ \ \ \ \ \ aux1.clear(),\ aux2.clear();$
$1;\ \ \ \ \ \ \ \ \ \ \ \ aux1.length\ =\ (nowprecision\ <<\ 1)\ +\ 1\ +\ (length\ \&\ 1),\ aux1.sig\ =\ 1;$
$++i)\ \ \ \ \ \ \ \ \ \ \ \ for\ (int\ i\ =\ length\ -\ aux1.length;\ i\ <\ length;\ ++i)$
${\ \ \ \ \ \ \ \ \ \ \ \ \{$
$0;\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ aux1.a[i\ -\ length\ +\ aux1.length]\ =\ i\ >=\ 0\ ?\ a[i]\ :\ 0;$
$}\ \ \ \ \ \ \ \ \ \ \ \ \}$
$1);\ \ \ \ \ \ \ \ \ \ \ \ aux1.mult(aux),\ aux1.rightshift(nowprecision\ +\ 1);$
$1);\ \ \ \ \ \ \ \ \ \ \ \ aux1.mult(aux),\ aux1.rightshift(nowprecision\ +\ 1);$
$aux1.divide(2);\ \ \ \ \ \ \ \ \ \ \ \ aux1.divide(2);$
$1;\ \ \ \ \ \ \ \ \ \ \ \ aux2.length\ =\ (nowprecision\ +\ 1)\ <<\ 1,\ aux2.sig\ =\ 1;$
$5;\ \ \ \ \ \ \ \ \ \ \ \ aux2.a[aux2.length\ -\ 1]\ =\ 1,\ aux2.a[aux2.length\ -\ 2]\ =\ 5;$
$aux2.minus(aux1);\ \ \ \ \ \ \ \ \ \ \ \ aux2.minus(aux1);$
$aux.mult(aux2);\ \ \ \ \ \ \ \ \ \ \ \ aux.mult(aux2);$
$2);\ \ \ \ \ \ \ \ \ \ \ \ aux.rightshift(nowprecision\ +\ 2);$
$}\ \ \ \ \ \ \ \ \}$
$aux.mult(∗this);\ \ \ \ \ \ \ \ aux.mult(*this);$
$1);\ \ \ \ \ \ \ \ aux.rightshift((length\ >>\ 1)\ +\ nowprecision\ +\ 1);$
$aux1.assign(aux);\ \ \ \ \ \ \ \ aux1.assign(aux);$
$aux1.mult(aux1);\ \ \ \ \ \ \ \ aux1.mult(aux1);$
$aux2.assign(∗this);\ \ \ \ \ \ \ \ aux2.assign(*this);$
$aux2.mult(2);\ \ \ \ \ \ \ \ aux2.mult(2);$
$minus(aux1);\ \ \ \ \ \ \ \ minus(aux1);$
$0;\ \ \ \ \ \ \ \ int\ flag\ =\ greater(aux2)\ ?\ 2\ :\ sig\ <\ 0\ ?\ 1\ :\ 0;$
$assign(aux);\ \ \ \ \ \ \ \ assign(aux);$
$(flag)\ \ \ \ \ \ \ \ if\ (flag)$
${\ \ \ \ \ \ \ \ \{$
$addone();\ \ \ \ \ \ \ \ \ \ \ \ flag\ ==\ 1\ ?\ minusone()\ :\ addone();$
$}\ \ \ \ \ \ \ \ \}$
$}\ \ \ \ \}$
$};\};$