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

#include <algorithm>



using namespace std;



const int MAXN = 100000 + 5;



struct process {

  string name;

  int time;

};



process Q[MAXN];

int head, tail;

int n, q, total_time = 0;



void enqueue(process x) {

  Q[tail] = x;

  tail++;

  tail %= MAXN;

}



process dequeue() {

  process x = Q[head];

  head++;

  head %= MAXN;

  return x;

}



bool isEmpty() {

  return head == tail;

}



int main() {

  cin >> n >> q;

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

    cin >> Q[i].name >> Q[i].time;

  }

  head = 0, tail = n;

  while (!isEmpty()) {

    process crt = dequeue();

    int need = min(crt.time, q);

    crt.time -= need;

    total_time += need;

    if (crt.time == 0) {

      cout << crt.name << " " << total_time << endl;

    } else {

      enqueue(crt);

    }

  }

  return 0;

}

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

#include <stdlib.h>

#include <deque>

#include <string>

#include <iostream>

using namespace std;

int main(){

	int n,q;

	deque<long int> myque;

	deque<string> nque;

	string name;

	long int time;

	cin>>n>>q;

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

		cin>>name>>time;

	    nque.push_back(name);

	    myque.push_back(time);

	}

	long int sum=0;

	long int t;

	while(myque.size()!=0)

	{

	  	if(myque.front()>q){

	  	   sum+=q;

		   t = myque.front() - q;

		   name = nque.front();

		   myque.pop_front();

		   nque.pop_front();

		   myque.push_back(t);

		   nque.push_back(name);	

		}

		else{

		  sum+=myque.front();

		  cout<<nque.front()<<" "<<sum<<endl;

		  myque.pop_front();

		  nque.pop_front();

		} 

	}

	return 0;

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

#include <algorithm>



using namespace std;



const int MAXN = 100000 + 5;



struct process {

  string name;

  int time;

};



process Q[MAXN];

int head, tail;

int n, q, total_time = 0;



void enqueue(process x) {

  Q[tail] = x;

  tail++;

  tail %= MAXN;

}



process dequeue() {

  process x = Q[head];

  head++;

  head %= MAXN;

  return x;

}



bool isEmpty() {

  return head == tail;

}



int main() {

  cin >> n >> q;

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

    cin >> Q[i].name >> Q[i].time;

  }

  head = 0, tail = n;

  while (!isEmpty()) {

    process crt = dequeue();

    int need = min(crt.time, q);

    crt.time -= need;

    total_time += need;

    if (crt.time == 0) {

      cout << crt.name << " " << total_time << endl;

    } else {

      enqueue(crt);

    }

  }

  return 0;

}

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

#include <queue>

#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

struct Process{

    char name[500];

    int time;

};



int main(){

    int n = 0, quantum;

    int remain = 0;

    int finishTime = 0;

    queue<Process> q;

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

    // 5 100

    // 150 80 200 350 20

    // p1 p2 p3 p4 p5

    while(n--){

        Process tmp;

        scanf("%s", tmp.name);

        scanf("%d", &tmp.time);

        q.push(tmp);

    }

    while(q.size() > 0){

        remain = q.front().time - quantum;

        if(remain <= 0){ // finished

            finishTime += q.front().time;

            printf("%s %d\n", q.front().name, finishTime);

        }

        else{ // not finished

            finishTime += quantum;

            Process tmp;

            strcpy(tmp.name, q.front().name);

            tmp.time = remain;

            q.push(tmp);

        }

        q.pop();

    }

    return 0;

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

#include <algorithm>



using namespace std;



const int MAXN = 100000 + 5;



struct process {

  string name;

  int time;

};



process Q[MAXN];

int head, tail;

int n, q, total_time = 0;



void enqueue(process x) {

  Q[tail] = x;

  tail++;

  tail %= MAXN;

}



process dequeue() {

  process x = Q[head];

  head++;

  head %= MAXN;

  return x;

}



bool isEmpty() {

  return head == tail;

}



int main() {

  cin >> n >> q;

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

    cin >> Q[i].name >> Q[i].time;

  }

  head = 0, tail = n;

  while (!isEmpty()) {

    process crt = dequeue();

    int need = min(crt.time, q);

    crt.time -= need;

    total_time += need;

    if (crt.time == 0) {

      cout << crt.name << " " << total_time << endl;

    } else {

      enqueue(crt);

    }

  }

  return 0;

}

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

#include <queue>



using namespace std;



struct Process{

