stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include <bits/stdc++.h>

#include <math.h>

using namespace std;



int n;

int main () {

cin>>n;

cout<<pow(n,3)<<endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

printf ("%d",  possible);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

int N;

int main (){

	cin>>N;

	cout << N*N*N << endl;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

printf ("%d",  possible);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;

int n;

int main()

{

    cin>>n;

    cout<<n*n*n<<endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

printf ("%d",  possible);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cmath>



using namespace std;



int main()

{

    int k;

    cin>>k;

    int b = pow(k,3);

    cout<<b;

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

printf ("%d",  possible);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <algorithm>

#include <cmath>

using namespace std;



int main() {



    int n; cin >> n;

    cout << pow(n, 3);

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

printf ("%d",  possible);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include<math.h>



using namespace std;



int main()

{

   int n;

   cin>>n;

   cout<<pow(n,3);

    return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

printf ("%d",  possible);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>



#include<cmath>

using namespace std;



int main(){

int alaa;

cin>>alaa;

cout<<pow(alaa,3);









return 0;



}








// Optimized solution to the same problem (faster):
#include <stdio.h>

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

printf ("%d",  possible);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):


#include <iostream>

#include <cmath>



using namespace std;



int main()

{

    int A;

    cin>>A;

    cout<<pow(A,3);



    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

printf ("%d",  possible);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

#include<cmath>

using namespace std;

int main()

{

    double n,result;

    cin>>n;



    result=pow(n,3);



    printf("%.0lf",result);

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

printf ("%d",  possible);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



int main(){

	int n;

	cin >> n;

	cout << pow (n,3) << endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main() {

	

	int x;

	scanf("%d", &x);

	printf("%d", x * x * x);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>



using namespace std;



int main()

{

    int n; cin >> n;

    cout << n*n*n;;

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main() {

	

	int x;

	scanf("%d", &x);

	printf("%d", x * x * x);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;

int main(){

    int N;

    cin>>N;

    int x;



    x=N*N*N;

    cout<<x;



   return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main() {

	

	int x;

	scanf("%d", &x);

	printf("%d", x * x * x);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <math.h>



using namespace std;

int main()

{

    int n;

    cin >> n;



    cout << pow(n, 3) << endl;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main() {

	

	int x;

	scanf("%d", &x);

	printf("%d", x * x * x);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cmath>



using namespace std;



int main()

{



int  x;

cin>>x;



cout<<pow(x,3)<<endl;



    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main() {

	

	int x;

	scanf("%d", &x);

	printf("%d", x * x * x);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cmath>



using namespace std;





int main()

{

    int a;cin>>a;

    cout<<pow(a,3);







    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main() {

	

	int x;

	scanf("%d", &x);

	printf("%d", x * x * x);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

int main(void)

{

  int N;

  cin>>N;

  cout<<N*N*N;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main() {

	

	int x;

	scanf("%d", &x);

	printf("%d", x * x * x);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>



using namespace std;



int main(){

	int n;

	cin>>n;

	cout<<n*n*n;

	return 0;

}

// Optimized solution to the same problem (faster):
#include<cstdio>

int main(){

  int n;

  scanf("%d",&n);

  n=n*n*n;

  printf("%d",n);

  return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
/*ANKON GHOSH

  KUET,ECE 2K16*/

#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define inf 1e18

#define MAX 4003

#define mod 1000000007

#define sf(a) scanf("%lld",&a)

#define sff(a,b) scanf("%lld %lld",&a,&b)

#define sfff(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)

#define Case(i) cout<<"Case #"<<i<<": "

#define pf(a) printf("%lld\n",a)

#define pfsn printf("NO\n")

#define pfs  printf("YES\n")

#define pff(a,b) printf("%lld %lld\n",a,b)

#define pfff(a,b,c) printf("%lld %lld %lld\n",a,b,c)

#define pffff(a,b,c,d) printf("%lld %lld %lld %lld\n",a,b,c,d)

#define FOR(i,n) for(ll i=0;i<n;i++)

#define FOR1(i,n) for(ll i=1;i<=n;i++)

#define LOOP(x,y) for(ll r=x;r<=y;r++)

#define RFOR(i,n) for(ll i=n-1;i>=0;i--)

#define RFOR1(i,n) for(ll i=n;i>0;i--)

#define RLOOP(x,y) for(ll i=y;i>=x;i--)

#define m_p(a,b) make_pair(a,b)

#define p_b(a) push_back(a)

#define ff first

#define ss second

#define fast ios_base::sync_with_stdio(false); cin.tie(NULL)

map<ll,ll>mp1,mp;

vector<pair<ll,pair<ll,ll> > >vpp,vpp1;

vector<pair<ll,ll> >vp,fin;

vector<ll>v1,v2,dummy;

map<pair<ll,ll>,bool>mbb;

map<ll,bool>mb;

ll n,k,a,b,c,d,ta,sum=0,cnt=0,m,l,req,sz,maxi;

bool sortbysec(const pair<pair<ll,ll>,ll> &a,const pair<pair<ll,ll>,ll> &b)

{

    return (a.second < b.second);

}

vector<ll>power;

int main()

{

    cin>>n;

    cout<<powl(n,3LL);

    return 0;

}

/*

5

4

3

2

3

4

4

3

3

4

2

3

*/


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

    int a;

    scanf("%d", &a);

    printf("%d", a*a*a);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

#define ll long long int

#define co cout

#define ci cin

#define sf1(n) scanf("%lld",&n);

#define sf2(n,m) scanf("%lld %lld",&n,&m);

#define sf3(n,m,p) scanf("%lld %lld %lld",&n,&m,&p);

#define en cout<<endl;

#define pb push_back

#define coy cout<< "YES"<<endl;

#define con cout<< "NO"<<endl;

#define For(a,b) for(ll a=0;a<b;a++)

#define br break;

#define i64 long long

i64 M=10000000;

ll b[805],ans[805];

map< ll,pair<ll,ll> >mp;

//vector<ll>a;

int main()

{

    ll t,n,g,k,m,mx=0,mn=1e9,c,res,c1,x,y,c2;

    sf1(t)

    co<<t*t*t;

}




// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

    int a;

    scanf("%d", &a);

    printf("%d", a*a*a);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

int main(){

int n;



cin>>n;



long long int a = pow(n,3);

cout<<a<<endl;

return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

    int a;

    scanf("%d", &a);

    printf("%d", a*a*a);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

#include <math.h>

using namespace std;



int n;

int main () {

cin>>n;

cout<<pow(n,3)<<endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int n;

	scanf("%d", &n);

	printf("%d", n * n * n);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;

int main(){

int n;

cin >> n;

cout << n*n*n << endl;

return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int n;

	scanf("%d", &n);

	printf("%d", n * n * n);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include<cmath>



using namespace std;



int main()

{

    int n;

    cin>>n;

    cout<<pow(n,3);



    return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int n;

	scanf("%d", &n);

	printf("%d", n * n * n);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;







int main()

{

  int N;

  cin>>N;

int x =N*N*N;

cout<<x;



		return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int n;

	scanf("%d", &n);

	printf("%d", n * n * n);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cmath>

using namespace std;



int main()

{

    int n;

    cin >> n;

    int x=pow(n,3);

    cout << x;

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int n;

	scanf("%d", &n);

	printf("%d", n * n * n);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include<cmath>

using namespace std;



int main()

{

    int b;

    cin>>b ;

    if(b==1)

        cout<<b;

    else cout<<pow(b,3);

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int n;

	scanf("%d", &n);

	printf("%d", n * n * n);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

using namespace std; 

int main(){

int N;

cin >> N; 

cout<<N*N*N;

return 0; }

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int n;

	scanf("%d", &n);

	printf("%d", n * n * n);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;

int main(){

    int n;

    cin>>n;

    cout<<n*n*n;

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int n;

	scanf("%d", &n);

	printf("%d", n * n * n);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

using namespace std;

int main()

{

	ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    int n;

    cin>>n;

    cout<<n*n*n;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int n;

	scanf("%d", &n);

	printf("%d", n * n * n);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

//#include <stdlib.h>

//#include <string.h>



using namespace std;



int main()

{

    int n;

    cin>>n;

    cout<<n*n*n;



    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int n;

	scanf("%d", &n);

	printf("%d", n * n * n);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

#include <math.h>

using namespace std;

int main()

{

    int x,ans;

    cin>>x;

    ans=pow(x,3);

    cout<<ans<<endl;

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

	printf("%d",n*n*n);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;



int main()

{

	int N;

	cin >> N;

	cout << N*N*N;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

	printf("%d",n*n*n);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;

int main() {

	int n;

	cin >> n;

	cout << n * n * n;

	return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

	printf("%d",n*n*n);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

int main()

{

    int n;

    cin>>n;

    int res=1;

    for(int i=1;i<=3;i++){

        res*=n;

    }

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

    return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

	printf("%d",n*n*n);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

int n;

int main () {

	cin >> n;

	cout << n*n*n << endl;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

	printf("%d",n*n*n);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

int main(){

	int n;cin>>n;cout<<pow(n,3)<<endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

	printf("%d",n*n*n);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

int n;

int main () {

cin >> n;

cout << (n*n*n) << endl;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

	printf("%d",n*n*n);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cmath>



using namespace std;



int main(void) {



	int input;



	cin >> input;



	cout<<pow(input, 3)<<endl;



	return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

	printf("%d",n*n*n);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cmath>

using namespace std;



int main()

{

    int N;

    cin>>N;

    if(N==1)

        cout<<N<<endl;

    else

        cout<<pow(N , 3)<<endl;

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

	

int num;

int result;

scanf("%d", &num);

result = num * num * num;

printf("%d", result);

return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;



int main() {

    int num;

    cin >> num;

    cout << num*num*num;

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

	

int num;

int result;

scanf("%d", &num);

result = num * num * num;

printf("%d", result);

return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <cstdio>

#include <utility>

#include <vector>

static const int MAXN = 104;

static const int ALPHA = 26;



int h, w;

int ct[ALPHA] = { 0 };

std::vector<std::vector<std::pair<int, int>>> groups[5];

char s[MAXN][MAXN];



int main()

{

    scanf("%d%d", &h, &w); getchar();

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

        for (int j = 0; j < w; ++j)

            ++ct[getchar() - 'a'];

        getchar();

    }



    for (int i = 0; i < (h + 1) / 2; ++i)

        for (int j = 0; j < (w + 1) / 2; ++j) {

            std::vector<std::pair<int, int>> g;

            g.push_back({ i, j });

            if (i * 2 != h - 1) {

                g.push_back({ h - 1 - i, j });

                if (j * 2 != w - 1) {

                    g.push_back({ i, w - 1 - j });

                    g.push_back({ h - 1 - i, w - 1 - j });

                }

            } else {

                if (j * 2 != w - 1)

                    g.push_back({ i, w - 1 - j });

            }

            //for (auto pos : g) printf(" (%d %d)", pos.first, pos.second); putchar('\n');

            groups[g.size()].push_back(g);

        }



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

        for (int j = 4; j >= 1; --j)

            while (ct[i] >= j && !groups[j].empty()) {

                ct[i] -= j;

                for (auto pos : groups[j].back())

                    s[pos.first][pos.second] = i + 'a';

                groups[j].pop_back();

            }

    }



    for (int i = 1; i <= 4; ++i) if (!groups[i].empty()) { puts("No"); return 0; }



    /*for (int i = 0; i < h; ++i) {

        for (int j = 0; j < w; ++j) putchar(s[i][j]);

        putchar('\n');

    }*/

    puts("Yes");



    return 0;

}


// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

static const int MAXN = 104;

static const int ALPHA = 26;



int h, w;

int ct[ALPHA] = { 0 };

int groups[5] = { 0 };



int main()

{

    scanf("%d%d", &h, &w); getchar();

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

        for (int j = 0; j < w; ++j)

            ++ct[getchar() - 'a'];

        getchar();

    }



    for (int i = 0; i < (h + 1) / 2; ++i)

        for (int j = 0; j < (w + 1) / 2; ++j) {

            int u = 1;

            if (i * 2 != h - 1) {

                u += 1;

                if (j * 2 != w - 1) u += 2;

            } else {

                if (j * 2 != w - 1) u += 1;

            }

            groups[u] += 1;

        }



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

        for (int j = 4; j >= 1; --j) {

            int dec = std::min(groups[j], ct[i] / j);

            ct[i] -= j * dec;

            groups[j] -= dec;

        }

    }



    bool valid = true;

    for (int i = 1; i <= 4; ++i) if (groups[i] > 0) valid = false;

    puts(valid ? "Yes" : "No");



    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



map<int, char> ans;



const int N = 1100;



int n, a, b, q;



int x[N], y[N], h[N];

char c[N][10];



int get(int pos) {

	while (1) {

		int now = upper_bound(y, y + b + 1, pos) - y - 1;

		if (now == 0 || h[now] == 0) return pos;

		int per = y[now] - h[now];

		pos -= ((pos - y[now]) / per + 1) * per;

	}

}



int main() {

	ios_base::sync_with_stdio(0);

	cin >> n >> a >> b >> q;

	for (int i = 1; i <= a; i++) cin >> x[i] >> c[i];

	y[0] = 1, y[b + 1] = n + 1;

	for (int i = 1; i <= b; i++) cin >> y[i] >> h[i];

	for (int i = 1; i <= a; i++) {

		ans[get(x[i])] = c[i][0];

	}

	for (int i = 1; i <= q; i++) {

		int z; cin >> z; 

//		cerr << z << endl;

		z = get(z);

//		cerr << z << endl;

		if (!ans.count(z)) cout << "?";

		else cout << ans[z];

	}

	cout << endl;

	return 0;

}




// Optimized solution to the same problem (faster):
#include<cstdio>

#include<map>

using namespace std;

const int N=1100;

int n,a,b,q,i,x,m,known[N];char ch[N][9];

int y[N],h[N];

map<int,char>T;

struct E{int l,d;E(){}E(int _l,int _d){l=_l,d=_d;}}e[N];

inline int go(int x){

    int i=m;

    while(1){

        while(i&&e[i].l>x)i--;

        int l=e[i].l,d=e[i].d;

        if(!i||!d)break;

        x-=((x-l)/d+1)*d;

    }

    return x;

}

int main(){

    scanf("%d%d%d%d",&n,&a,&b,&q);

    for(i=1;i<=a;i++)scanf("%d%s",&known[i],ch[i]);

    for(i=1;i<=b;i++)scanf("%d%d",&y[i],&h[i]);

    y[b+1]=n+1;

    for(i=1;i<=b;i++)e[++m]=E(y[i],h[i]?y[i]-h[i]:0);

    for(i=1;i<=a;i++)T[go(known[i])]=ch[i][0];

    while(q--){

        scanf("%d",&x);

        x=go(x);

        if(T.find(x)==T.end())putchar('?');else putchar(T[x]);

    }

    putchar('\n');

    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

using namespace __gnu_pbds;

using namespace std;



typedef long long ll;

typedef pair<int,int> ii;

typedef tree<ii,null_type,less<ii>,rb_tree_tag,tree_order_statistics_node_update> indexed_set;



int main() {

	cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(0);

	int N; string S; cin>>N>>S;

	map<int,int> b,w;

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

		if(S[i]=='#') b[i]++;

		else w[i]++;

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

		b[i]+=b[i-1];

	for (int i=N-2; i>=0; i--)

		w[i]+=w[i+1];

	int ret=min(b[N-1],w[0]);

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

		ret=min(ret,b[i]+w[i+1]);

	cout<<ret<<"\n";

	return 0;

}

// Optimized solution to the same problem (faster):
#include<cstdio>

int n;

char a[200200];

int cnt[200200][2]; // count of . and #

int main()

{

	// #. is a bad pattern

	// only possible patterns is ... followed by ###

	scanf("%d%s", &n, &a[1]);

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

	{

		cnt[i][0] = cnt[i - 1][0] + (a[i] == '.');

		cnt[i][1] = cnt[i - 1][1] + (a[i] == '#');

	}

	int ans = n;

	for (int i = 0; i <= n; i++) // number of .

	{

		int v = cnt[i][1] + (cnt[n][0] - cnt[i][0]);

		if (ans > v) ans = v;

	}

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

	return 0;

}


// Fastest known solution for this problem: