ZUFEOJ 2229-2239 【A~K&&G==0】

ZUFE OJ 2229-2239 源自浙江财经大学信息学院2014年院赛
其中在某些基础点上也会被卡住些许时间，在此记录并向当年的出题先生致敬！

A：问题 A: 黑鸡打BOSS
题目描述
今天，黑鸡决定去单挑纳什男爵。由于黑鸡和提莫一样萌，所以他与提莫有一些共性，也就是黑鸡也会造成毒属性伤害。这里我们把黑鸡与男爵的战斗规则简单介绍一下。黑鸡具有a的固定攻击，b的毒属性伤害，当然黑鸡由于装备比较好，还具有暴击能力。毒属性伤害的附加值是循环的，并且循环长度为4。比如黑鸡第一次攻击时毒属性附加为0，第二次附加为b，第三次附加为2*b,第四次附加伤害为3*b,第五次又到了循环的起点，即值为0，如此0,b,2*b,3*b,0,b,2*b,3*b,0...的循环。黑鸡的暴击属性并不是随机的，而是每3次必定暴击一次，即对男爵造成的固定伤害（不考虑毒属性伤害）为：第一次值为a，第二次值为a,而第三次由于暴击值为2*a,也就是a,a,2*a,a,a,2*a,a...如此循环。当然纳什男爵也是会进行攻击的，纳什男爵仅有固定攻击且攻击力为c。现在假设黑鸡与男爵是按顺序进行攻击的，这里黑鸡是先手。即顺序为黑鸡攻击，男爵反击，黑鸡攻击，男爵反击...直到其中某一方生命值小于等于0。（这里一方攻击后，受攻击方要受到等同于攻击力的伤害，即生命值下降值为受到的攻击值）。

输入
包含多组测试数据，现在第一行给出HP1，HP2，a，b，c分别表示黑鸡的生命值，纳什男爵的生命值，黑鸡的固定攻击力，黑鸡的毒属性伤害,以及纳什男爵的固定攻击力，其中(0<HP1,HP2<=1000,0<a,b,c<=100)。

输出
如果黑鸡胜利，即纳什男爵的生命值先小于等于0，那么输出"victory"，否则输出"defeated"。

样例输入
20 20 3 3 3
15 20 1 2 3
样例输出
victory
defeated
提示
读入HP1，HP2， a, b, c

使用bool类型或int类型判断判断当前是哪方攻击， 定义int变量表示普通攻击暴击循环和毒属性攻击

使用while HP1 > 0 and HP2 > 0然后通过当前是哪方攻击处理，如果是黑鸡攻击，则要考虑普通攻击的暴击和毒属性攻击， 如果是男爵攻击则较简单， 受攻击一方减去对应的血量即可

PS:男爵的攻击的次数不算在黑鸡的普通攻击和毒属性攻击的循环次数中。


最后只需要判断HP1 和 HP2两值中哪个小于等于0， 小于等于0的一方为负方

分析：直接模拟！两种伤害分别计算。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
#define ll long long int 
#define INF 0x3f3f3f3f
const int maxn = 1e5 + 10;
int main()
{
    int HP1, HP2, a, b, c;
    while (cin >> HP1 >> HP2 >> a >> b >> c)
    {
        for (int i = 0;; i++)
        {           
            int gank = i % 3;
            if (gank == 2)
                HP2 -= a;
            int tmp = (i % 4) * b;
            HP2 = HP2 - tmp - a;
            HP1 = HP1 - c;
            if (HP2 <= 0)
            {
                cout << "victory" << endl;
                break;
            }
            if (HP1 <= 0)
            {
                cout << "defeated" << endl;
                break;
            }
        }
    }

    return 0;
}

问题 B: True or False
时间限制: 1 Sec  内存限制: 128 MB
提交: 314  解决: 42
[提交][状态][讨论版]
题目描述
vv发现一个简单的不等式，这个不等式十分简单,但是vv只会+，-，*，/四则运算,于是让你判断一个简单的不等式，首先判断是否被vv能解出，然后判断结果。
输入
输入有多组数据，每一组数据，都是包括四个整数a,b,c,d(-1000<a,b,c,d<1000),和三个字符
x,y,z (y只取!,=,<,> 分别表示了 !=,==,<=,>=，保证x,z不出现,!,<,>,=)。
输出
若式子解不出，则输出 error ，否则判断是否结果正确,正确为true，错误为false。
样例输入
1 1 1 1 + = +
1 1 1 1 + = -
1 1 1 1 - = -
1 1 1 1 + = -
1 1 1 1 ^ = &
2 3 1 1 / = -
样例输出
true
false
true
false
error
true
提示
例如


例子1+1==1+1 输出true


vv有强迫症哟，如果出现小数他会向下取整。

例如如果是1.1vv会认为是1；如果是1.6vv也会认为是1；如果是-1.1vv就会认为是-2。

分析：除0操作需要报错！scanf输入printf输出，否则超时

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<cmath>
using namespace std;
#define ll long long int 
#define INF 0x3f3f3f3f
const int maxn = 1e5 + 10;
const double eps = 0.000001;
int a, b, c, d;
int ans[5];
int main()
{
    char tmp[4];
    /*double x = 1.5, y = -1.5;
    cout << (int)x << " " << (int)y << endl;*/
    while (scanf("%d %d %d %d %c %c %c", &ans[1], &ans[2], &ans[3], &ans[4], &tmp[1], &tmp[2], &tmp[3]) != EOF)
    {
        if (tmp[1] == '/'&&ans[2] == 0 || tmp[3] == '/'&&ans[4] == 0)
        {
            printf("error\n");
            continue;
        }
        if (tmp[1] != '*'&&tmp[1] != '/'&&tmp[1] != '-'&&tmp[1] != '+')
        {
            printf("error\n");
            continue;
        }
        if (tmp[3] != '*'&&tmp[3] != '/'&&tmp[3] != '-'&&tmp[3] != '+')
        {
            printf("error\n");
            continue;
        }
        if (tmp[2] != '!'&&tmp[2] != '='&&tmp[2] != '<'&&tmp[2] != '>')
        {
            printf("error\n");
            continue;
        }
        for (int i = 1; i <= 3; i++)
        {
            if (i == 2)
                continue;
            if (tmp[i] == '+')
            {
                ans[i + 1] += ans[i];
                ans[i] = 0;
            }
            else if (tmp[i] == '-')
            {
                ans[i + 1] = ans[i] - ans[i + 1];
                ans[i] = 0;
            }
            else if (tmp[i] == '*')
            {
                ans[i + 1] *= ans[i];
                ans[i] = 0;
            }
            else if (tmp[i] == '/')
            {

                double cs = 1.0*ans[i] / ans[i + 1];
                /*cout << cs << endl;
                cout << (int)cs << endl;*/
                if (fabs(cs - 1.0*(int)cs) < eps)
                {
                    ans[i + 1] = (int)cs;
                }
                else
                {
                    if (cs < 0)
                        ans[i + 1] = (int)cs - 1;
                    else
                        ans[i + 1] = (int)cs;
                }
                ans[i] = 0;
            }
        }
        if (tmp[2] == '=')
        {
            if (ans[2] == ans[4])
            {
                printf("true\n");
                continue;
            }
            else
            {
                printf("false\n");
                continue;
            }
        }
        if (tmp[2] == '>')
        {
            if (ans[2] >= ans[4])
            {
                printf("true\n");
                continue;
            }
            else
            {
                printf("false\n");
                continue;
            }
        }
        else if (tmp[2] == '!')
        {
            if (ans[2] != ans[4])
            {
                printf("true\n");
                continue;
            }
            else
            {
                printf("false\n");
                continue;
            }
        }
        if (tmp[2] == '<')
        {
            if (ans[2] <= ans[4])
            {
                printf("true\n");
                continue;
            }
            else
            {
                printf("false\n");
                continue;
            }
        }

    }
    return 0;
}

问题 C: 四正要出国
时间限制: 1 Sec  内存限制: 128 MB
提交: 344  解决: 58
[提交][状态][讨论版]
题目描述
财经的一位传奇人物四正马上就要出国深造了。小伙伴们都舍不得四正，我想他也一定是这么想的吧^_^。他说他要把满满的记忆都带过去（真是感动啊）。这不，他最近都在家里整理他的行李。这当然少不了他记录ACM点滴的记事本。第一页记录着他刚入集训队时的一个简单的题目。告诉你一串数字以及l和r要求求得第l个到第r个数字的和。因为数字个数很少（最多之有100个），所以他用了最暴力的方法把第l个数字加上第l+1个数字再加上第l+2个数字，直到加到第r个数字。
因为四正是一个善于联想，肯动脑筋的人（不然也不会成为一代神犇啊~）。他并不满足与只有100个数字的运算。那么问题来了，如果一开始给你数字很多并且有很多次l到r的数字的和的询问又该怎么办呢？
四正太忙了，于是，聪明又热心的你，赶紧帮四正解决它吧。

输入
第一行输入一个n (n<=100000) 表示有n个数，第二行输入这n个数字(数字保证在0到100之内)。第三行输入一个m表示有m次查询。接下来m (m<=100000) 行，每行两个数字l 和 r(1<=l<=r<=n)，表示查询的范围为[l,r](包括第l个数和第r个数)。

输出
每行输出一个数字，表示从第l个数字到第r个数字的和。

样例输入
2
1 2
2
1 1
1 2
样例输出
1
3
提示

分析：前缀和

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
#define ll long long int 
#define INF 0x3f3f3f3f
const int maxn = 1e5 + 10;
int a[maxn];
int sum[maxn];
int main()
{
    int n; int m;
    while (~scanf("%d",&n))
    {
        memset(sum, 0, sizeof(sum));
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &a[i]);
            sum[i] = sum[i - 1] + a[i];
        }
        scanf("%d", &m);
        int L, R;
        while (m--)
        {
            scanf("%d%d", &L, &R);
            printf("%d\n", sum[R] - sum[L - 1]);
        }
    }

    return 0;
}

问题 D: 买票
时间限制: 1 Sec  内存限制: 128 MB
提交: 355  解决: 71
[提交][状态][讨论版]
题目描述
游泳池里今天有优惠哦，一个大人带一个小孩时小孩免票，但是带多个小孩只能免去一个小孩的票，虽然vv也是小孩，但是没有大人在身边，所以他不能买票。突然他在门口看到了一堆有n个大人，m个小孩，在进入人数最多的情况下，他想知道他们买票数量有几种，请你告诉他。

输入
输入有多组数据,每组数据就两个整数n，m(n,m<100)。

输出
输出就一行买票数量的可能情况。

样例输入
3 5
1 0
样例输出
3
1

分析：倒着分析，悬挂分析，各种分析！

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int main()
{
    int n, m;
    while (cin >> n >> m)
    {
        if (n == 0 || m == 0)
        {
            cout << "1" << endl;
            continue;
        }
      /*  int tmp = n + m;
        int cmp = n;
        while (n > 0 && m > 0)
        {
            n--;
            if (m == 1)
            {
                cmp++;  
                m--;
            }
            else if (m >= 2)
            {
                cmp++;
                m -= 2;
            }
        }
        cmp += m;
        cout << tmp - cmp + 1 << endl;*/
        cout << min(m, n) << endl;
    }
    return 0;
}

问题 E: 免费的pizza
时间限制: 1 Sec  内存限制: 128 MB
提交: 191  解决: 37
[提交][状态][讨论版]
题目描述
啊飘是一只黄色的大老鼠。他很喜欢吃pizza。有一家pizza店搞活动。pizza店给出一个英文句子，要求你找出其中的pizza的数量，根据找出的数量赠予免费的pizza。啊飘想要吃到尽量多的pizza，也就是在句子中找出尽量多的pizza，但是他水平有限，找不出很多的pizza，所以他希望你能编写程序帮助他。该活动的具体规则如下：给出一串英文句子，其中仅包含小写字母。要求找出其中的pizza的数量，pizza可以不连续，但是相对顺序必须正确。比如pxizkzua，其中第1，3，4，6，8位组成了一个pizza，但是ipzza则不能组成一个pizza，因为相对顺序错误，并且每一个字母最多只能用于一个句子，比如ppizzzzaa，其中只能找出1个pizza，因为每个字符只能最多用在一个句子，i只能用一次。如pxpiiyzqzqzzuaa，这里则能最多找出2个pizza。