	string name;

	int time;

	

	Process(string name = "", int time = 0) : name(name), time(time) {}

};



int main(){

	

	long long passtime = 0;

	int n, q;

	string s;

	int t;

	queue<Process> que;

	

	cin >> n >> q;

	

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

		cin >> s;

		cin >> t;

		que.push(Process(s, t));

	}

	

	while(!que.empty()){

		Process np = que.front();

		que.pop();

		if(np.time <= q){

			passtime += np.time;

			cout << np.name << " " << passtime << endl;

		}

		else{

			passtime += q;

			np.time -= q;

			que.push(np);

		}

	}

	

	return 0;

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

#include <algorithm>



using namespace std;



const int MAXN = 100000 + 5;



struct process {

  string name;

  int time;

};



process Q[MAXN];

int head, tail;

int n, q, total_time = 0;



void enqueue(process x) {

  Q[tail] = x;

  tail++;

  tail %= MAXN;

}



process dequeue() {

  process x = Q[head];

  head++;

  head %= MAXN;

  return x;

}



bool isEmpty() {

  return head == tail;

}



int main() {

  cin >> n >> q;

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

    cin >> Q[i].name >> Q[i].time;

  }

  head = 0, tail = n;

  while (!isEmpty()) {

    process crt = dequeue();

    int need = min(crt.time, q);

    crt.time -= need;

    total_time += need;

    if (crt.time == 0) {

      cout << crt.name << " " << total_time << endl;

    } else {

      enqueue(crt);

    }

  }

  return 0;

}

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

using namespace std;



int main()

{

    int n, qu, tmp, st;

    string s, ts;

    queue <string> q1;

    queue <int> q2;

    st = 0;

    cin >> n >> qu;

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

    {

        cin >> s >> tmp;

        q1.push(s);

        q2.push(tmp);

    }

    while(!q2.empty())

    {

        if(q2.front() > qu)

        {

            tmp = q2.front() - qu;

            st += qu;

            q2.pop();

            q2.push(tmp);

            ts = q1.front();

            q1.pop();

            q1.push(ts);

        }

        else

        {

            st += q2.front();

            cout << q1.front() << " " << st << endl;

            q1.pop();

            q2.pop();

        }

    }

    return 0;

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

#include <algorithm>



using namespace std;



const int MAXN = 100000 + 5;



struct process {

  string name;

  int time;

};



process Q[MAXN];

int head, tail;

int n, q, total_time = 0;



void enqueue(process x) {

  Q[tail] = x;

  tail++;

  tail %= MAXN;

}



process dequeue() {

  process x = Q[head];

  head++;

  head %= MAXN;

  return x;

}



bool isEmpty() {

  return head == tail;

}



int main() {

  cin >> n >> q;

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

    cin >> Q[i].name >> Q[i].time;

  }

  head = 0, tail = n;

  while (!isEmpty()) {

    process crt = dequeue();

    int need = min(crt.time, q);

    crt.time -= need;

    total_time += need;

    if (crt.time == 0) {

      cout << crt.name << " " << total_time << endl;

    } else {

      enqueue(crt);

    }

  }

  return 0;

}

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

#include <stdio.h>

#include <string>

using namespace std;

struct

{

	char name[13];

	int time;

}mission[100010];

int main(void)

{

	int n, limit;



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

	{

		int sum = 0, head = 0, tail = 0;



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

		{

			cin >> mission[i].name;

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

			tail++;

		}

		while (head != tail)

		{

			if (tail == n + 1)

				tail = 0;

			else if (head == n + 1)

				head = 0;

			else

			{

				if (mission[head].time <= limit)

				{

					sum += mission[head].time;

					printf("%s %d\n", mission[head].name, sum);

					head++;

				}

				else

				{

					sum += limit;

					mission[head].time -= limit;

					mission[tail++] = mission[head++];

				}

			}

		}

	}

	//system("pause");



	return 0;

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

#include <algorithm>



using namespace std;



const int MAXN = 100000 + 5;



struct process {

  string name;

  int time;

};



process Q[MAXN];

int head, tail;

int n, q, total_time = 0;



void enqueue(process x) {

  Q[tail] = x;

  tail++;

  tail %= MAXN;

}



process dequeue() {

  process x = Q[head];

  head++;

  head %= MAXN;

  return x;

}



bool isEmpty() {

  return head == tail;

}



int main() {

  cin >> n >> q;

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

    cin >> Q[i].name >> Q[i].time;

  }

  head = 0, tail = n;

  while (!isEmpty()) {

    process crt = dequeue();

    int need = min(crt.time, q);

    crt.time -= need;

    total_time += need;

    if (crt.time == 0) {

      cout << crt.name << " " << total_time << endl;

    } else {

      enqueue(crt);

    }

  }

  return 0;

}

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

