stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <map>

#include <cstdio>

#include <vector>

#include <sstream>

#include <iostream>

#include <algorithm>

#define LL long long

using namespace std;

const int MAXN = 2e3+55;

int vis[20];

int main()

{

    int n,k,v;

    cin>>n>>k;

    for(int i=1;i<=k;++i)

    {

        cin>>v;

        vis[v]++;

    }

    string s;

    for(int i = n;;++i)

    {

        stringstream in;

        in<<i;

        in>>s;

        bool flag = true;

        for(int i=0;i<s.size();++i)

        {

            int t = s[i] - '0';

            if(vis[t]){

                flag = false;

                break;

            }

        }

        if(flag) {cout<<i;return 0;}

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 9.688148207130528x):
#include<cstdio>

using namespace std;



int n,k,x;

bool arr[10];



bool check(int n)

{

    while(n)

    {

        if(arr[n%10])

            return 0;

        n /= 10;

    }

    return 1;

}



int main()

{

    while(scanf("%d%d",&n,&k)!=EOF)

    {

        for(int i=0;i<k;i++)

        {

            scanf("%d",&x);

            arr[x] = 1;

        }

        for(int i=n;;i++)

        {

            if(check(i))

            {

                printf("%d\n",i);

                break;

            }

        }

    }

return 0;

}
// Slower C++ solution:
#include <cstdio>

#include <cstring>

#include <cmath>

#include <cstdlib>

#include <algorithm>

#include<iostream>

#include<vector>

using namespace std;

int main()

{

    int n,k;

    while(cin>>n>>k)

    {

        int q[10];

        int qq[100];

//        int mi=100;

        memset(qq,0,sizeof(qq));

        for(int i=1; i<=k; i++)

        {

            cin>>q[i];

            qq[q[i]]=1;

        }

        int sum=0;

        int a[6];

//        cout<<n<<endl;

        for(int j=n; j<=100000; j++)

        {

            int i=j;

            a[0]=i/10000;

            i%=10000;

            a[1]=i/1000;

            i%=1000;

            a[2]=i/100;

            i%=100;

            a[3]=i/10;

            a[4]=i%10;



//            if(i=10000)

//                cout<<a<<" "<<b<<" "<<c<<" "<<d<<endl;

            int flag=1;

            int vis=1;

            for(int i=0;i<=4;i++)

            {

                if(a[i]!=0)

                {

                    vis=0;

                }

                if(vis==0)

                {

                    if(qq[a[i]]==1)

                        flag=0;

                }

            }

            if(flag)

            {

                sum=j;

                break;

            }

        }

        cout<<sum<<endl;

    }

}


// Faster C++ solution for the same problem (measured speedup: 5.167067167553456x):
#include<cstdio>

using namespace std;



int n,k,x;

bool arr[10];



bool check(int n)

{

    while(n)

    {

        if(arr[n%10])

            return 0;

        n /= 10;

    }

    return 1;

}



int main()

{

    while(scanf("%d%d",&n,&k)!=EOF)

    {

        for(int i=0;i<k;i++)

        {

            scanf("%d",&x);

            arr[x] = 1;

        }

        for(int i=n;;i++)

        {

            if(check(i))

            {

                printf("%d\n",i);

                break;

            }

        }

    }

return 0;

}
// Slower C++ solution:
#include <iostream>

#include <algorithm>

#include <cmath>

#include <cstdio>

#include <vector>

#include <cstring>

#include <algorithm>

#define Inf 0x3f3f3f3f

using namespace std;

typedef long long ll;

int a[100010];

int vis[100010];

bool check(int n)

{

    while(n)

    {

        if(vis[n%10])

            return false;

        n/=10;

    }

    return true;

}

int main()

{

    int n,k;

    scanf("%d %d",&n,&k);

    memset(vis,0,sizeof(vis));

    for(int i=0; i<k; i++)

    {

        scanf("%d",&a[i]);

        vis[a[i]]=1;

    }

    for(int i=n; ; i++)

    {

        if(check(i))

        {

            printf("%d\n",i);

            return 0;

        }

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 7.136226229442929x):
#include<cstdio>

using namespace std;



int n,k,x;

bool arr[10];



bool check(int n)

{

    while(n)

    {

        if(arr[n%10])

            return 0;

        n /= 10;

    }

    return 1;

}



int main()

{

    while(scanf("%d%d",&n,&k)!=EOF)

    {

        for(int i=0;i<k;i++)

        {

            scanf("%d",&x);

            arr[x] = 1;

        }

        for(int i=n;;i++)

        {

            if(check(i))

            {

                printf("%d\n",i);

                break;

            }

        }

    }

return 0;

}
// Slower C++ solution:
#include <map>

#include <cstdio>

#include <vector>

#include <sstream>

#include <iostream>

#include <algorithm>

#define LL long long

using namespace std;

const int MAXN = 2e3+55;

int vis[20];

int main()

{

    int n,k,v;

    cin>>n>>k;

    for(int i=1;i<=k;++i)

    {

        cin>>v;

        vis[v]++;

    }

    string s;

    for(int i = n;;++i)

    {

        stringstream in;

        in<<i;

        in>>s;

        bool flag = true;

        for(int i=0;i<s.size();++i)

        {

            int t = s[i] - '0';

            if(vis[t]){

                flag = false;

                break;

            }

        }

        if(flag) {cout<<i;return 0;}

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.35734817499621x):
#include<iostream>

#include<cstring>

#include<cstdio>

#include<algorithm>

using namespace std;

int p[100005];

bool judge(int n)

{

    int b;

    int flag=1;

    while(n)

    {

        b=n%10;

        if(p[b])

        {

             return false;

        }

          n/=10;

    }

    return true;

}

int main()

{

    int N,K;

    int m;

    while(scanf("%d%d",&N,&K)!=EOF)

    {

        memset(p,0,sizeof(p));

        for(int i=0;i<K;i++)

        {

              scanf("%d",&m);

              p[m]=1;

        }

         for(int i=N;;i++)

         {

             if(judge(i))

             {

                 printf("%d\n",i);

                 break;

             }

         }

    }

    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main() {

	int n, k;

	scanf ( "%d %d", &n, &k );

	int d[k];

	for ( int i = 0; i < k; i++ )

		scanf ( "%d", &d[i] );

	bool used[10];

	for ( int i = 0; i < 10; i++ )

		used[i] = true;

	for ( int i = 0; i < k; i++ )

		used[d[i]] = false;

	for ( int i = n; ; i++ ) {

		string s = to_string ( i );

		bool ok = true;

		for ( int j = 0; j < s.size(); j++ ) 

			if ( !used[s[j] - '0'] ) 

				ok = false;

		if ( ok ) {

			printf ( "%d\n", i );

			break;

		}

	}

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.1817763801828443x):
#include <iostream>

#include <cstdio>

#include <cstring>

#include <cmath>

#include <algorithm>

using namespace std;

int vis[15];

int check(int n)

{

    while(n)

    {



        if(vis[n%10])

            return 0;

        n/=10;

    }

    return 1;

}

int main()

{

    int n,k;

    cin>>n>>k;

    int s;

    for(int i=0;i<k;i++)

    {

        cin>>s;

        vis[s]=1;

    }

    for(int i=n;;i++)

    {

        if(check(i))

        {

            cout<<i<<endl;

            break;

        }

    }

    return 0;

}
// Slower C++ solution:
#include <map>

#include <cstdio>

#include <vector>

#include <sstream>

#include <iostream>

#include <algorithm>

#define LL long long

using namespace std;

const int MAXN = 2e3+55;

int vis[20];

int main()

{

    int n,k,v;

    cin>>n>>k;

    for(int i=1;i<=k;++i)

    {

        cin>>v;

        vis[v]++;

    }

    string s;

    for(int i = n;;++i)

    {

        stringstream in;

        in<<i;

        in>>s;

        bool flag = true;

        for(int i=0;i<s.size();++i)

        {

            int t = s[i] - '0';

            if(vis[t]){

                flag = false;

                break;

            }

        }

        if(flag) {cout<<i;return 0;}

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.8919008448044872x):
#include <iostream>

#include <cstdio>

#include <cstring>

#include <cmath>

#include <algorithm>

using namespace std;

int vis[15];

int check(int n)

{

    while(n)

    {



        if(vis[n%10])

            return 0;

        n/=10;

    }

    return 1;

}

int main()

{

    int n,k;

    cin>>n>>k;

    int s;

    for(int i=0;i<k;i++)

    {

        cin>>s;

        vis[s]=1;

    }

    for(int i=n;;i++)

    {

        if(check(i))

        {

            cout<<i<<endl;

            break;

        }

    }

    return 0;

}
// Slower C++ solution:
#include <iostream>

#include <algorithm>

#include <cmath>

#include <cstdio>

#include <vector>

#include <cstring>

#include <algorithm>

#define Inf 0x3f3f3f3f

using namespace std;

typedef long long ll;

int a[100010];

int vis[100010];

bool check(int n)

{

    while(n)

    {

        if(vis[n%10])

            return false;

        n/=10;

    }

    return true;

}

int main()

{

    int n,k;

    scanf("%d %d",&n,&k);

    memset(vis,0,sizeof(vis));

    for(int i=0; i<k; i++)

    {

        scanf("%d",&a[i]);

        vis[a[i]]=1;

    }

    for(int i=n; ; i++)

    {

        if(check(i))

        {

            printf("%d\n",i);

            return 0;

        }

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.393561715154418x):
#include <iostream>

#include <cstdio>

#include <cstring>

#include <cmath>

#include <algorithm>

using namespace std;

int vis[15];

int check(int n)

{

    while(n)

    {



        if(vis[n%10])

            return 0;

        n/=10;

    }

    return 1;

}

int main()

{

    int n,k;

    cin>>n>>k;

    int s;

    for(int i=0;i<k;i++)

    {

        cin>>s;

        vis[s]=1;

    }

    for(int i=n;;i++)

    {

        if(check(i))

        {

            cout<<i<<endl;

            break;

        }

    }

    return 0;

}
// Slower C++ solution:
#include<iostream>

#include<cstring>

#include<cstdio>

#include<algorithm>

using namespace std;

int p[100005];

bool judge(int n)

{

    int b;

    int flag=1;

    while(n)

    {

        b=n%10;

        if(p[b])

        {

             return false;

        }

          n/=10;

    }

    return true;

}

int main()

{

    int N,K;

    int m;

    while(scanf("%d%d",&N,&K)!=EOF)

    {

        memset(p,0,sizeof(p));

        for(int i=0;i<K;i++)

        {

              scanf("%d",&m);

              p[m]=1;

        }

         for(int i=N;;i++)

         {

             if(judge(i))

             {

                 printf("%d\n",i);

                 break;

             }

         }

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.3938213346106054x):
#include <iostream>

#include <cstdio>

#include <cstring>

#include <cmath>

#include <algorithm>

using namespace std;

int vis[15];

int check(int n)

{

    while(n)

    {



        if(vis[n%10])

            return 0;

        n/=10;

    }

    return 1;

}

int main()

{

    int n,k;

    cin>>n>>k;

    int s;

    for(int i=0;i<k;i++)

    {

        cin>>s;

        vis[s]=1;

    }

    for(int i=n;;i++)

    {

        if(check(i))

        {

            cout<<i<<endl;

            break;

        }

    }

    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main() {

	int n, k;

	scanf ( "%d %d", &n, &k );

	int d[k];

	for ( int i = 0; i < k; i++ )

		scanf ( "%d", &d[i] );

	bool used[10];

	for ( int i = 0; i < 10; i++ )

		used[i] = true;

	for ( int i = 0; i < k; i++ )

		used[d[i]] = false;

	for ( int i = n; ; i++ ) {

		string s = to_string ( i );

		bool ok = true;

		for ( int j = 0; j < s.size(); j++ ) 

			if ( !used[s[j] - '0'] ) 

				ok = false;

		if ( ok ) {

			printf ( "%d\n", i );

			break;

		}

	}

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.1819270162506395x):
#include<iostream>

#include<cmath>

#include<cstring>

#include<cstdio>

#include<algorithm>

using namespace std;

int n,k,vis[10];

int check(int n){

	while(n){

		if(vis[n%10]==1)

		return 0;

		n/=10;

	}

    return 1;

	}

int main()

{

	cin>>n>>k;

	memset(vis,0,sizeof(vis));

	int a;

	for(int i=0;i<k;i++){

	cin>>a;

	vis[a]=1;

}

	int i=n;

	while(1){

		if(check(i)){

			cout<<i<<endl;

			break;

		}

		i++;

	}

	

	

 }
// Slower C++ solution:
#include <map>

#include <cstdio>

#include <vector>

#include <sstream>

#include <iostream>

#include <algorithm>

#define LL long long

using namespace std;

const int MAXN = 2e3+55;

int vis[20];

int main()

{

    int n,k,v;

    cin>>n>>k;

    for(int i=1;i<=k;++i)

    {

        cin>>v;

        vis[v]++;

    }

    string s;

    for(int i = n;;++i)

    {

        stringstream in;

        in<<i;

        in>>s;

        bool flag = true;

        for(int i=0;i<s.size();++i)

        {

            int t = s[i] - '0';

            if(vis[t]){

                flag = false;

                break;

            }

        }

        if(flag) {cout<<i;return 0;}

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.8921419974529057x):
#include<iostream>

#include<cmath>

#include<cstring>

#include<cstdio>

#include<algorithm>

using namespace std;

int n,k,vis[10];

int check(int n){

	while(n){

		if(vis[n%10]==1)

		return 0;

		n/=10;

	}

    return 1;

	}

int main()

{

	cin>>n>>k;

	memset(vis,0,sizeof(vis));

	int a;

	for(int i=0;i<k;i++){

	cin>>a;

	vis[a]=1;

}

	int i=n;

	while(1){

		if(check(i)){

			cout<<i<<endl;

			break;

		}

		i++;

	}

	

	

 }
// Slower C++ solution:
#include <iostream>

#include <algorithm>

#include <cmath>

#include <cstdio>

#include <vector>

#include <cstring>

#include <algorithm>

#define Inf 0x3f3f3f3f

using namespace std;

typedef long long ll;

int a[100010];

int vis[100010];

bool check(int n)

{

    while(n)

    {

        if(vis[n%10])

            return false;

        n/=10;

    }

    return true;

}

int main()

{

    int n,k;

    scanf("%d %d",&n,&k);

    memset(vis,0,sizeof(vis));

    for(int i=0; i<k; i++)

    {

        scanf("%d",&a[i]);

        vis[a[i]]=1;

    }

    for(int i=n; ; i++)

    {

        if(check(i))

        {

            printf("%d\n",i);

            return 0;

        }

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.39373934660866x):
#include<iostream>

#include<cmath>

#include<cstring>

#include<cstdio>

#include<algorithm>

using namespace std;

int n,k,vis[10];

int check(int n){

	while(n){

		if(vis[n%10]==1)

		return 0;

		n/=10;

	}

    return 1;

	}

int main()

{

	cin>>n>>k;

	memset(vis,0,sizeof(vis));

	int a;

	for(int i=0;i<k;i++){

	cin>>a;

	vis[a]=1;

}

	int i=n;

	while(1){

		if(check(i)){

			cout<<i<<endl;

			break;

		}

		i++;

	}

	

	

 }
// Slower C++ solution:
#include<iostream>

#include<cstring>

#include<cstdio>

#include<algorithm>

using namespace std;

int p[100005];

bool judge(int n)

{

    int b;

    int flag=1;

    while(n)

    {

        b=n%10;

        if(p[b])

        {

             return false;

        }

          n/=10;

    }

    return true;

}

int main()

{

    int N,K;

    int m;

    while(scanf("%d%d",&N,&K)!=EOF)

    {

        memset(p,0,sizeof(p));

        for(int i=0;i<K;i++)

        {

              scanf("%d",&m);

              p[m]=1;

        }

         for(int i=N;;i++)

         {

             if(judge(i))

             {

                 printf("%d\n",i);

                 break;

             }

         }

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.3939989991574484x):
#include<iostream>

#include<cmath>

#include<cstring>

#include<cstdio>

#include<algorithm>

using namespace std;

int n,k,vis[10];

int check(int n){

	while(n){

		if(vis[n%10]==1)

		return 0;

		n/=10;

	}

    return 1;

	}

int main()

{

	cin>>n>>k;

	memset(vis,0,sizeof(vis));

	int a;

	for(int i=0;i<k;i++){

	cin>>a;

	vis[a]=1;

}

	int i=n;

	while(1){

		if(check(i)){

			cout<<i<<endl;

			break;

		}

		i++;

	}

	

	

 }
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main() {

	int n, k;

	scanf ( "%d %d", &n, &k );

	int d[k];

	for ( int i = 0; i < k; i++ )

		scanf ( "%d", &d[i] );

	bool used[10];

	for ( int i = 0; i < 10; i++ )

		used[i] = true;

	for ( int i = 0; i < k; i++ )

		used[d[i]] = false;

	for ( int i = n; ; i++ ) {

		string s = to_string ( i );

		bool ok = true;

		for ( int j = 0; j < s.size(); j++ ) 

			if ( !used[s[j] - '0'] ) 

				ok = false;

		if ( ok ) {

			printf ( "%d\n", i );

			break;

		}

	}

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.1815237653708364x):
#include <iostream>

#include <algorithm>

#include<cstring>

using namespace std;

int dis[10];

int check(int n);

int main()

{

     int n,k;

     cin >> n >> k;

     memset(dis,0,sizeof(dis));

     int x;

     for(int i = 0;i < k;i++)

        {

         cin >> x;

         dis[x] = 1;

        }

     for(int i = n; ;i++)

        {

         if(check(i))

            {

             cout << i <<endl;

             break;

            }

        }

     return 0;

}

int check(int n)

{

     while(n)

        {

         int yushu = n%10;





         if(dis[yushu])

            {

            return 0;

         }

         n /= 10;

         }

    return 1;

}
// Slower C++ solution:
#include <map>

#include <cstdio>

#include <vector>

#include <sstream>

#include <iostream>

#include <algorithm>

#define LL long long

using namespace std;

const int MAXN = 2e3+55;

int vis[20];

int main()

{

    int n,k,v;

    cin>>n>>k;

    for(int i=1;i<=k;++i)

    {

        cin>>v;

        vis[v]++;

    }

    string s;

    for(int i = n;;++i)

    {

        stringstream in;

        in<<i;

        in>>s;

        bool flag = true;

        for(int i=0;i<s.size();++i)

        {

            int t = s[i] - '0';

            if(vis[t]){

                flag = false;

                break;

            }

        }

        if(flag) {cout<<i;return 0;}

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.8914964348126628x):
#include <iostream>

#include <algorithm>

#include<cstring>

using namespace std;

int dis[10];

int check(int n);

int main()

{

     int n,k;

     cin >> n >> k;

     memset(dis,0,sizeof(dis));

     int x;

     for(int i = 0;i < k;i++)

        {

         cin >> x;

         dis[x] = 1;

        }

     for(int i = n; ;i++)

        {

         if(check(i))

            {

             cout << i <<endl;

             break;

            }

        }

     return 0;

}

int check(int n)

{

     while(n)

        {

         int yushu = n%10;





         if(dis[yushu])

            {

            return 0;

         }

         n /= 10;

         }

    return 1;

}
// Slower C++ solution:
#include <iostream>

#include <algorithm>

#include <cmath>

#include <cstdio>

#include <vector>

#include <cstring>

#include <algorithm>

#define Inf 0x3f3f3f3f

using namespace std;

typedef long long ll;

int a[100010];

int vis[100010];

bool check(int n)

{

    while(n)

    {

        if(vis[n%10])

            return false;

        n/=10;

    }

    return true;

}

int main()

{

    int n,k;

    scanf("%d %d",&n,&k);

    memset(vis,0,sizeof(vis));

    for(int i=0; i<k; i++)

    {

        scanf("%d",&a[i]);

        vis[a[i]]=1;

    }

    for(int i=n; ; i++)

    {

        if(check(i))

        {

            printf("%d\n",i);

            return 0;

        }

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.3932638294151205x):
#include <iostream>

#include <algorithm>

#include<cstring>

using namespace std;

int dis[10];

int check(int n);

int main()

{

     int n,k;

     cin >> n >> k;

     memset(dis,0,sizeof(dis));

     int x;

     for(int i = 0;i < k;i++)

        {

         cin >> x;

         dis[x] = 1;

        }

     for(int i = n; ;i++)

        {

         if(check(i))

            {

             cout << i <<endl;

             break;

            }

        }

     return 0;

}

int check(int n)

{

     while(n)

        {

         int yushu = n%10;





         if(dis[yushu])

            {

            return 0;

         }

         n /= 10;

         }

    return 1;

}
// Slower C++ solution:
#include<iostream>

#include<cstring>

#include<cstdio>

#include<algorithm>

using namespace std;

int p[100005];

bool judge(int n)

{

    int b;

    int flag=1;

    while(n)

    {

        b=n%10;

        if(p[b])

        {

             return false;

        }

          n/=10;

    }

    return true;

}

int main()

{

    int N,K;

    int m;

    while(scanf("%d%d",&N,&K)!=EOF)

    {

        memset(p,0,sizeof(p));

        for(int i=0;i<K;i++)

        {

              scanf("%d",&m);

              p[m]=1;

        }

         for(int i=N;;i++)

         {

             if(judge(i))

             {

                 printf("%d\n",i);

                 break;

             }

         }

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.393523393375428x):
#include <iostream>

#include <algorithm>

#include<cstring>

using namespace std;

int dis[10];

int check(int n);

int main()

{

     int n,k;

     cin >> n >> k;

     memset(dis,0,sizeof(dis));

     int x;

     for(int i = 0;i < k;i++)

        {

         cin >> x;

         dis[x] = 1;

        }

     for(int i = n; ;i++)

        {

         if(check(i))

            {

             cout << i <<endl;

             break;

            }

        }

     return 0;

}

int check(int n)

{

     while(n)

        {

         int yushu = n%10;





         if(dis[yushu])

            {

            return 0;

         }

         n /= 10;

         }

    return 1;

}
// Slower C++ solution:
#include<iostream>

#include<string>

#include<sstream>

using namespace std;

int n, k, d[9];



bool solve(int n) {

	string s;

	stringstream ss;

	ss << n;

	ss >> s;

	for (int i = 0; i < k; i++) {

		if (s.find((char)(d[i] + '0')) != string::npos) return false;

	}

	return true;

}

int main() {

	cin >> n >> k;

	for (int i = 0; i < k; i++) cin >> d[i];

	while (n < 100000) {

		if (solve(n)) break;

		n++;

	}

	cout << n << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.899082669475717x):
#include <bits/stdc++.h>

#define int long long

#define endl '\n'

#define FOR(i, a, n) for (int i = (a); i < (n); ++i)

#define REP(i, n) FOR(i, 0, n)

using namespace std;



int N, K;

set<int> st;



int dfs(int lev, int s) {

    if (s >= N) return s;

    int res = 1LL << 30;

    if (lev == 5) return res;

    for (int d : st) res = min(res, dfs(lev + 1, s * 10 + d));

    return res;

}



void _main() {

    cin >> N >> K;

    REP (i, 10) st.insert(i);

    REP (i, K) {

        int D;

        cin >> D;

        st.erase(D);

    }

    cout << dfs(0, 0) << endl;

}



signed main() {

    ios::sync_with_stdio(false);

    cin.tie(nullptr);

    cout << fixed << setprecision(10);

    _main();

    return 0;

}