输入
包含多组测试数据，每组给出一行字符串，字符串仅包含小写字母，字符串长度L范围1<=L<=100000。

输出
输出一个数字，表示最多能找出几个pizza。

样例输入
ipzza
ppizzzzaa
pxpiiyzqzqzzuaa
样例输出
0
1
2
分析：基础DP，维护五个变量

#include<stdio.h>
#include<string.h>
char c[100005];
int main()
{   
    while (scanf("%s", &c) != EOF)
    {
        int p = 0, i = 0, z1 = 0, z2= 0, a = 0;
        int len = strlen(c);
        for (int j = 0; j < len; j++)
        {
            if (c[j] == 'p')
            {
                p++;
            }
            else if (c[j] == 'i')
            {
                i++;
                if (i>p)
                    i = p;
            }
            else if (c[j] == 'z')
            {
                z1++;
                if (z1 > 2 * i)
                    z1 = 2 * i;
                z2 = z1 / 2;
            }
            else if (c[j] == 'a')
            {
                a++;
                if (z2 < a)
                    a = z2;
            }
        }
        printf("%d\n", a);
    }   
    return 0;
}

问题 F: 黑鸡学骑车
时间限制: 1 Sec  内存限制: 128 MB
提交: 164  解决: 64
[提交][状态][讨论版]
题目描述
因为财大的教学楼离宿舍有一段不短的距离，并且黑鸡同学又有懒床的坏习惯，总是要等到快上课了才起床，导致经常迟到只能坐在教室的最前排。这还不是最糟的，有次等他到教室，老师已经点过名了（a sad story）。终于，他向世界宣布，他要开始学骑自行车了。学骑车是件痛苦的事情，在摔了n次以后，他还是放弃了。一个人坐在文化长廊看路上车来车往。突然，他想到了高中数学曾经教过的线速度=角速度*半径。（学霸的世界我们不懂T^T）。那么问题来了，已知自行车的角速度，求自行车的线速度。

输入
第一行输入一个数T表示有T组数据，对于每组数据输入两个实数w和r(w,r都在100以内)。其中w表示自行车车轮的转速为w弧度/秒，r表示自行车车轮的半径（单位米）。

输出
对于每组数据，输出一个实数v表示自行车的前进速度为v（km/h）保留2位小数。

样例输入
2
10 1
5 5
样例输出
36.00
90.00

分析：水题

#include<iostream>
#include<cmath>
#include<iomanip>
#include<algorithm>
#include<cstdio>
using namespace std;
int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        double w, r; double ans;
        scanf("%lf%lf", &w, &r);
        ans = w*r;
        ans = ans*3.6;
        cout << setiosflags(ios::fixed) << setprecision(2) << ans << endl;
    }
    return 0;
}

问题 G: 小刷放学记
时间限制: 1 Sec  内存限制: 128 MB
提交: 35  解决: 5
[提交][状态][讨论版]
题目描述
终于到了放学的时候，小伙伴们很开心地冲出校园，奔走在回家的路上，小刷也不例外，这不，他正和同班的妹子们一起回家呢！
小刷是个浪漫的人，半路上，他准备好了放在书包里的一大堆糖果要跟同学们分享，借此巩固他在班级里男神的地位，但是，女童鞋们很犀利，她们每个人都提出了一个需求。
比如小刷有n种糖果，每种糖果的数量可以认为有无数个，每种糖果有一个价值，第i种糖果的价值为a[i],现在有m个需求，第b[i]种糖果的数量必须大于第c[i]种糖果，问，最后一共有多少种不同的取糖果的方案来满足这m个需求，并且价值的总量是t。

输入
每组数据的第一行输入n, m t，第二行输入n个整数表示n种糖果的价值
接下来的m行表示m个需求。1 <= n <= 100, 1 <= m <= 100, t <= 10000;
a[i] <= 100000.

输出
每组数据输出一个整数表示方案数，对1000000007取模。