using namespace std;

using process = pair<string, int>;



queue<process> que;



int main()

{

	int n, q; cin >> n >> q;

	while (n--)

	{

		process p; cin >> p.first >> p.second;

		que.push(p);

	}

	

	int stamp = 0;

	while (!que.empty())

	{

		process cur = que.front(); que.pop();

		

		int diff = min(cur.second, q);

		cur.second -= diff, stamp += diff;

		if (cur.second == 0)

		{

			cout << cur.first << ' ' << stamp << endl;

		}

		else que.push(cur);

	}

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

#include <algorithm>



using namespace std;



const int MAXN = 100000 + 5;



struct process {

  string name;

  int time;

};



process Q[MAXN];

int head, tail;

int n, q, total_time = 0;



void enqueue(process x) {

  Q[tail] = x;

  tail++;

  tail %= MAXN;

}



process dequeue() {

  process x = Q[head];

  head++;

  head %= MAXN;

  return x;

}



bool isEmpty() {

  return head == tail;

}



int main() {

  cin >> n >> q;

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

    cin >> Q[i].name >> Q[i].time;

  }

  head = 0, tail = n;

  while (!isEmpty()) {

    process crt = dequeue();

    int need = min(crt.time, q);

    crt.time -= need;

    total_time += need;

    if (crt.time == 0) {

      cout << crt.name << " " << total_time << endl;

    } else {

      enqueue(crt);

    }

  }

  return 0;

}

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



#define ms(a,x) memset(a,x,sizeof(a))

using namespace std;



typedef long long ll;



int gcd(int a,int b){

	if(b==0)return a;

	return gcd(b,a%b);}

int lcm(int a,int b){

	return a/gcd(a,b)*b;}

#define Len 100005

typedef struct pp{

	char name[20];

	int t;

}P; 



P Q[Len];

int head,tail,n;



void enqueue(P x){/*在tail所指位置添加x，由于元素数增加一，

			所以tail也随之加一，此时如果超过数组容量上限则

			重置为0*/ 

	Q[tail]=x;

	tail=(tail+1)%Len;

}

P dequeue(){/*将头指针所指对头元素暂存入变量x,随后

			头指针加一，然后返回x值 */ 

	P x=Q[head];

	head = (head+1)%Len;

	return x; 

}

int min(int a,int b) {

	return a<b?a:b;

}

int main(){

	int elaps=0,c;

	int i,q;

	P u;

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

	

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

		scanf("%s",Q[i].name);

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

	}

	head=1;

	tail=n+1;

	

	while(head!=tail){

		u=dequeue();

		c=min(q,u.t);

		u.t-=c;

		elaps+=c;

		if(u.t>0)enqueue(u);

		else {

			printf("%s %d\n",u.name,elaps);

		}

	}

	return 0;

}



/*

5 100

p1 150

p2 80

p3 200

p4 350

p5 20

*/