样例输入
3 2 6
3 1 1
1 2
2 3
3 2 10
1 2 3
1 2
2 1
样例输出
0
0
提示
分析：不会做= =

问题 H: 小刷上学记
时间限制: 1 Sec  内存限制: 128 MB
提交: 169  解决: 26
[提交][状态][讨论版]
题目描述
有n个小朋友一起结伴同行去上学，每个小朋友的口袋里都有一些糖果，孩子的世界总是单纯而又可爱，现在其中的小刷提出了一个问题，如果把某些人的糖果组合起来，能否组合出素数个糖果呢？如果能够组合出素数个糖果，能组成的最大的素数又是多少呢？如果不能，又最接近于哪个素数呢？如果一样接近，最大的又是哪个素数呢？
看，小刷的世界就是这么单洁而又可爱！

输入
第一行输入一个n，紧接着下一行输入n个整数ai表示n个小朋友口袋里的糖果。
(n <= 100 ai <= 10000,ai之和<=10000)

输出
对于每组数据，输出一个数answer，表示能组合出来的最大的素数，如果不能组合出素数， 输出能组合出来的最接近的素数，如果有多个，输出最大的那个。即满足abs(answer - i)是最小的，且answer最大。（ i是能通过若干个小朋友组合出来的糖果数量）输出的素数小于10000

样例输入
1
3
1
10
样例输出
3
11
提示
输出的素数小于10000
分析：0-1背包

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
#define INF 0x3f3f3f3f
int prime[10005];
int ans[10005];
int a[10005];
int n, T;
int main()
{
    memset(prime, 0, sizeof(prime));
    for (int i = 2; i <= 10000; i++)
    {
        if (!prime[i])
        {
            for (int j = 2 * i; j <= 10000; j += i)
            {
                prime[j] = 1;
            }
        }
    }
    while (~scanf("%d", &n))
    {
        memset(a, 0, sizeof(a));
        memset(ans, 0, sizeof(ans));
        int res = 2;
        int Min = 10000;
        ans[0] = 1; int sum = 0;
        for (int i = 0; i < n; i++)
        {
            scanf("%d", &a[i]);
            sum += a[i];
            for (int j = sum; j >= a[i]; j--)
            {
                ans[j] += ans[j - a[i]];
            }
        }
        for (int i = 1; i <= sum; i++)
        {
            if (ans[i])
            {
                for (int j = 0; j <= Min; j++)
                {
                    if (!prime[i - j])
                    {
                        res = i - j;
                        Min = j;
                    }
                    if (!prime[i + j] && i + j < 10000)
                    {
                        res = i + j;
                        Min = j;
                    }
                }
            }
        }
        printf("%d\n", res);
    }
    return 0;
}

问题 I: 炒菜
时间限制: 1 Sec  内存限制: 128 MB
提交: 312  解决: 53
[提交][状态][讨论版]
题目描述
皮卡丘和他的朋友四小正是好朋友，今天他决定炒菜给四小正吃，但四小正的食量大得惊人哪是皮卡丘喂得饱的，于是皮卡丘找来了会用电脑控制挖掘机炒菜的冯富帅，冯富帅会炒n种菜，每种菜能让四小正获得不同的满足度，四小正对所有菜的份数需求都是无限的，每种都要用挖掘机进行大量的操作，这是非常消耗能量的，幸好冯富帅精通电路，皮卡丘可以把自己的电力供给给挖掘机，皮卡丘希望能让四小正吃个痛快，请帮帮他。

输入
输入直到文件尾，每组n，m（n<=100，m<=10000）分别表示菜的种数和皮卡丘拥有的电力，接下来n行每行两个数a，b（a，b<=100）分别表示这道菜做一次需要的电力和能给四小正带来的满足度。

输出
四小正可以获得的最大满足度。

样例输入
2 10
1 1
2 1
样例输出
10
提示
皮卡丘拥有的原料数是无限的
分析：完全背包~

#include<iostream>
#include<cmath>
#include<iomanip>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn = 1e5 + 10;
char str[maxn];
struct node
{
    int a;
    int b;

}c[10005];
int dp[10005];
int main()
{
    int n, m;
    while (scanf("%d%d",&n,&m)!=EOF)
    {
        memset(dp, 0, sizeof(dp));
        for (int i = 1; i <= n; i++)
        {
            scanf("%d%d", &c[i].a, &c[i].b);
        }
        for (int i = 1; i <= m; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                if (i - c[j].a >= 0)
                {
                    dp[i] = max(dp[i], dp[i - c[j].a] + c[j].b);
                }
            }
        }
        printf("%d\n", dp[m]);
    }
    return 0;
}

问题 J: 坐电梯
时间限制: 1 Sec  内存限制: 128 MB
提交: 457  解决: 97
[提交][状态][讨论版]
题目描述
大只四正为了长肉已经懒到不择手段了，即使只隔一层楼也一定要坐电梯，他终于开始考虑电梯的感受了，久而久之他注意到电梯向上运行一层需要6秒钟，向下一层需要4秒钟，开一次门需要5秒钟，并且每下一个人需要1秒钟，求电梯完成一次任务所需的时间（电梯从0层开始（为了减少做功大家都喜欢从地下室上电梯），回到0层才算一趟任务结束）。

输入
输入直到文件尾，一个n，之后n行代表大家要去第几层。所有数小于等于100

输出
一趟任务的所需时间。

样例输入
1
1
样例输出
16
提示
提示：电梯总共花费的时间为：上去的总时间+下来的总时间+开门的总时间+人走出去的总时间。


有多少楼层就开几次门，有多少人就需要多少时间让人出去，上去的层数就是最高层的楼层，下来的层数也是最高层的楼层

[提交][状态]

分析：注意许多人可能在同一层下电梯，注意标记

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
#define ll long long int 
#define INF 0x3f3f3f3f
const int maxn = 1e5 + 10;
int main()
{
    int n; int a[105]; int vis[105];
    while (cin >> n)
    {
        memset(vis, 0, sizeof(vis));
        int Max = -1;
        for (int i = 0; i < n; i++)
        {
            cin >> a[i];
            vis[a[i]]++;
            if (a[i] > Max)
                Max = a[i];
        }
        int door = 0;
        for (int i = 0; i < 105; i++)
        {
            if (vis[i])
                door++;

        }
        cout << Max * 10 + n +5*door << endl;
    }
//  system("pause");
    return 0;
}

问题 K: 能量收集
时间限制: 1 Sec  内存限制: 128 MB
提交: 50  解决: 23
[提交][状态][讨论版]
题目描述
黑鸡是一个很萌的小朋友，他有一个奇怪的能力，可以把某个地区的能量收集起来（holy high！），现有一个国家有n个地区，通过n-1条双向边相连（任意两地可互相到达，黑鸡每次从一个只与一条边相连的地区开始，走到某个选定的地区，收集该地区所有能量，如此重复m次。However..黑鸡的能力有一个缺陷，就是他走过的所有城市能量都会清零（无论是否被收集），因此他开发出了一种能力，可以直接传送到一个城市，收集所有能量后传送回去，该能力有使用次数限制k。那么问题来了，黑鸡最多能收集多少能量？

输入
每组数据第一行为三个整数n,m,k,接下来n行表示n个地区的能量值;接下来n-1行每行两个数u,v，表示n-1条边;（n<=100000,0<=k<=m<=n）

输出
能收集的最大能量点数。

样例输入
5 1 1
1 2 3 4 5
1 2
2 3
3 4
4 5
样例输出
5
提示
[提交][状态]
分析：排序分析~各种分析~倒着分析~悬挂分析~

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 1e5 + 10;
int ans[maxn];
int main()
{
    int a, b, c, u, v;
    while (scanf("%d%d%d", &a, &b, &c) != EOF)
    {
        int sum = 0;
        for (int i = 0; i < a; i++)
        {
            scanf("%d", &ans[i]);
            //f
        }
        for (int i = 0; i < a - 1; i++)
        {
            scanf("%d%d", &u, &v);
        }
        sort(ans, ans + a);
        for (int i = a - 1; i > a - b - 1; i--)
        {
            sum = sum + ans[i];
        }
        printf("%d\n", sum);
    }
    return 0;
}