/*p2 180

p5 400

p1 450

p3 550

p4 800

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

#include <algorithm>



using namespace std;



const int MAXN = 100000 + 5;



struct process {

  string name;

  int time;

};



process Q[MAXN];

int head, tail;

int n, q, total_time = 0;



void enqueue(process x) {

  Q[tail] = x;

  tail++;

  tail %= MAXN;

}



process dequeue() {

  process x = Q[head];

  head++;

  head %= MAXN;

  return x;

}



bool isEmpty() {

  return head == tail;

}



int main() {

  cin >> n >> q;

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

    cin >> Q[i].name >> Q[i].time;

  }

  head = 0, tail = n;

  while (!isEmpty()) {

    process crt = dequeue();

    int need = min(crt.time, q);

    crt.time -= need;

    total_time += need;

    if (crt.time == 0) {

      cout << crt.name << " " << total_time << endl;

    } else {

      enqueue(crt);

    }

  }

  return 0;

}

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

#include<cstdio>

#include<string>

#include<cstring>

using namespace std;

const int LEN=100005;



typedef struct pp{

	char name[100];

	int t;

}p; 



p Q[LEN];

int head,tail,n;



void enqueue(p x)

{

	Q[tail]=x;

	tail=(tail+1)%LEN;

}



p dequeue()

{

	p x=Q[head];

	head=(head+1)%LEN;

	return x;

}



int min(int a, int b)

{

	return a<b?a:b;

}



int main(void) 

{

	int elaps=0,c,q;

	p u;

	cin >> n >> q;

	//cout <<n << q<< endl;

	

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

		cin >> Q[i].name;

		cin >> Q[i].t;

		getchar();

		//cout <<Q[i].name << Q[i].t << endl;

	}

	head=1;

	tail=n+1;

	while(head!=tail){

		u=dequeue();

		c=min(q,u.t);

		u.t-=c;

		elaps+=c;

		if(u.t>0)

			enqueue(u);

		else

			cout << u.name << " " << elaps << endl;

	}



	return 0;

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

#include <algorithm>



using namespace std;



const int MAXN = 100000 + 5;



struct process {

  string name;

  int time;

};



process Q[MAXN];

int head, tail;

int n, q, total_time = 0;



void enqueue(process x) {

  Q[tail] = x;

  tail++;

  tail %= MAXN;

}



process dequeue() {

  process x = Q[head];

  head++;

  head %= MAXN;

  return x;

}



bool isEmpty() {

  return head == tail;

}



int main() {

  cin >> n >> q;

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

    cin >> Q[i].name >> Q[i].time;

  }

  head = 0, tail = n;

  while (!isEmpty()) {

    process crt = dequeue();

    int need = min(crt.time, q);

    crt.time -= need;

    total_time += need;

    if (crt.time == 0) {

      cout << crt.name << " " << total_time << endl;

    } else {

      enqueue(crt);

    }

  }

  return 0;

}

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

#include <cstring>

#include <algorithm>

#include <cstdio>



using namespace std;



#define LEN 100005



typedef struct Poj{

    char name[100];

    int time;

}poj;



poj Q[LEN];

int head, tail, n;



void enqueue(poj x){

    Q[tail] = x;

    tail = (tail+1) % LEN;

}



poj dequeue(){

    poj tmp = Q[head];

    head = (head+1) % LEN;

    return tmp;

}



int main(){

    int elapse = 0, q = 0;

    poj cur;

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



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

        scanf("%s",Q[i].name);

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

    }

    head = 0;

    tail = n;



    while(head != tail){

        cur = dequeue();

        elapse += min(q,cur.time);

        cur.time -= min(q,cur.time);

        if(cur.time > 0)

            enqueue(cur);

        else

            printf("%s %d\n",cur.name,elapse);

    }

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

#include <algorithm>



using namespace std;



const int MAXN = 100000 + 5;



struct process {

  string name;

  int time;

};



process Q[MAXN];

int head, tail;

int n, q, total_time = 0;



void enqueue(process x) {

  Q[tail] = x;

  tail++;

  tail %= MAXN;

}



process dequeue() {

  process x = Q[head];

  head++;

  head %= MAXN;

  return x;

}



bool isEmpty() {

  return head == tail;

}



int main() {

  cin >> n >> q;

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

    cin >> Q[i].name >> Q[i].time;

  }

  head = 0, tail = n;

  while (!isEmpty()) {

    process crt = dequeue();

    int need = min(crt.time, q);

    crt.time -= need;

    total_time += need;

    if (crt.time == 0) {

      cout << crt.name << " " << total_time << endl;

    } else {

      enqueue(crt);

    }

  }

  return 0;

}

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

#include<cstdio>

#include<algorithm>

#include<queue>

#include<string>

using namespace std;

int main()

{

	int n, q,t;

	int elaps = 0;

	string name;

	queue< pair<string,int> > Q;

	cin >> n >> q;

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

		cin >> name >> t;

		Q.push(make_pair(name,t));

	}

	pair<string,int> u;

	while(!Q.empty()){

		u = Q.front(); Q.pop();

		int cost = min(q,u.second);

		u.second -= cost;

		elaps += cost;

		if(u.second <= 0){

			cout << u.first << " " << elaps << endl;

		}

		else{

			Q.push(u);

		}

	}

	

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

#include <algorithm>



using namespace std;



const int MAXN = 100000 + 5;



struct process {

  string name;

  int time;

};



process Q[MAXN];

int head, tail;

int n, q, total_time = 0;



void enqueue(process x) {

  Q[tail] = x;

  tail++;

  tail %= MAXN;

}



process dequeue() {

  process x = Q[head];

  head++;

  head %= MAXN;

  return x;

}



bool isEmpty() {

  return head == tail;

}



int main() {

  cin >> n >> q;

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

    cin >> Q[i].name >> Q[i].time;

  }

  head = 0, tail = n;

  while (!isEmpty()) {

    process crt = dequeue();

    int need = min(crt.time, q);

    crt.time -= need;

    total_time += need;

    if (crt.time == 0) {

      cout << crt.name << " " << total_time << endl;

    } else {

      enqueue(crt);

    }

  }

  return 0;

}

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

#include <string.h>

#include <queue>



using namespace std;

struct point

{

    char s[12];

    long long x;

}a[1000005];



void check(long long n,long long k)

{

    queue <point> q;

    queue <point> t;

    point f;

    long long sum = 0;

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

        q.push(a[i]);

    while(!q.empty())

    {

        f = q.front();

        if(f.x > k)

        {

            f.x -= k;

            sum += k;

            q.push(f);

        }

        else

        {

            sum += f.x;

            f.x = sum;

            t.push(f);

        }

        q.pop();

    }

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

    {

        f = t.front();

        printf("%s %lld\n",f.s,f.x);

        t.pop();

    }

}



int main()

{

    long long n,k;

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

    {

        for(long long i = 0; i < n; i++)

            scanf("%s%lld",a[i].s,&a[i].x);

        check(n,k);

    }

    return 0;

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

#include <algorithm>



using namespace std;



const int MAXN = 100000 + 5;



struct process {

  string name;

  int time;

};



process Q[MAXN];

int head, tail;

int n, q, total_time = 0;



void enqueue(process x) {

  Q[tail] = x;

  tail++;

  tail %= MAXN;

}



process dequeue() {

  process x = Q[head];

  head++;

  head %= MAXN;

  return x;

}



bool isEmpty() {

  return head == tail;

}



int main() {

  cin >> n >> q;

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

    cin >> Q[i].name >> Q[i].time;

  }

  head = 0, tail = n;

  while (!isEmpty()) {

    process crt = dequeue();

    int need = min(crt.time, q);

    crt.time -= need;

    total_time += need;

    if (crt.time == 0) {

      cout << crt.name << " " << total_time << endl;

    } else {

      enqueue(crt);

    }

  }

  return 0;

}

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

#include <cstdio>

#include <cstring>

#include <cstdio>

#include <cstdlib>

#include <algorithm>

#include <queue>

using namespace std;

struct node

{

    char str[11];

    int t;

};

node a[100001];

int main()

{

    int n,q;

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

    {

        queue<node> Q;

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

        {

            scanf("%s",a[i].str);

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

            Q.push(a[i]);

        }

        int sum=0;

        while(!Q.empty())

        {

            if(Q.front().t<=q)

            {

                sum+=Q.front().t;

                printf("%s %d\n",Q.front().str,sum);

                Q.pop();

            }

            else

            {

                Q.front().t-=q;

                sum+=q;

                Q.push(Q.front());

                Q.pop();

            }

        }

    }

    return 0;

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

#include <algorithm>



using namespace std;



const int MAXN = 100000 + 5;



struct process {

  string name;

  int time;

};



process Q[MAXN];

int head, tail;

int n, q, total_time = 0;



void enqueue(process x) {

  Q[tail] = x;

  tail++;

  tail %= MAXN;

}



process dequeue() {

  process x = Q[head];

  head++;

  head %= MAXN;

  return x;

}



bool isEmpty() {

  return head == tail;

}



int main() {

  cin >> n >> q;

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

    cin >> Q[i].name >> Q[i].time;

  }

  head = 0, tail = n;

  while (!isEmpty()) {

    process crt = dequeue();

    int need = min(crt.time, q);

    crt.time -= need;

    total_time += need;

    if (crt.time == 0) {

      cout << crt.name << " " << total_time << endl;

    } else {

      enqueue(crt);

    }

  }

  return 0;

}

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

using namespace std;

queue< pair<string,int> > Q;

pair<string,int> P;



int main()

{

    int n , q , time;

    string name;

    cin >> n >> q;

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

        cin >> name >> time;

        P = make_pair(name,time);

        Q.push(P);

    }

    int sum = 0;

    while(!Q.empty()){

        P = Q.front();

        time = P.second;

        if(time > q){

                P.second -= q;

                sum += q;

                Q.push(P);

                Q.pop();

        }else{

            sum += time;

            cout << P.first << " " << sum << endl;

            Q.pop();

        }

    }

    return 0;

}