problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k ⌀ | fixed_code stringlengths 12 526k ⌀ | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M ⌀ | fixed_submission_id int64 2 1.54M ⌀ | user_id stringlengths 10 10 ⌀ | language stringclasses 9 values |
|---|---|---|---|---|---|---|---|
p03023 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 180) * N;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 2) * 180;
}
| [
"literal.number.change",
"io.output.change",
"identifier.replace.remove",
"literal.replace.add"
] | 835,104 | 835,105 | u618604643 | cpp |
p03023 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
int main() {
int n;
cin >> n;
cout << 90 * (n - 1) << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
int main() {
int n;
cin >> n;
cout << 180 * (n - 2) << endl;
return 0;
} | [
"literal.number.change",
"io.output.change"
] | 835,106 | 835,107 | u348670055 | cpp |
p03023 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
int main() {
int n;
cin >> n;
cout << 90 * (n - 2) << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
int main() {
int n;
cin >> n;
cout << 180 * (n - 2) << endl;
return 0;
} | [
"literal.number.change",
"io.output.change"
] | 835,108 | 835,107 | u348670055 | cpp |
p03023 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb(a) push_back(a)
#define fi first
#define se second
int main() {
ll n;
cin >> n;
cout << (n - 1) * 180 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb(a) push_back(a)
#define fi first
#define se second
int main() {
ll n;
cin >> n;
cout << (n - 2) * 180 << endl;
return 0;
} | [
"literal.number.change",
"io.output.change"
] | 835,120 | 835,121 | u136725765 | cpp |
p03023 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << 90 * (N - 1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << 180 * (N - 2) << endl;
} | [
"literal.number.change",
"io.output.change"
] | 835,124 | 835,125 | u609576113 | cpp |
p03023 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repf(i, m, n) for (int(i) = m; (i) < n; (i)++)
#define all(v) (v).begin(), (v).end()
#define ll long long
#define vec(name, num) vector<ll> name((num), 0);
#define op(i) cout << (i) << endl;
#define ip(i) cin >> (i);
#define opN cout << "No" << endl;
#define opY cout << "Yes" << endl;
#define opP cout << "Possible" << endl;
#define opI cout << "Impossible" << endl;
#define mat(name, fnum, snum) \
; \
vector<vector<ll>> name((fnum), vector<ll>((snum), 0));
#define matC(name, fnum, snum) \
; \
vector<vector<char>> name((fnum), vector<char>((snum), 0));
#define debugP \
int debug_point; \
cin >> debug_point;
#define FI first
#define SE second
const ll MOD = 1e9 + 7;
template <typename T> void putv(vector<T> &V) {
// cout << "The elements in the vector are: " << endl;
for (auto x : V)
cout << x << " ";
cout << endl;
}
ll pow_mod(ll fi, ll se, ll mod) {
if (se == 0) {
return 1;
}
if (se % 2) {
return pow_mod(fi, se - 1, mod) * fi % mod;
}
ll t = pow_mod(fi, se / 2, mod);
return t * t % mod;
}
template <class T> vector<T> getv(ll n) {
vector<T> Vector_temp;
rep(i, n) {
T input;
cin >> input;
Vector_temp.emplace_back(input);
}
return Vector_temp;
}
ll gcd(ll c, ll b) {
while (1) {
if (c % b != 0) {
ll tmp = b;
b = c % b;
c = tmp;
} else {
return b;
}
}
}
vector<pair<int, int>> Dir = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
/* <3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3*/
int main() {
ll n;
cin >> n;
op((n - 3) * 180);
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repf(i, m, n) for (int(i) = m; (i) < n; (i)++)
#define all(v) (v).begin(), (v).end()
#define ll long long
#define vec(name, num) vector<ll> name((num), 0);
#define op(i) cout << (i) << endl;
#define ip(i) cin >> (i);
#define opN cout << "No" << endl;
#define opY cout << "Yes" << endl;
#define opP cout << "Possible" << endl;
#define opI cout << "Impossible" << endl;
#define mat(name, fnum, snum) \
; \
vector<vector<ll>> name((fnum), vector<ll>((snum), 0));
#define matC(name, fnum, snum) \
; \
vector<vector<char>> name((fnum), vector<char>((snum), 0));
#define debugP \
int debug_point; \
cin >> debug_point;
#define FI first
#define SE second
const ll MOD = 1e9 + 7;
template <typename T> void putv(vector<T> &V) {
// cout << "The elements in the vector are: " << endl;
for (auto x : V)
cout << x << " ";
cout << endl;
}
ll pow_mod(ll fi, ll se, ll mod) {
if (se == 0) {
return 1;
}
if (se % 2) {
return pow_mod(fi, se - 1, mod) * fi % mod;
}
ll t = pow_mod(fi, se / 2, mod);
return t * t % mod;
}
template <class T> vector<T> getv(ll n) {
vector<T> Vector_temp;
rep(i, n) {
T input;
cin >> input;
Vector_temp.emplace_back(input);
}
return Vector_temp;
}
ll gcd(ll c, ll b) {
while (1) {
if (c % b != 0) {
ll tmp = b;
b = c % b;
c = tmp;
} else {
return b;
}
}
}
vector<pair<int, int>> Dir = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
/* <3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3*/
int main() {
ll n;
cin >> n;
op((n - 2) * 180);
return 0;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 835,126 | 835,127 | u190234543 | cpp |
p03023 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
cout << N * 180;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 2) * 180;
} | [] | 835,128 | 835,129 | u768204022 | cpp |
p03023 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
cout << 180 - (N - 2);
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
cout << 180 * (N - 2);
return 0;
} | [
"expression.operator.arithmetic.change",
"io.output.change"
] | 835,130 | 835,131 | u710135612 | cpp |
p03023 | #include "bits/stdc++.h"
using namespace std;
#define ll long long
#define endl '\n'
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, a, b) for (int i = int(a); i < int(b); i++)
#define pb emplace_back
#define all(x) (x).begin(), (x).end()
ll mod = 1e9 + 7;
ll mod2 = 998244353;
const int INF = 1e9;
signed main() {
ll n;
cin >> n;
cout << (n - 1) * 90 << endl;
}
// `.`..`(WNNNNNNMNWWWH9rttwgHM8OtttwwVtttrrtrttrw0rtrtwrrrtrZUAOOrrrXWppHMHyZHpWHMHMkWWVHMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// `.`.`..`(WMNMHfWH9ZtrtAdNM8ttttOwVtrrtrrtrrrrrdrrttrZkOrrrrrrXWyrtrrZWWWWMmwXWppWHHMmWHkWMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// .`.```_..(HMfWH9OtttwXWHBrttrOw0rttrOvrrrtrZrrRrtrrrtZHwrrrrrwwZHyrrrrZWWpWMmwWppkWHHMkHNkVWMNNNNN#NN#NN#NN#NN#NN#NN#NN#NN#NN#NNNN
// .``..
// ..HNfWW9wtrrOdWHM0trttOdSrtrtwwrtrtrw0twSrtOrrrrZHwtrrrrrXwdWwrrrrXHppWNkXWpkvWH@MkHMHkWMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// `.`.
// -jMWWXXwtrttO0d@BrtrttwXVrtrrwVrrrtrtXrrd0rrXrrrrrZWyrrrrrrZXwWyZOrrvWWpWMkZHbkwrdHMMKMMNHkHMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// `.`.
// v8Xdk9ttttrOwXM0tttrtwXwwrtrw0rrtrrtwKrrd0rrXrtrrrrZHkwrrrrrrXkVkrrrvrZHWpHHkWkwrwvVHHNWMMMMkWMNNNNNNN#NN#NN#NN#NN#NN#NN#NNNN
// ..
// JHZdbKOrrrtrtwWWOOttrOwSzVrOrw0rrttrrrdRrrdZrrdOrtrtrrZHkXwrrrrrZWXHwwrrrvWWWWNkWkvrrrwWM@RMMMNNmWMNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// .
// .JGXHStttttrtwW9OrtrrrdSX0rtrdStrtrtrrwHVrrdkrrtSrrrrrrrdMyXrrrrrvXWXWmwvrrvdHWWNkWyvvvvvT@MNWM#N#MNWMMNNNNNNNNNNNNNNNNNNNNNNNNN
// (.zqHXZtrttrrOwU0trttrOdWX0OtOdRrrtrrrrrdNrrrdkrrrXOwrrrrrrdNySrrrrrwXXkUmvvwvrZHWfNkUkvwvvvdMMMRM#MMNNNkMMNNNNNN#NN#NN#NN#NN#NNNN
// (wdS0OttrtOOrwSrtttrrtwKukrrrwKrrrrrtrrwW@rrrXKrrrZkr0OrrrrrWNwkrvvrrvzXkXHwvvrvwWVVHkUyrvvvvZHMMNWMMNNNNNkWMNNNNNNNNNNNNNNNNNNNNN
// wWtrrttrrOwrwStrttrtrwWZXOrtwX0rrrttrrrXMSrrrXWrrrrXrwvrrrrvZHHXkrrrrvrzWkXNyvrvvvWWWHHWwvvvvvwHNMHRM#NNNNNMmWMMNNNNNNNNNNNNNNNNNN
// 8OtttrwZwwtwSrrttrrrwdyXwtrrdWrrtrrrrrdWH0rrrXWOrrrwRz0rrvrrrdMHWwvvrrvvXWkWHyrvvvrWWWHkHvvvvvvwWMMMNWMMNNNNNMHWMMNMNNNN#NN#NNNNNN
// wttrrdVrZrwWwtOrrrrwdWX0rrtdH0rrrtrrtwWHHrrrrXWRrrvrXXXrrvrrrvXHkSwvvrvrrXWkVHyvvvvwHVWHWRvvvvvvdHdMMMKMNNNNNNNMNkWMNNNNNNNNNNNNNM
// ttrrd0rwrOX0rrtrrtwXHXSrwrwHKrtrtrrtrdWH#rrrrdpkrrrrvHwkwvrrvrZWHXkzzvvvvwUWkpNwvrvvZHfVNHwvvvvvzXHWMNMNMNNNNNNNN#NkWMNNNNNNNNNM3>
// rrrdSrwwtXSrrtrrrwXWWKwrrrdHXrrrrrrrwWWH#vrrrvWpvrrvrdRXwvrvrvvXHWWwkvvrvvwWWKWHzwvvvXHVWWHvzzzzvzWRHMMMNHMNNNNNNNNMNkMMNNNNNN@<<>
// OOd9rw0rdKOtrtrrruXHW0rrrdH#rrrrrrrrdpWp#rrrrrXWkvrvvrWwkrvrrvwwWHpKdvvrrvvXHHfWmdwvzwWHVHWkzzzzzzwWXHMHHNWMNNNNNNNNNMNkMNNNN#z>>>
// OdSOwSwwW0rrrrtrwXNW8rrtrWWSrtrrrrrrXpHWHvrrrrXpHrrrvwZHdyvvvvvvXHpHwkvvvvvrXHHfNwXvzzwWWWKHzzzzzzzWSWHHHMMKMNNNNNNNNNNMNKMNN#>>;>
// wWwOXrwX8rtrrrrwWWpHrrrrdNNrrrrrrrrwppNWHrvrvrypWwvvrrvXKWvrvrvvZXHHkXzvvvvvwWWWWNdkvvzXHfHWkXzzzzzwWXHHHHNMHMNNNNNNNNNNNNNWMN+>>>
// R0rd0rdKrrtrtrrdWHWSrrrwWWDrrrrrrrrXpWHqWvrrrvdWbRvvrvvwWZkvvvrvvXHbHzRvvvvvvdHHpHkWwvzXWHWHHzuzzzzzXXWHHHMHMNHMNNNNNNNNNNNMNWh<>>
// wOwSrwXSrtrtrrwHWWMwrrrdNWSrrrrrrrvppWpHprrvrvddWHwvvrrvXHXwvvvrvzXWHkXzvvvvvzWWKWNdRvzzXWWHHXzzzzzzzudWHbH@HNNWMNNNNNNNNNNNNNkHe>
// rOXwwwKrrrrrrrXWHHDrrwrdHHXwrrrrrrwpWWbHWvvvrvwHHpHrvvvrXWHWwvvrwwXHkHdkvzvvvvZHHpHKWzzzwWHWHRzzzzuzzzzWHHkHHMMNWMNNNNNNNNNNNNNNKm
// rdX0OXSrrtrrrdHHWMXrrrwHWHrrrrrrrrXppqWHWkrrvvwWMHHXwwvvvZWKRvvvvrWHWHwWvzvzzzzXWKWNXRzzwXWWNHzzzzzzzzzXUHkHWMMHNWMNNNNNNNNNNNNNNN
// wSwww#rrrrrrwWWHM#vrrrd#WKvrrrrrvvXppmWMWkvvvvwXNNpNvSXzzvdHkkvvzvdWWWRXwzzzzzzdNNpMkHzzzWVHHpXzzzzzzzzdkHkHHHNMHNkMNNNNNNNNNNNNNN
// XwSwWwrrrrrrdHWWMKrvrvWHWSrvrvvvvwpppHW#HRwUUUWWMMMMMHHHHmmXHWwvvzwWHbNwRzzzzzzzWWWWHWkzzdXWWWRzzzzzzzuzWWbHHWMNMMNkMNNNNNNNNNNNNN
// 8drd#rrrrrrwWWkHMmXmywMfWXrvrrrvrwppWNWMNWvrvvwvW#MNHmdkrvvXHMMmmwzdWpM0WzzzzzzzdHHWNUHzzzWWmHHzzuzzuzuzWXbbNkHMqMHNkHNNNNNNNNNNNN
// dSwWSrrrrrrdHHHMHrrrwWMfWvvvrvrrrdppWNW#WWRvvrvvdM?WNHkXkzvvdWMHXHNmHHHkfwzzzzzzXHHpMWHkzuXWHNWXzzuzzuzzXXkkHbHMHMMMMkMNNNNNNNNNNN
// Xrd#wrrrrrrXpHWH#rrrvdMWWvrrvrvvrdppWHW#(NWwvvvvwMr~TNHmdkvzvXWMKzzzWMHKXXzzzzzzuWHbHkWKuzdWWHWkzzzuzzuuXXHkHkgHk@H@HHkMNNNNNNNNNN
// RvWDrrrrrrwHWkMW#rvvrMMfWwrvrrvvrdppWHW@~?HHuvvrvdb_~?NWkdkzzzUWMkzuuWWHWXuzwzzuzXHHHKWHuzzWW@WRuzuzzzzzduWbHHgMH@HHHMMHMNNNNNNNNN
// rdHwrrrrrrXHHWNW#vvvdMMHWkvrvrrvrdppWbWD~~?XKkrrrwMc~~~THHZHwzzWHNkvzwMRdHHzuzzzzXHHWHXNkuzdWHkWuzzuzuzzXzWkHHHMHHHkH@MMNWMNNNNNNN
// rdHvrrrrrrWkHHHW#rrrd#dNWKrvrvvrvwbpWWW$...vVkkOrtXb~~~~(WHkWkvwWWMkzzWRXkSWXzzzuwmNWHXHRuuwHMKWzzuzzzuzXzWHWHHMHHHkkMMMHHWNNNNNNN
// wW#rrvrrrwHWHMpWNrvrd@(NWWvrrrrrvvWpWXH$..._?dkkttOWl~~~~~?HHdHXXbWMkzUHXWkzzzzzzuHNk#XHHzzukHHXzuzzzuzuXuXqkMHMHMbbkHHH@HNWMNNNNN
// dH#rrrvrrdNWWNpHHwrrd@_WHWkrvvrrrrZpWXWr...__?WkWyOvN~~~~~__7HkWkbbkNkzXHZkzzzuzzzWHW#ugbXuzWWHXXuzzuzuuuzXkkHHH@MbkHMHMHMMNWMNNNN
// X@KrrvrvrXNHWHpHHHrrdb~(NWHrrrrrrrrXWXWr..`...-7HZkzvn~~~~~~~_TNyHHkHMyzXkXuzzzzuuWHW#uHkkzzWHHXuzzzzuzzuuXHkHHHMNbkHHHHHHMMNWMNNN
// WHKvvrvrvXHNMbpHmHkOwb..?HWRrwOrtrtrWKWr`.`.`..._?6dkJn~~~~~~-_~7NHMHbNkuUkzzuzzzuWHW#uHbRzuXHHXzzuuuuzuuzXHkHHMMbkkHkMkkkMMMNUMMN
// WHKrrvrrvXqHMpfHHHWkrb...vkHyOrtttttdNXr.`.J>~-((J+ggQkHXHHHmaJz7&JWHMMWkuHXzuuuzzWgHHwHkKuzXMKXuzuuzuzzuzdkHHHHHkHWMHHbkWHMMMNXM#
// Wg#rvrvrrXmHNpfHHHMMRd-.._4kfyttttllOHWr``
// <udT"""7"""""TMHHMNHHMNgv4HMRXHXHwuzzzuWHHKXHkHzzXMSWzuzzuzuuzudbkHHHHkkHqHuWkWHHMMMNWM
// WHNrvrvvvXHmNppgg@MMMHr..` UkWOlllllldW$..?! ` `
// ?@MMHHMM#NMMmMkXXWkHuzuzuWNHSXHHHuuXNSWuzuuzuzuzuWkHNgMkkkMHSuWkqmqHHMNNK
// WHMkvvrvrXHHMppHHHMNMTN_``` 4kWOz====vXP` ` `
// ``.HggmgM@MH###NKkkuXWHzzuXHHMzdMHHuzWNXKzuuzuzuzuuHkHHNMkkHHBuzWkHHHHuHMMM
// WHHNzvvrvwHMMppHMMMM>.#L`````?kyy====?0S`` ` `
// ``...dmqqqmmHHHMMM#WRSzuzWHuzXHq#uWHHHzuWHXKzuzzuzuzuXHkHWMNkWM#uzuWHHHHSuuWM#
// WM@MkwvvrzXMMHpgHMMM[.MN.`````(HXy1???zd.`` ` ` `
// dHkkqkkqkHHHHHHMMWWXzzuzwWwXHHKXMkHHuXMRXSuuuzuuzuzXHkHdHHWHHXuuwWHqHHuXzXWM
// XHHMNyrvvwdW@HpHWMHML MM[` ` `.4kGz<<>Or``` `
// `dWpbbbbbHMMbbbHHMXXuzzuzuzXWHHSXMkHHuXMSXuzzuzzuzuzWkkHWMHMSwuzzXHkHHXuzuWd#
// dHHH@NyzwwwWHMHHWMMMR dW]`` ` ```(HZx<<<4.```` `` ``
// OZppfppppWfpWpK9NKXuuzuuzuXWHHudMqNHXWNuHuzzuzuzuzuHkHXMMBuuuzuuWkHHUuuuXSMS
// wWHMMMMkwwvdNpHHHM#MH-jWP``` `` ```7kI<:<h.``````` ``
// ,2OWVVyVVyWWWWIdMKWzuuuzzuXHHSwHHHHKXHHXSuuzuuzuzuXHHHXMXuuuuuuXHHHuzuuXSX#X
// wdWHMMMMmwXwHbpMNHMM@b.hb```````````
// 7x1_(>_```````````(x7UUUV0XwvCI1dMWKXuzzuzuWHHudMkgkWbMSXuzzzuzzuzuWkHSW#zXwXuXXWHHuuXXuWXWSX
// vvXWHMMHWNkvWHbbMWMMMN_JF.```` ``
// `````?1_(_.`.`........(<777=<<<><<+dMXUuzuuuuWWMRwMHWMkWHHXSuuzuzuzzuXqHHXMHUXuXXHHHSuuwuXWud8uH
// mzzXWH#zHbHkXNbbWMMMMD~(_```````````````
// .~_`.``.`.`.....___(<~(<<(<<dHkkuuuuuXkHHuWMkHkkkHSXXzuuzuuuuzXHHSd#uuXXWHHXuuuZuXSuqHudS
// UHzzXWSXXWbbHHHbWHMH#<~...```` ``````````````.```.`
// -_____<~~_<_<~~(jMWSuzuzuXWHMHXMHHHkkH#XSuzzuzuzuzuKkHXMQkWHHWUXuXXUuXUuXHuXBu
// .(Smd8wSvXbbbbHHHWHW3___.``````` ``
// ``````.```.```.`...._.._~~..~_~~(#WuzuuzXXkHMqMMHMkkkMUXuXzuuwuuzuXkHSWMWUUuuuXXUUuXHXXWSuXHXu
// .. JKwSvwzWkkkkHHHH5~~..```````````````````.```.````````.`
// .........dWSuuzzzdkHMW@MHMkkkHHXXuzuuXSuzuuWWHd#uuuXXkWSuXXWUXXHUXWHuuu
// .`(HXSzzzzwWbkWHNHr_...``````````````````.```````.```````.`.`..`.-.(HKuzzuuwHHMNMHHMkkkHHuZuuzuuXuuuuXkHWMHHHUUuXXXWHXXHHUuXW8uuuu
// .-MXWwzzzuzXkHHMHHN-.``````````
// ````````````.`.````.``.```.`.`....-dXUXuzuXHWHMMHHBWHMMMSZuzuuzXXzuuXHHMHMHkHHHHHHHWHHSuXkHWSuuuuX
// (#XKzzzzzuzuWHHkWHHp
// ``.````````````````````````.````````.....-((-(NSXuzzXHW@D:~`(/1-
// .kXuzuuzXSuuzXXkHWMHHHHHHHHMWuuuQXUXWuuuXuXH
// MXWzuzzzzzuXHHbHNMMMt`.```````````````````````````.`.` ..-J7"!``
// XKuzzuXHHM9;/<-.J-u!JXXuuzuXWuuuuXHHH#WMNHmkkkuXXkWUXXWXXuuuXqHH
// XWzzzzuzzwXHHHH#"````<.````````````````````.``.`...-c"7``` ` `
// `(BzuuuXmHH8<!(- ?_!`jWUuzuuuWuuuzXWHNH> ..7WHHqHmQkWWXXuuuuuXWqHH
// SwuzzzXuwXHNHY`` `` <,`.`````````````` `` ..J7=``` ` ` ``
// ````.#zuzXXHHH$~`` ```(_(HSuuuzuXSuzuuXHHWCi(` ._ ?WggHHHHWkkkkWHHHHMH
// zzzuzuzwWHMY!` ` ` `(&.```````````` ..J7^ `` ` ` ` ` `. .HXuuXWHW#!` `
// ```` (WUuzzuXXSzuuudHHXY$. : (..``.THHkqkHHHgHHMHkkk zzzzzzXHWK`` ` `` ` ` `
// TJ.``````..J7=```` ` ` ` ` `` ` `.8zuXXHHW=` ``
// ..(XSuuuuuXWuuuuXHWH5~~` .`_?_,-``.TMMMMMMHkkqqHHH zzuuzdHHkN ` ` ` `` `
// ``(Wm,.(J7!``` ` ``` `` `` ` ` ``` .SzuXWHHY ``
// .._~<~~(dSuuuzzXHuuuuXHWHD::?C._.( -`(!_1 ,WHqHHHmqHHHHN zuzXXHHkHM;` ` ` `
// `` ` .;jY= ` .``_`` ` ` ` ` `` ` `.dXuXWm@^
// .._~_.~~~~~(d0uuzuuXHUuuuXHWH5:::::::_.<&._4r?_.;WMMM@MMY"<!` zzXHHHHMHMb``
// `` ` `` `` .J! ` ..`_~ ` ` ` `` ` ` ``.JXXXHY!
// .__.....~.~~~-d0wuzuXXHSuuuXWWH$::::;:::;:+- ~`(.i +HqHHkkHL..`. XWHHHMMHMHM;
// ` ` ` ` ._`` ...(:.=_` ` ` ` ` ````
// .-dVT7^``````......~~~~~_jWuuuuuXHSuzuXHHH3<;:::::;;j<+z ``` -dHNkkMqkkN..``
// HHHMMHHHHNMN.`` ` ` `!`z(. ~..~ ! . ` `` ` ` `
// ..gHr``````````........~~~~_jWuuuuuXkSuuuXHWHC:;::;;:::+v>:((J<!(WHHMkkHNqkM;`..
// HMMkkHHHHM9?b `` ` ` `` .``. ` ` ` ` ``` 4HkkkH,
// ``````.`......~~~~_+KuuuzuXHSuuuXHHK<(::::::<;<J+g9>::;< .4NkkqMHqH]..`
// MHkHHHMM$<<:?L` `` ` ` ` ``.` ` !`` ` ` ` ` `
// ?HbkkHx``````.`..`...~~~~_jKuuuuuXHSuuuqMHD<:<;:<++ddNMB3:;::;:<`
// `,HkkqH@HH].`` kkHHkHY``` (;?h`` ` ` `` ```` ` ` ` ` ` ` ` `
// ```.4XWbHx```..`......~~~~_gKuuuuXWH0uuuXHH3:;++1z<jgMB3<::::::::~`
// `jMkqkHMHHF.`. kHHHH=` . ` _<?L ` ` ` ` ` ` ` ` ` ` ` ` ` ` ?kwWHp
// .`.......~_~~(dKuuuuXWHUuuXWH9++z1<;+jWB3::::;;;::;:;_`` MNkqkqMNMF..` HHk@!.
// ` ` ` ~?L ` ` `` ` `` `` ` ` ` ` ` ` ` `
// -WuXHh..`.....~~~~(dWuuuXXkHUuuXHH9>:<:++YY<:;::::;:::::;:::+.``?HHkHHHM>`.`
| #include "bits/stdc++.h"
using namespace std;
#define ll long long
#define endl '\n'
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, a, b) for (int i = int(a); i < int(b); i++)
#define pb emplace_back
#define all(x) (x).begin(), (x).end()
ll mod = 1e9 + 7;
ll mod2 = 998244353;
const int INF = 1e9;
signed main() {
ll n;
cin >> n;
cout << (n - 2) * 180 << endl;
}
// `.`..`(WNNNNNNMNWWWH9rttwgHM8OtttwwVtttrrtrttrw0rtrtwrrrtrZUAOOrrrXWppHMHyZHpWHMHMkWWVHMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// `.`.`..`(WMNMHfWH9ZtrtAdNM8ttttOwVtrrtrrtrrrrrdrrttrZkOrrrrrrXWyrtrrZWWWWMmwXWppWHHMmWHkWMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// .`.```_..(HMfWH9OtttwXWHBrttrOw0rttrOvrrrtrZrrRrtrrrtZHwrrrrrwwZHyrrrrZWWpWMmwWppkWHHMkHNkVWMNNNNN#NN#NN#NN#NN#NN#NN#NN#NN#NN#NNNN
// .``..
// ..HNfWW9wtrrOdWHM0trttOdSrtrtwwrtrtrw0twSrtOrrrrZHwtrrrrrXwdWwrrrrXHppWNkXWpkvWH@MkHMHkWMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// `.`.
// -jMWWXXwtrttO0d@BrtrttwXVrtrrwVrrrtrtXrrd0rrXrrrrrZWyrrrrrrZXwWyZOrrvWWpWMkZHbkwrdHMMKMMNHkHMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// `.`.
// v8Xdk9ttttrOwXM0tttrtwXwwrtrw0rrtrrtwKrrd0rrXrtrrrrZHkwrrrrrrXkVkrrrvrZHWpHHkWkwrwvVHHNWMMMMkWMNNNNNNN#NN#NN#NN#NN#NN#NN#NNNN
// ..
// JHZdbKOrrrtrtwWWOOttrOwSzVrOrw0rrttrrrdRrrdZrrdOrtrtrrZHkXwrrrrrZWXHwwrrrvWWWWNkWkvrrrwWM@RMMMNNmWMNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// .
// .JGXHStttttrtwW9OrtrrrdSX0rtrdStrtrtrrwHVrrdkrrtSrrrrrrrdMyXrrrrrvXWXWmwvrrvdHWWNkWyvvvvvT@MNWM#N#MNWMMNNNNNNNNNNNNNNNNNNNNNNNNN
// (.zqHXZtrttrrOwU0trttrOdWX0OtOdRrrtrrrrrdNrrrdkrrrXOwrrrrrrdNySrrrrrwXXkUmvvwvrZHWfNkUkvwvvvdMMMRM#MMNNNkMMNNNNNN#NN#NN#NN#NN#NNNN
// (wdS0OttrtOOrwSrtttrrtwKukrrrwKrrrrrtrrwW@rrrXKrrrZkr0OrrrrrWNwkrvvrrvzXkXHwvvrvwWVVHkUyrvvvvZHMMNWMMNNNNNkWMNNNNNNNNNNNNNNNNNNNNN
// wWtrrttrrOwrwStrttrtrwWZXOrtwX0rrrttrrrXMSrrrXWrrrrXrwvrrrrvZHHXkrrrrvrzWkXNyvrvvvWWWHHWwvvvvvwHNMHRM#NNNNNMmWMMNNNNNNNNNNNNNNNNNN
// 8OtttrwZwwtwSrrttrrrwdyXwtrrdWrrtrrrrrdWH0rrrXWOrrrwRz0rrvrrrdMHWwvvrrvvXWkWHyrvvvrWWWHkHvvvvvvwWMMMNWMMNNNNNMHWMMNMNNNN#NN#NNNNNN
// wttrrdVrZrwWwtOrrrrwdWX0rrtdH0rrrtrrtwWHHrrrrXWRrrvrXXXrrvrrrvXHkSwvvrvrrXWkVHyvvvvwHVWHWRvvvvvvdHdMMMKMNNNNNNNMNkWMNNNNNNNNNNNNNM
// ttrrd0rwrOX0rrtrrtwXHXSrwrwHKrtrtrrtrdWH#rrrrdpkrrrrvHwkwvrrvrZWHXkzzvvvvwUWkpNwvrvvZHfVNHwvvvvvzXHWMNMNMNNNNNNNN#NkWMNNNNNNNNNM3>
// rrrdSrwwtXSrrtrrrwXWWKwrrrdHXrrrrrrrwWWH#vrrrvWpvrrvrdRXwvrvrvvXHWWwkvvrvvwWWKWHzwvvvXHVWWHvzzzzvzWRHMMMNHMNNNNNNNNMNkMMNNNNNN@<<>
// OOd9rw0rdKOtrtrrruXHW0rrrdH#rrrrrrrrdpWp#rrrrrXWkvrvvrWwkrvrrvwwWHpKdvvrrvvXHHfWmdwvzwWHVHWkzzzzzzwWXHMHHNWMNNNNNNNNNMNkMNNNN#z>>>
// OdSOwSwwW0rrrrtrwXNW8rrtrWWSrtrrrrrrXpHWHvrrrrXpHrrrvwZHdyvvvvvvXHpHwkvvvvvrXHHfNwXvzzwWWWKHzzzzzzzWSWHHHMMKMNNNNNNNNNNMNKMNN#>>;>
// wWwOXrwX8rtrrrrwWWpHrrrrdNNrrrrrrrrwppNWHrvrvrypWwvvrrvXKWvrvrvvZXHHkXzvvvvvwWWWWNdkvvzXHfHWkXzzzzzwWXHHHHNMHMNNNNNNNNNNNNNWMN+>>>
// R0rd0rdKrrtrtrrdWHWSrrrwWWDrrrrrrrrXpWHqWvrrrvdWbRvvrvvwWZkvvvrvvXHbHzRvvvvvvdHHpHkWwvzXWHWHHzuzzzzzXXWHHHMHMNHMNNNNNNNNNNNMNWh<>>
// wOwSrwXSrtrtrrwHWWMwrrrdNWSrrrrrrrvppWpHprrvrvddWHwvvrrvXHXwvvvrvzXWHkXzvvvvvzWWKWNdRvzzXWWHHXzzzzzzzudWHbH@HNNWMNNNNNNNNNNNNNkHe>
// rOXwwwKrrrrrrrXWHHDrrwrdHHXwrrrrrrwpWWbHWvvvrvwHHpHrvvvrXWHWwvvrwwXHkHdkvzvvvvZHHpHKWzzzwWHWHRzzzzuzzzzWHHkHHMMNWMNNNNNNNNNNNNNNKm
// rdX0OXSrrtrrrdHHWMXrrrwHWHrrrrrrrrXppqWHWkrrvvwWMHHXwwvvvZWKRvvvvrWHWHwWvzvzzzzXWKWNXRzzwXWWNHzzzzzzzzzXUHkHWMMHNWMNNNNNNNNNNNNNNN
// wSwww#rrrrrrwWWHM#vrrrd#WKvrrrrrvvXppmWMWkvvvvwXNNpNvSXzzvdHkkvvzvdWWWRXwzzzzzzdNNpMkHzzzWVHHpXzzzzzzzzdkHkHHHNMHNkMNNNNNNNNNNNNNN
// XwSwWwrrrrrrdHWWMKrvrvWHWSrvrvvvvwpppHW#HRwUUUWWMMMMMHHHHmmXHWwvvzwWHbNwRzzzzzzzWWWWHWkzzdXWWWRzzzzzzzuzWWbHHWMNMMNkMNNNNNNNNNNNNN
// 8drd#rrrrrrwWWkHMmXmywMfWXrvrrrvrwppWNWMNWvrvvwvW#MNHmdkrvvXHMMmmwzdWpM0WzzzzzzzdHHWNUHzzzWWmHHzzuzzuzuzWXbbNkHMqMHNkHNNNNNNNNNNNN
// dSwWSrrrrrrdHHHMHrrrwWMfWvvvrvrrrdppWNW#WWRvvrvvdM?WNHkXkzvvdWMHXHNmHHHkfwzzzzzzXHHpMWHkzuXWHNWXzzuzzuzzXXkkHbHMHMMMMkMNNNNNNNNNNN
// Xrd#wrrrrrrXpHWH#rrrvdMWWvrrvrvvrdppWHW#(NWwvvvvwMr~TNHmdkvzvXWMKzzzWMHKXXzzzzzzuWHbHkWKuzdWWHWkzzzuzzuuXXHkHkgHk@H@HHkMNNNNNNNNNN
// RvWDrrrrrrwHWkMW#rvvrMMfWwrvrrvvrdppWHW@~?HHuvvrvdb_~?NWkdkzzzUWMkzuuWWHWXuzwzzuzXHHHKWHuzzWW@WRuzuzzzzzduWbHHgMH@HHHMMHMNNNNNNNNN
// rdHwrrrrrrXHHWNW#vvvdMMHWkvrvrrvrdppWbWD~~?XKkrrrwMc~~~THHZHwzzWHNkvzwMRdHHzuzzzzXHHWHXNkuzdWHkWuzzuzuzzXzWkHHHMHHHkH@MMNWMNNNNNNN
// rdHvrrrrrrWkHHHW#rrrd#dNWKrvrvvrvwbpWWW$...vVkkOrtXb~~~~(WHkWkvwWWMkzzWRXkSWXzzzuwmNWHXHRuuwHMKWzzuzzzuzXzWHWHHMHHHkkMMMHHWNNNNNNN
// wW#rrvrrrwHWHMpWNrvrd@(NWWvrrrrrvvWpWXH$..._?dkkttOWl~~~~~?HHdHXXbWMkzUHXWkzzzzzzuHNk#XHHzzukHHXzuzzzuzuXuXqkMHMHMbbkHHH@HNWMNNNNN
// dH#rrrvrrdNWWNpHHwrrd@_WHWkrvvrrrrZpWXWr...__?WkWyOvN~~~~~__7HkWkbbkNkzXHZkzzzuzzzWHW#ugbXuzWWHXXuzzuzuuuzXkkHHH@MbkHMHMHMMNWMNNNN
// X@KrrvrvrXNHWHpHHHrrdb~(NWHrrrrrrrrXWXWr..`...-7HZkzvn~~~~~~~_TNyHHkHMyzXkXuzzzzuuWHW#uHkkzzWHHXuzzzzuzzuuXHkHHHMNbkHHHHHHMMNWMNNN
// WHKvvrvrvXHNMbpHmHkOwb..?HWRrwOrtrtrWKWr`.`.`..._?6dkJn~~~~~~-_~7NHMHbNkuUkzzuzzzuWHW#uHbRzuXHHXzzuuuuzuuzXHkHHMMbkkHkMkkkMMMNUMMN
// WHKrrvrrvXqHMpfHHHWkrb...vkHyOrtttttdNXr.`.J>~-((J+ggQkHXHHHmaJz7&JWHMMWkuHXzuuuzzWgHHwHkKuzXMKXuzuuzuzzuzdkHHHHHkHWMHHbkWHMMMNXM#
// Wg#rvrvrrXmHNpfHHHMMRd-.._4kfyttttllOHWr``
// <udT"""7"""""TMHHMNHHMNgv4HMRXHXHwuzzzuWHHKXHkHzzXMSWzuzzuzuuzudbkHHHHkkHqHuWkWHHMMMNWM
// WHNrvrvvvXHmNppgg@MMMHr..` UkWOlllllldW$..?! ` `
// ?@MMHHMM#NMMmMkXXWkHuzuzuWNHSXHHHuuXNSWuzuuzuzuzuWkHNgMkkkMHSuWkqmqHHMNNK
// WHMkvvrvrXHHMppHHHMNMTN_``` 4kWOz====vXP` ` `
// ``.HggmgM@MH###NKkkuXWHzzuXHHMzdMHHuzWNXKzuuzuzuzuuHkHHNMkkHHBuzWkHHHHuHMMM
// WHHNzvvrvwHMMppHMMMM>.#L`````?kyy====?0S`` ` `
// ``...dmqqqmmHHHMMM#WRSzuzWHuzXHq#uWHHHzuWHXKzuzzuzuzuXHkHWMNkWM#uzuWHHHHSuuWM#
// WM@MkwvvrzXMMHpgHMMM[.MN.`````(HXy1???zd.`` ` ` `
// dHkkqkkqkHHHHHHMMWWXzzuzwWwXHHKXMkHHuXMRXSuuuzuuzuzXHkHdHHWHHXuuwWHqHHuXzXWM
// XHHMNyrvvwdW@HpHWMHML MM[` ` `.4kGz<<>Or``` `
// `dWpbbbbbHMMbbbHHMXXuzzuzuzXWHHSXMkHHuXMSXuzzuzzuzuzWkkHWMHMSwuzzXHkHHXuzuWd#
// dHHH@NyzwwwWHMHHWMMMR dW]`` ` ```(HZx<<<4.```` `` ``
// OZppfppppWfpWpK9NKXuuzuuzuXWHHudMqNHXWNuHuzzuzuzuzuHkHXMMBuuuzuuWkHHUuuuXSMS
// wWHMMMMkwwvdNpHHHM#MH-jWP``` `` ```7kI<:<h.``````` ``
// ,2OWVVyVVyWWWWIdMKWzuuuzzuXHHSwHHHHKXHHXSuuzuuzuzuXHHHXMXuuuuuuXHHHuzuuXSX#X
// wdWHMMMMmwXwHbpMNHMM@b.hb```````````
// 7x1_(>_```````````(x7UUUV0XwvCI1dMWKXuzzuzuWHHudMkgkWbMSXuzzzuzzuzuWkHSW#zXwXuXXWHHuuXXuWXWSX
// vvXWHMMHWNkvWHbbMWMMMN_JF.```` ``
// `````?1_(_.`.`........(<777=<<<><<+dMXUuzuuuuWWMRwMHWMkWHHXSuuzuzuzzuXqHHXMHUXuXXHHHSuuwuXWud8uH
// mzzXWH#zHbHkXNbbWMMMMD~(_```````````````
// .~_`.``.`.`.....___(<~(<<(<<dHkkuuuuuXkHHuWMkHkkkHSXXzuuzuuuuzXHHSd#uuXXWHHXuuuZuXSuqHudS
// UHzzXWSXXWbbHHHbWHMH#<~...```` ``````````````.```.`
// -_____<~~_<_<~~(jMWSuzuzuXWHMHXMHHHkkH#XSuzzuzuzuzuKkHXMQkWHHWUXuXXUuXUuXHuXBu
// .(Smd8wSvXbbbbHHHWHW3___.``````` ``
// ``````.```.```.`...._.._~~..~_~~(#WuzuuzXXkHMqMMHMkkkMUXuXzuuwuuzuXkHSWMWUUuuuXXUUuXHXXWSuXHXu
// .. JKwSvwzWkkkkHHHH5~~..```````````````````.```.````````.`
// .........dWSuuzzzdkHMW@MHMkkkHHXXuzuuXSuzuuWWHd#uuuXXkWSuXXWUXXHUXWHuuu
// .`(HXSzzzzwWbkWHNHr_...``````````````````.```````.```````.`.`..`.-.(HKuzzuuwHHMNMHHMkkkHHuZuuzuuXuuuuXkHWMHHHUUuXXXWHXXHHUuXW8uuuu
// .-MXWwzzzuzXkHHMHHN-.``````````
// ````````````.`.````.``.```.`.`....-dXUXuzuXHWHMMHHBWHMMMSZuzuuzXXzuuXHHMHMHkHHHHHHHWHHSuXkHWSuuuuX
// (#XKzzzzzuzuWHHkWHHp
// ``.````````````````````````.````````.....-((-(NSXuzzXHW@D:~`(/1-
// .kXuzuuzXSuuzXXkHWMHHHHHHHHMWuuuQXUXWuuuXuXH
// MXWzuzzzzzuXHHbHNMMMt`.```````````````````````````.`.` ..-J7"!``
// XKuzzuXHHM9;/<-.J-u!JXXuuzuXWuuuuXHHH#WMNHmkkkuXXkWUXXWXXuuuXqHH
// XWzzzzuzzwXHHHH#"````<.````````````````````.``.`...-c"7``` ` `
// `(BzuuuXmHH8<!(- ?_!`jWUuzuuuWuuuzXWHNH> ..7WHHqHmQkWWXXuuuuuXWqHH
// SwuzzzXuwXHNHY`` `` <,`.`````````````` `` ..J7=``` ` ` ``
// ````.#zuzXXHHH$~`` ```(_(HSuuuzuXSuzuuXHHWCi(` ._ ?WggHHHHWkkkkWHHHHMH
// zzzuzuzwWHMY!` ` ` `(&.```````````` ..J7^ `` ` ` ` ` `. .HXuuXWHW#!` `
// ```` (WUuzzuXXSzuuudHHXY$. : (..``.THHkqkHHHgHHMHkkk zzzzzzXHWK`` ` `` ` ` `
// TJ.``````..J7=```` ` ` ` ` `` ` `.8zuXXHHW=` ``
// ..(XSuuuuuXWuuuuXHWH5~~` .`_?_,-``.TMMMMMMHkkqqHHH zzuuzdHHkN ` ` ` `` `
// ``(Wm,.(J7!``` ` ``` `` `` ` ` ``` .SzuXWHHY ``
// .._~<~~(dSuuuzzXHuuuuXHWHD::?C._.( -`(!_1 ,WHqHHHmqHHHHN zuzXXHHkHM;` ` ` `
// `` ` .;jY= ` .``_`` ` ` ` ` `` ` `.dXuXWm@^
// .._~_.~~~~~(d0uuzuuXHUuuuXHWH5:::::::_.<&._4r?_.;WMMM@MMY"<!` zzXHHHHMHMb``
// `` ` `` `` .J! ` ..`_~ ` ` ` `` ` ` ``.JXXXHY!
// .__.....~.~~~-d0wuzuXXHSuuuXWWH$::::;:::;:+- ~`(.i +HqHHkkHL..`. XWHHHMMHMHM;
// ` ` ` ` ._`` ...(:.=_` ` ` ` ` ````
// .-dVT7^``````......~~~~~_jWuuuuuXHSuzuXHHH3<;:::::;;j<+z ``` -dHNkkMqkkN..``
// HHHMMHHHHNMN.`` ` ` `!`z(. ~..~ ! . ` `` ` ` `
// ..gHr``````````........~~~~_jWuuuuuXkSuuuXHWHC:;::;;:::+v>:((J<!(WHHMkkHNqkM;`..
// HMMkkHHHHM9?b `` ` ` `` .``. ` ` ` ` ``` 4HkkkH,
// ``````.`......~~~~_+KuuuzuXHSuuuXHHK<(::::::<;<J+g9>::;< .4NkkqMHqH]..`
// MHkHHHMM$<<:?L` `` ` ` ` ``.` ` !`` ` ` ` ` `
// ?HbkkHx``````.`..`...~~~~_jKuuuuuXHSuuuqMHD<:<;:<++ddNMB3:;::;:<`
// `,HkkqH@HH].`` kkHHkHY``` (;?h`` ` ` `` ```` ` ` ` ` ` ` ` `
// ```.4XWbHx```..`......~~~~_gKuuuuXWH0uuuXHH3:;++1z<jgMB3<::::::::~`
// `jMkqkHMHHF.`. kHHHH=` . ` _<?L ` ` ` ` ` ` ` ` ` ` ` ` ` ` ?kwWHp
// .`.......~_~~(dKuuuuXWHUuuXWH9++z1<;+jWB3::::;;;::;:;_`` MNkqkqMNMF..` HHk@!.
// ` ` ` ~?L ` ` `` ` `` `` ` ` ` ` ` ` ` `
// -WuXHh..`.....~~~~(dWuuuXXkHUuuXHH9>:<:++YY<:;::::;:::::;:::+.``?HHkHHHM>`.`
| [
"literal.number.change",
"io.output.change"
] | 835,145 | 835,146 | u890465662 | cpp |
p03023 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n * 180 - 360) / n << "\n";
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n * 180 - 360) << "\n";
return 0;
} | [
"expression.operation.binary.remove"
] | 835,151 | 835,152 | u882821419 | cpp |
p03023 | #include <cmath>
#include <iostream>
int main() {
int N;
std::cin >> N;
int ans = 180 * 2 * N - 360 * 2;
std::cout << ans << std::endl;
return 0;
}
| #include <cmath>
#include <iostream>
int main() {
int N;
std::cin >> N;
int ans = 180 * N - 360;
std::cout << ans << std::endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 835,153 | 835,154 | u936600428 | cpp |
p03023 | #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 2) / 180 << endl;
} | #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 2) * 180 << endl;
} | [
"expression.operator.arithmetic.change",
"io.output.change"
] | 835,159 | 835,160 | u203033720 | cpp |
p03023 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef complex<double> Point;
#define PI acos(-1.0)
#define EPS 1e-10
const ll INF = 1e16;
const ll MOD = 1e9 + 7;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, N) for (int i = 0; i < (N); i++)
#define ALL(s) (s).begin(), (s).end()
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) (EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))
#define fi first
#define se second
#define N_SIZE (1LL << 20)
#define NIL -1
ll n;
int main() {
cin >> n;
cout << (n - 3) * 180 << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef complex<double> Point;
#define PI acos(-1.0)
#define EPS 1e-10
const ll INF = 1e16;
const ll MOD = 1e9 + 7;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, N) for (int i = 0; i < (N); i++)
#define ALL(s) (s).begin(), (s).end()
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) (EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))
#define fi first
#define se second
#define N_SIZE (1LL << 20)
#define NIL -1
ll n;
int main() {
cin >> n;
cout << (n - 2) * 180 << endl;
} | [
"literal.number.change",
"io.output.change"
] | 835,169 | 835,170 | u344425917 | cpp |
p03023 | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N;
cin >> N;
cout << 180 * N - 2 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N;
cin >> N;
cout << 180 * (N - 2) << endl;
return 0;
}
| [] | 835,178 | 835,179 | u500092662 | cpp |
p03023 | #include <iostream>
using namespace std;
int main() {
int a;
cin >> a;
cout << (180 * (a - 2) / a) * a << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int a;
cin >> a;
cout << 180 * (a - 2) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 835,180 | 835,181 | u092312410 | cpp |
p03023 | #include <iostream>
using namespace std;
int main() {
int a;
cin >> a;
cout << a * 60 << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int a;
cin >> a;
cout << 180 * (a - 2) << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"io.output.change"
] | 835,182 | 835,181 | u092312410 | cpp |
p03022 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define PP pair<int, pair<int, int>>
const int MAX = 510000;
const int MOD = 998244353;
const int INV2 = (MOD + 1) / 2;
int modpow(int a, int n, int mod) {
int res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
template <typename T> void fwt(vector<T> &f) {
int n = f.size();
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
T x = f[j], y = f[j | i];
f[j] = (x + y) % MOD, f[j | i] = (x + MOD - y) % MOD;
}
}
}
}
template <typename T> void ifwt(vector<T> &f) {
int n = f.size();
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
T x = f[j], y = f[j | i];
f[j] = (x + y) % MOD * INV2 % MOD,
f[j | i] = (x + MOD - y) % MOD * INV2 % MOD;
}
}
}
}
signed main() {
int n;
cin >> n;
vector<int> a(1ll << n), b(1ll << n, 1), c(1ll << n, 0);
for (int i = 0; i < (1ll << n); i++)
cin >> a[i];
c[0] = 1;
int al = 0;
for (int i = 0; i < (1ll << n); i++)
al = (al + a[i]) % MOD;
al = modpow(al, MOD - 2, MOD);
for (int i = 0; i < (1ll << n); i++)
a[i] = (a[i] * al) % MOD;
fwt(a);
fwt(b);
fwt(c);
// for(int i=0;i<(1ll<<n);i++)cerr<<a[i]<<' '<<b[i]<<' '<<c[i]<<endl;
if (a[0] != 1) {
for (int i = 0; i < (1ll << n); i++)
b[i] = (b[i] * modpow((1 + MOD - a[i]) % MOD, MOD - 2, MOD)) % MOD;
for (int i = 0; i < (1ll << n); i++)
c[i] = (c[i] * modpow((1 + MOD - a[i]) % MOD, MOD - 2, MOD)) % MOD;
// for(int i=0;i<(1ll<<n);i++)cerr<<b[i]<<' '<<c[i]<<endl;
ifwt(b), ifwt(c);
int t = b[0] * modpow(c[0], MOD - 2, MOD) % MOD;
for (int i = 0; i < (1ll << n); i++)
cout << (b[i] + MOD - c[i] * t % MOD) % MOD << endl;
} else {
c[0] = 0;
for (int i = 1; i < (1ll << n); i++) {
c[i] = (MOD -
(1ll << n) % MOD * modpow((1 + MOD - a[i]) % MOD, MOD - 2, MOD));
c[0] = (c[0] + MOD - c[i]) % MOD;
}
// for(int i=0;i<(1ll<<n);i++)cout<<c[i]<<endl;
ifwt(c);
for (int i = 0; i < (1ll << n); i++)
cout << c[i] << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define PP pair<int, pair<int, int>>
const int MAX = 510000;
const int MOD = 998244353;
const int INV2 = (MOD + 1) / 2;
int modpow(int a, int n, int mod) {
int res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
template <typename T> void fwt(vector<T> &f) {
int n = f.size();
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
T x = f[j], y = f[j | i];
f[j] = (x + y) % MOD, f[j | i] = (x + MOD - y) % MOD;
}
}
}
}
template <typename T> void ifwt(vector<T> &f) {
int n = f.size();
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
T x = f[j], y = f[j | i];
f[j] = (x + y) % MOD * INV2 % MOD,
f[j | i] = (x + MOD - y) % MOD * INV2 % MOD;
}
}
}
}
signed main() {
int n;
cin >> n;
vector<int> a(1ll << n), b(1ll << n, 1), c(1ll << n, 0);
for (int i = 0; i < (1ll << n); i++)
cin >> a[i];
c[0] = 1;
int al = 0;
for (int i = 0; i < (1ll << n); i++)
al = (al + a[i]) % MOD;
al = modpow(al, MOD - 2, MOD);
for (int i = 0; i < (1ll << n); i++)
a[i] = (a[i] * al) % MOD;
fwt(a);
fwt(b);
fwt(c);
// for(int i=0;i<(1ll<<n);i++)cerr<<a[i]<<' '<<b[i]<<' '<<c[i]<<endl;
if (a[0] != 1) {
for (int i = 0; i < (1ll << n); i++)
b[i] = (b[i] * modpow((1 + MOD - a[i]) % MOD, MOD - 2, MOD)) % MOD;
for (int i = 0; i < (1ll << n); i++)
c[i] = (c[i] * modpow((1 + MOD - a[i]) % MOD, MOD - 2, MOD)) % MOD;
// for(int i=0;i<(1ll<<n);i++)cerr<<b[i]<<' '<<c[i]<<endl;
ifwt(b), ifwt(c);
int t = b[0] * modpow(c[0], MOD - 2, MOD) % MOD;
for (int i = 0; i < (1ll << n); i++)
cout << (b[i] + MOD - c[i] * t % MOD) % MOD << endl;
} else {
c[0] = 0;
for (int i = 1; i < (1ll << n); i++) {
c[i] = (MOD - (1ll << n) % MOD *
modpow((1 + MOD - a[i]) % MOD, MOD - 2, MOD) % MOD);
c[0] = (c[0] + MOD - c[i]) % MOD;
}
// for(int i=0;i<(1ll<<n);i++)cout<<c[i]<<endl;
ifwt(c);
for (int i = 0; i < (1ll << n); i++)
cout << c[i] << endl;
}
}
| [
"assignment.change"
] | 835,197 | 835,198 | u651317892 | cpp |
p03023 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << 180 * n - 2;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int d;
cout << 180 * (n - 2);
return 0;
}
| [
"variable_declaration.add"
] | 835,207 | 835,208 | u848862823 | cpp |
p03023 | #include <iostream>
#include <math.h>
#include <string>
using namespace std;
int main() {
int n;
int x = n - 2;
cout << 360 * x;
} | #include <iostream>
#include <math.h>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
int x = n - 2;
cout << 180 * x;
} | [
"literal.number.change",
"io.output.change"
] | 835,211 | 835,212 | u083006500 | cpp |
p03023 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 1) * 180 << endl;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 2) * 180 << endl;
}
| [
"literal.number.change",
"io.output.change"
] | 835,215 | 835,216 | u312172322 | cpp |
p03023 | #include <iostream>
int main() {
using namespace std;
int N;
cin >> N;
cout << 60 * N << endl;
return 0;
} | #include <iostream>
int main() {
using namespace std;
int N;
cin >> N;
cout << 180 * (N - 2) << endl;
return 0;
} | [
"literal.number.change",
"io.output.change"
] | 835,228 | 835,229 | u364278719 | cpp |
p03023 | #include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
cout << N * 60 << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 2) * 180 << endl;
return 0;
} | [
"literal.number.change",
"io.output.change"
] | 835,230 | 835,231 | u652609504 | cpp |
p03023 | #include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
cout << N * 180 << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 2) * 180 << endl;
return 0;
} | [] | 835,232 | 835,231 | u652609504 | cpp |
p03023 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << N - 2 * 180;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 2) * 180;
}
| [] | 835,235 | 835,236 | u208073493 | cpp |
p03023 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << (180 * (N - 2)) / N << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << 180 * (N - 2) << endl;
} | [
"expression.operation.binary.remove"
] | 835,242 | 835,243 | u926575240 | cpp |
p03023 | #include <stdio.h>
int main(void) {
int n;
scanf("%d", &n);
n = (n - 2) * 180;
printf("%d¥n", n);
return 0;
}
| #include <stdio.h>
int main(void) {
int n;
scanf("%d", &n);
n = (n - 2) * 180;
printf("%d", n);
return 0;
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 835,246 | 835,247 | u180133008 | cpp |
p03023 | #include <stdio.h>
int main(void) {
int n;
scanf("%d", &n);
n = (n - 2) * 180;
printf("%d¥n", n);
return 0;
} | #include <stdio.h>
int main(void) {
int n;
scanf("%d", &n);
n = (n - 2) * 180;
printf("%d", n);
return 0;
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 835,248 | 835,247 | u180133008 | cpp |
p03023 | #include <iostream>
using namespace std;
int main() {
int n;
scanf("%d", &n);
cout << ((180 * (n - 2)) / n) << endl;
} | #include <iostream>
using namespace std;
int main() {
int n;
scanf("%d", &n);
cout << ((180 * (n - 2))) << endl;
} | [
"expression.operation.binary.remove"
] | 835,251 | 835,252 | u783217740 | cpp |
p03023 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#define rep(i, n) for (ll i = 0; i < (ll)n; i++)
#define swap(a, b) \
a ^= b; \
b ^= a; \
a ^= b;
//#define for(i,a,b) for (ll i=(a);i<(ll)b; i++)
#define print(x) std::cout << x << std::endl;
using namespace std;
typedef long long ll;
template <class T, class U>
std::string replace(std::string s, const T &target, const U &replacement,
bool replace_first = 0, bool replace_empty = 0);
bool isContain(int value, int under, int top);
vector<int> range(int x);
int get_ab(string str) {
bool isA = false;
int res = 0;
if (str[0] == 'A')
isA = true;
for (int i = 1; i < str.length(); i++) {
if (isA && str[i] == 'B') {
res++;
isA = false;
} else if (str[i] == 'A')
isA = true;
else
isA = false;
}
return res;
}
vector<bool> isVisited;
vector<int> Accu;
vector<vector<int>> Datas;
int N;
void DEF(int pos, int sum) {
bool all_visited = true;
rep(i, N) if (isVisited[i] == false) {
all_visited = false;
break;
}
Accu[pos] = sum;
rep(i, N) {
if (isVisited[i] == true)
continue; //すでに訪れている
if (Datas[pos][i] == -1)
continue; //繋がっていない
isVisited[i] = true;
DEF(i, sum + Datas[pos][i]);
}
}
ll gcd(ll A, ll B) {
int r = A % B;
while (r != 0) {
A = B;
B = r;
r = A % B;
}
return B;
}
vector<bool> to_binary(int x) {
vector<bool> res;
while (x != 0) {
res.push_back(x % 2);
x /= 2;
}
return res;
}
vector<bool> pad(vector<bool> inp, int num) {
while (inp.size() != num) {
inp.push_back(false);
}
return inp;
}
vector<bool> proc(int x, int n) {
vector<bool> res = pad(to_binary(x), n);
reverse(res.begin(), res.end());
return res;
}
int main(void) {
// Program Start
int N;
cin >> N;
cout << (N - 1) * 180 << endl;
ProgramEndPointLabel:;
// Program End
system("pause");
return 0;
}
vector<int> range(int y) {
vector<int> result(y);
for (int i = 0; i < y; i++)
result[i] = i;
return result;
}
bool isContain(int value, int under, int top) {
if (under <= value && value <= top)
return true;
return false;
}
template <class T, class U>
std::string replace(std::string s, const T &target, const U &replacement,
bool replace_first, bool replace_empty) {
using S = std::string;
using C = std::string::value_type;
using N = std::string::size_type;
struct {
auto len(const S &s) { return s.size(); }
auto len(const C *p) { return std::char_traits<C>::length(p); }
auto len(const C c) { return 1; }
auto sub(S *s, const S &t, N pos, N len) { s->replace(pos, len, t); }
auto sub(S *s, const C *t, N pos, N len) { s->replace(pos, len, t); }
auto sub(S *s, const C t, N pos, N len) { s->replace(pos, len, 1, t); }
auto ins(S *s, const S &t, N pos) { s->insert(pos, t); }
auto ins(S *s, const C *t, N pos) { s->insert(pos, t); }
auto ins(S *s, const C t, N pos) { s->insert(pos, 1, t); }
} util;
N target_length = util.len(target);
N replacement_length = util.len(replacement);
if (target_length == 0) {
if (!replace_empty || replacement_length == 0)
return s;
N n = s.size() + replacement_length * (1 + s.size());
s.reserve(!replace_first ? n : s.size() + replacement_length);
for (N i = 0; i < n; i += 1 + replacement_length) {
util.ins(&s, replacement, i);
if (replace_first)
break;
}
return s;
}
N pos = 0;
while ((pos = s.find(target, pos)) != std::string::npos) {
util.sub(&s, replacement, pos, target_length);
if (replace_first)
return s;
pos += replacement_length;
}
return s;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#define rep(i, n) for (ll i = 0; i < (ll)n; i++)
#define swap(a, b) \
a ^= b; \
b ^= a; \
a ^= b;
//#define for(i,a,b) for (ll i=(a);i<(ll)b; i++)
#define print(x) std::cout << x << std::endl;
using namespace std;
typedef long long ll;
template <class T, class U>
std::string replace(std::string s, const T &target, const U &replacement,
bool replace_first = 0, bool replace_empty = 0);
bool isContain(int value, int under, int top);
vector<int> range(int x);
int get_ab(string str) {
bool isA = false;
int res = 0;
if (str[0] == 'A')
isA = true;
for (int i = 1; i < str.length(); i++) {
if (isA && str[i] == 'B') {
res++;
isA = false;
} else if (str[i] == 'A')
isA = true;
else
isA = false;
}
return res;
}
vector<bool> isVisited;
vector<int> Accu;
vector<vector<int>> Datas;
int N;
void DEF(int pos, int sum) {
bool all_visited = true;
rep(i, N) if (isVisited[i] == false) {
all_visited = false;
break;
}
Accu[pos] = sum;
rep(i, N) {
if (isVisited[i] == true)
continue; //すでに訪れている
if (Datas[pos][i] == -1)
continue; //繋がっていない
isVisited[i] = true;
DEF(i, sum + Datas[pos][i]);
}
}
ll gcd(ll A, ll B) {
int r = A % B;
while (r != 0) {
A = B;
B = r;
r = A % B;
}
return B;
}
vector<bool> to_binary(int x) {
vector<bool> res;
while (x != 0) {
res.push_back(x % 2);
x /= 2;
}
return res;
}
vector<bool> pad(vector<bool> inp, int num) {
while (inp.size() != num) {
inp.push_back(false);
}
return inp;
}
vector<bool> proc(int x, int n) {
vector<bool> res = pad(to_binary(x), n);
reverse(res.begin(), res.end());
return res;
}
int main(void) {
// Program Start
int N;
cin >> N;
cout << (N - 2) * 180 << endl;
ProgramEndPointLabel:;
// Program End
system("pause");
return 0;
}
vector<int> range(int y) {
vector<int> result(y);
for (int i = 0; i < y; i++)
result[i] = i;
return result;
}
bool isContain(int value, int under, int top) {
if (under <= value && value <= top)
return true;
return false;
}
template <class T, class U>
std::string replace(std::string s, const T &target, const U &replacement,
bool replace_first, bool replace_empty) {
using S = std::string;
using C = std::string::value_type;
using N = std::string::size_type;
struct {
auto len(const S &s) { return s.size(); }
auto len(const C *p) { return std::char_traits<C>::length(p); }
auto len(const C c) { return 1; }
auto sub(S *s, const S &t, N pos, N len) { s->replace(pos, len, t); }
auto sub(S *s, const C *t, N pos, N len) { s->replace(pos, len, t); }
auto sub(S *s, const C t, N pos, N len) { s->replace(pos, len, 1, t); }
auto ins(S *s, const S &t, N pos) { s->insert(pos, t); }
auto ins(S *s, const C *t, N pos) { s->insert(pos, t); }
auto ins(S *s, const C t, N pos) { s->insert(pos, 1, t); }
} util;
N target_length = util.len(target);
N replacement_length = util.len(replacement);
if (target_length == 0) {
if (!replace_empty || replacement_length == 0)
return s;
N n = s.size() + replacement_length * (1 + s.size());
s.reserve(!replace_first ? n : s.size() + replacement_length);
for (N i = 0; i < n; i += 1 + replacement_length) {
util.ins(&s, replacement, i);
if (replace_first)
break;
}
return s;
}
N pos = 0;
while ((pos = s.find(target, pos)) != std::string::npos) {
util.sub(&s, replacement, pos, target_length);
if (replace_first)
return s;
pos += replacement_length;
}
return s;
}
| [
"literal.number.change",
"io.output.change"
] | 835,259 | 835,260 | u040251933 | cpp |
p03023 | #include <iostream>
#include <string>
using namespace std;
int main() {
int N;
cin >> N;
cout << 180 + (N - 3) * 90 << endl;
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int N;
cin >> N;
cout << 180 * (N - 2) << endl;
return 0;
} | [
"expression.operator.arithmetic.change",
"io.output.change",
"literal.number.change",
"expression.operation.binary.remove"
] | 835,262 | 835,263 | u684863590 | cpp |
p03023 | #include <iostream>
#include <string>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 1) * 90 << endl;
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int N;
cin >> N;
cout << 180 * (N - 2) << endl;
return 0;
} | [
"literal.number.change",
"io.output.change",
"expression.operation.binary.remove"
] | 835,264 | 835,263 | u684863590 | cpp |
p03023 | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main(void) {
int N;
cin >> N;
cout << (180 + N * 180);
return 0;
} | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main(void) {
int N;
cin >> N;
cout << (180 + (N - 3) * 180);
return 0;
} | [] | 835,267 | 835,266 | u894950682 | cpp |
p03023 | #include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 1) * 90 << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 2) * 180 << endl;
return 0;
}
| [
"literal.number.change",
"io.output.change"
] | 835,270 | 835,271 | u953268227 | cpp |
p03023 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
const double PI = acos(-1);
const double EPS = 1e-15;
long long INF = (long long)1E17;
#define i_7 (long long)(1E9 + 7)
long mod(long a) {
long long c = a % i_7;
if (c >= 0)
return c;
return c + i_7;
}
using namespace std;
bool prime(int n) {
if (n == 1) {
return false;
} else if (n == 2) {
return true;
} else {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
}
long long gcd(long long a, long long b) {
if (a < b) {
swap(a, b);
}
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
long long lcm(long long x, long long y) { return (x / gcd(x, y)) * y; }
class UnionFind {
public:
//各頂点の親の番号を格納する。その頂点自身が親だった場合は-(その集合のサイズ)を入れる。
vector<int> Parent;
//クラスを作るときは、Parentの値を全て-1にする。
//以下のようにすると全てバラバラの頂点として解釈できる。
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //先祖をrootで取っておきたい。
}
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらAとBをひっくり返す。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
int main() {
int n;
int ans;
ans = 180 * n - 360;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
const double PI = acos(-1);
const double EPS = 1e-15;
long long INF = (long long)1E17;
#define i_7 (long long)(1E9 + 7)
long mod(long a) {
long long c = a % i_7;
if (c >= 0)
return c;
return c + i_7;
}
using namespace std;
bool prime(int n) {
if (n == 1) {
return false;
} else if (n == 2) {
return true;
} else {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
}
long long gcd(long long a, long long b) {
if (a < b) {
swap(a, b);
}
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
long long lcm(long long x, long long y) { return (x / gcd(x, y)) * y; }
class UnionFind {
public:
//各頂点の親の番号を格納する。その頂点自身が親だった場合は-(その集合のサイズ)を入れる。
vector<int> Parent;
//クラスを作るときは、Parentの値を全て-1にする。
//以下のようにすると全てバラバラの頂点として解釈できる。
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //先祖をrootで取っておきたい。
}
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらAとBをひっくり返す。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
int main() {
int n;
cin >> n;
int ans;
ans = 180 * n - 360;
cout << ans << endl;
return 0;
}
| [] | 835,274 | 835,275 | u222293734 | cpp |
p03023 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 3) * 180 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 2) * 180 << endl;
} | [
"literal.number.change",
"io.output.change"
] | 835,278 | 835,279 | u200855589 | cpp |
p03023 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define REP(i, s) for (int i = 0; i < s; ++i)
#define ALL(v) (v.begin(), v.end())
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
#define EACH(i, s) \
for (__typeof__((s).begin()) i = (s).begin(); i != (s).end(); ++i)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T1, class T2> ostream &operator<<(ostream &s, pair<T1, T2> P) {
return s << '<' << P.first << ", " << P.second << '>';
}
template <class T> ostream &operator<<(ostream &s, vector<T> P) {
for (int i = 0; i < P.size(); ++i) {
if (i > 0) {
s << " ";
}
s << P[i];
}
return s;
}
template <class T> ostream &operator<<(ostream &s, vector<vector<T>> P) {
for (int i = 0; i < P.size(); ++i) {
s << endl << P[i];
}
return s << endl;
}
template <class T> ostream &operator<<(ostream &s, set<T> P) {
EACH(it, P) { s << "<" << *it << "> "; }
return s << endl;
}
template <class T1, class T2> ostream &operator<<(ostream &s, map<T1, T2> P) {
EACH(it, P) { s << "<" << it->first << "->" << it->second << "> "; }
return s << endl;
}
typedef long long ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
int main() {
int n;
cout << 180 * (n - 2) << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define REP(i, s) for (int i = 0; i < s; ++i)
#define ALL(v) (v.begin(), v.end())
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
#define EACH(i, s) \
for (__typeof__((s).begin()) i = (s).begin(); i != (s).end(); ++i)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T1, class T2> ostream &operator<<(ostream &s, pair<T1, T2> P) {
return s << '<' << P.first << ", " << P.second << '>';
}
template <class T> ostream &operator<<(ostream &s, vector<T> P) {
for (int i = 0; i < P.size(); ++i) {
if (i > 0) {
s << " ";
}
s << P[i];
}
return s;
}
template <class T> ostream &operator<<(ostream &s, vector<vector<T>> P) {
for (int i = 0; i < P.size(); ++i) {
s << endl << P[i];
}
return s << endl;
}
template <class T> ostream &operator<<(ostream &s, set<T> P) {
EACH(it, P) { s << "<" << *it << "> "; }
return s << endl;
}
template <class T1, class T2> ostream &operator<<(ostream &s, map<T1, T2> P) {
EACH(it, P) { s << "<" << it->first << "->" << it->second << "> "; }
return s << endl;
}
typedef long long ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
int main() {
int n;
cin >> n;
cout << 180 * (n - 2) << endl;
return 0;
} | [] | 835,284 | 835,285 | u074445770 | cpp |
p03023 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define endl '\n'
#define eb emplace_back
#define fst first
#define scd second
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
constexpr int MOD = 1000000007;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vector<int>> vii;
typedef vector<ll> vl;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
// value
void solve() {
int N;
cin >> N;
cout << 180 * N - 2 << endl;
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
} | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define endl '\n'
#define eb emplace_back
#define fst first
#define scd second
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
constexpr int MOD = 1000000007;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vector<int>> vii;
typedef vector<ll> vl;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
// value
void solve() {
int N;
cin >> N;
cout << 180 * (N - 2) << endl;
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| [] | 835,286 | 835,287 | u381714561 | cpp |
p03023 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define str string
#define sec .second
ll MOD = 1000000007, INFL = 1ll << 60, INF = 1 << 30;
ll A[100][100] = {};
ll X[1000000] = {};
ll rui[100002] = {}, ruin[100002] = {};
int dy[] = {0, 0, 1, -1}, dx[] = {1, -1, 0, 0};
vector<ll> v;
ll a = 0, b = 0, c = 0, n = 0, sum = 0, max = INF, mi = -1;
pair<str, ll> S[1000];
bool an = false, bn = false;
int findDigits(int n) {
int i = 0;
while (n > 0) {
X[i] = n % 10;
n /= 10;
i++;
}
return i;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// Code Line
cin >> n;
cout << n - 2 * 180 << endl;
// Code Line
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define str string
#define sec .second
ll MOD = 1000000007, INFL = 1ll << 60, INF = 1 << 30;
ll A[100][100] = {};
ll X[1000000] = {};
ll rui[100002] = {}, ruin[100002] = {};
int dy[] = {0, 0, 1, -1}, dx[] = {1, -1, 0, 0};
vector<ll> v;
ll a = 0, b = 0, c = 0, n = 0, sum = 0, max = INF, mi = -1;
pair<str, ll> S[1000];
bool an = false, bn = false;
int findDigits(int n) {
int i = 0;
while (n > 0) {
X[i] = n % 10;
n /= 10;
i++;
}
return i;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// Code Line
cin >> n;
cout << (n - 2) * 180 << endl;
// Code Line
return 0;
}
| [] | 835,292 | 835,293 | u109792330 | cpp |
p03023 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n - 1) * 180 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n - 2) * 180 << endl;
}
| [
"literal.number.change",
"io.output.change"
] | 835,304 | 835,305 | u637284188 | cpp |
p03023 | #include <cstdio>
#include <iostream>
#include <sstream>
#include <deque>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <chrono>
#include <random>
using namespace std;
using i64 = int_fast64_t;
using ui64 = uint_fast64_t;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<i64>;
using vvl = vector<vl>;
using vd = vector<double>;
using vvd = vector<vd>;
using vb = vector<bool>;
using vvb = vector<vb>;
using pii = pair<int, int>;
using pll = pair<i64, i64>;
//////////////////////////////////////////////////
int main() {
int n;
cin >> n;
cout << (n - 2) * 60 + 120 << endl;
return 0;
}
| #include <cstdio>
#include <iostream>
#include <sstream>
#include <deque>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <chrono>
#include <random>
using namespace std;
using i64 = int_fast64_t;
using ui64 = uint_fast64_t;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<i64>;
using vvl = vector<vl>;
using vd = vector<double>;
using vvd = vector<vd>;
using vb = vector<bool>;
using vvb = vector<vb>;
using pii = pair<int, int>;
using pll = pair<i64, i64>;
//////////////////////////////////////////////////
int main() {
int n;
cin >> n;
cout << (n - 2) * 180 << endl;
return 0;
}
| [
"literal.number.change",
"io.output.change",
"expression.operation.binary.remove"
] | 835,312 | 835,313 | u799443198 | cpp |
p03023 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int H;
cin >> H;
int ans = 180 * (3 - 2);
cout << ans << endl;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int H;
cin >> H;
int ans = 180 * (H - 2);
cout << ans << endl;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change"
] | 835,316 | 835,317 | u430797067 | cpp |
p03023 | #include <bits/stdc++.h>
#define mod 1000000007
#define fr first
#define se second
#define ll long long
#define PI 3.1415926535
#define pb push_back
#define mpr make_pair
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Senky_Bansal ios_base::sync_with_stdio(false);
#define IIIT_ALLAHABAD \
cin.tie(NULL); \
cout.tie(NULL);
using namespace std;
signed main() {
Senky_Bansal IIIT_ALLAHABAD
ll n;
cin >> n;
cout << 180 * (n - 1);
}
| #include <bits/stdc++.h>
#define mod 1000000007
#define fr first
#define se second
#define ll long long
#define PI 3.1415926535
#define pb push_back
#define mpr make_pair
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Senky_Bansal ios_base::sync_with_stdio(false);
#define IIIT_ALLAHABAD \
cin.tie(NULL); \
cout.tie(NULL);
using namespace std;
signed main() {
Senky_Bansal IIIT_ALLAHABAD
ll n;
cin >> n;
cout << 180 * (n - 2);
}
| [
"literal.number.change",
"io.output.change"
] | 835,320 | 835,321 | u942813425 | cpp |
p03023 | #include <bits/stdc++.h>
using namespace std;
#define FAST ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
#define sz(a) ll((a).size())
#define pb emplace_back
#define mp make_pair
#define ff first
#define ss second
#define all(c) (c).begin(), (c).end()
#define tr(c, i) for (typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
typedef long long ll;
typedef long double ld;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
int main() {
FAST;
ll n;
cin >> n;
cout << 180 * (n - 1);
}
| #include <bits/stdc++.h>
using namespace std;
#define FAST ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
#define sz(a) ll((a).size())
#define pb emplace_back
#define mp make_pair
#define ff first
#define ss second
#define all(c) (c).begin(), (c).end()
#define tr(c, i) for (typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
typedef long long ll;
typedef long double ld;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
int main() {
FAST;
ll n;
cin >> n;
cout << 180 * (n - 2);
}
| [
"literal.number.change",
"io.output.change"
] | 835,323 | 835,324 | u670919462 | cpp |
p03023 | #include "bits/stdc++.h"
using namespace std;
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REP1(i, n) for (ll i = 1; i < n; i++)
#define REPR(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend())
#define ll long long
#define ALL(a) (a).begin(), (a).end()
#define pb(a) push_back(a)
int a, b;
string s;
int main() {
cin >> a >> b;
int ans = (a - 1) * 90;
cout << ans << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REP1(i, n) for (ll i = 1; i < n; i++)
#define REPR(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend())
#define ll long long
#define ALL(a) (a).begin(), (a).end()
#define pb(a) push_back(a)
int a, b;
string s;
int main() {
cin >> a;
int ans = (a - 2) * 180;
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.remove",
"literal.number.change",
"expression.operation.binary.change"
] | 835,325 | 835,326 | u837951457 | cpp |
p03023 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 1) * 180 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 2) * 180 << endl;
}
| [
"literal.number.change",
"io.output.change"
] | 835,331 | 835,332 | u096717230 | cpp |
p03023 | #include <iostream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n - 1) * 90;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n - 2) * 180;
} | [
"literal.number.change",
"io.output.change"
] | 835,333 | 835,334 | u659075447 | cpp |
p03023 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
const ll LINF = 1e18;
const int INF = 1e8;
using namespace std;
//マクロ定義
#define vvint(vec, n, m, l) \
vector<vector<int>> vec(n, vector<int>(m, l)); // lで初期化
#define vvll(vec, n, m, l) vector<vector<ll>> vec(n, vector<ll>(m, l));
#define vint vector<int>
#define pint pair<int, int>
#define rep(i, a) for (int i = 0; i < (a); i++)
#define all(x) (x).begin(), (x).end() ss
#define debug system("pause") //デバッグ用
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
cout << 180 << endl;
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
const ll LINF = 1e18;
const int INF = 1e8;
using namespace std;
//マクロ定義
#define vvint(vec, n, m, l) \
vector<vector<int>> vec(n, vector<int>(m, l)); // lで初期化
#define vvll(vec, n, m, l) vector<vector<ll>> vec(n, vector<ll>(m, l));
#define vint vector<int>
#define pint pair<int, int>
#define rep(i, a) for (int i = 0; i < (a); i++)
#define all(x) (x).begin(), (x).end() ss
#define debug system("pause") //デバッグ用
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
cout << (n - 2) * 180 << endl;
} | [
"expression.operation.binary.add"
] | 835,342 | 835,343 | u776194115 | cpp |
p03023 | #include <iostream>
#include <string>
using namespace std;
int main(void) {
int n;
cin >> n;
n = (n - 3) * 180;
cout << n;
}
| #include <iostream>
#include <string>
using namespace std;
int main(void) {
int n;
cin >> n;
n = (n - 2) * 180;
cout << n;
}
| [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 835,344 | 835,345 | u664272778 | cpp |
p03023 | #include <bits/stdc++.h>
#define vsort(v) sort(v.begin(), v.end())
typedef long long ll;
using namespace std;
int main() {
int N;
cin >> N;
cout << 180 * (N - 2) / N << endl;
}
| #include <bits/stdc++.h>
#define vsort(v) sort(v.begin(), v.end())
typedef long long ll;
using namespace std;
int main() {
int N;
cin >> N;
cout << 180 * (N - 2) << endl;
}
| [
"expression.operation.binary.remove"
] | 835,348 | 835,349 | u695857481 | cpp |
p03023 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cout << (N - 2) * 180 << endl;
};
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 2) * 180 << endl;
};
| [] | 835,357 | 835,358 | u987594251 | cpp |
p03023 | #include <stdio.h>
int main(void) {
int n, m;
char str[1000];
int i, j;
int ans = 0;
scanf("%d", &n);
if (n == 3) {
ans = 180;
} else {
ans = 180 * (n - 3);
}
printf("%d\n", ans);
return 0;
} | #include <stdio.h>
int main(void) {
int n, m;
char str[1000];
int i, j;
int ans = 0;
scanf("%d", &n);
if (n == 3) {
ans = 180;
} else {
ans = 180 + 180 * (n - 3);
}
printf("%d\n", ans);
return 0;
} | [
"assignment.change"
] | 835,359 | 835,360 | u015875086 | cpp |
p03023 | #include <bits/stdc++.h>
using namespace std;
// 変数ダンプ先。coutかcerr
#define DUMPOUT cerr
// 提出時はコメントアウト
#define DEBUG_
// #define int long long // intで書いたけど心配なときにlong longに変換する
struct Fast {
Fast() {
std::cin.tie(0);
ios::sync_with_stdio(false);
}
} fast;
/* cpp template {{{ */
/* short */
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
#define ALL(v) begin(v), end(v)
#define RALL(v) rbegin(v), rend(v)
#define X real()
#define Y imag()
/* REPmacro */
#define REPS(i, a, n) for (ll i = (a); i < (ll)(n); ++i)
#define REP(i, n) REPS(i, 0, n)
#define RREP(i, n) REPS(i, 1, n + 1)
#define DEPS(i, a, n) for (ll i = (a); i >= (ll)(n); --i)
#define DEP(i, n) DEPS(i, n, 0)
#define EACH(i, n) for (auto &&i : n)
/* debug */
#define debug(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n';
/* alias */
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using pii = pair<int, int>;
using D = double;
using P = complex<D>;
using vs = vector<string>;
template <typename T> using PQ = priority_queue<T>;
template <typename T> using minPQ = priority_queue<T, vector<T>, greater<T>>;
/* const */
const int INF = 1001001001;
const ll LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7;
const D EPS = 1e-9;
const int dx[] = {0, 1, 0, -1, 1, -1, 1, -1},
dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
/* func */
inline bool inside(int y, int x, int H, int W) {
return y >= 0 && x >= 0 && y < H && x < W;
}
inline int in() {
int x;
cin >> x;
return x;
}
inline ll IN() {
ll x;
cin >> x;
return x;
}
inline vs split(const string &t, char c) {
vs v;
stringstream s(t);
string b;
while (getline(s, b, c))
v.eb(b);
return v;
}
template <typename T> inline bool chmin(T &a, const T &b) {
if (a > b)
a = b;
return a > b;
}
template <typename T> inline bool chmax(T &a, const T &b) {
if (a < b)
a = b;
return a < b;
}
template <typename T, typename S> inline void print(const pair<T, S> &p) {
cout << p.first << " " << p.second << endl;
}
template <typename T> inline void print(const T &x) { cout << x << '\n'; }
template <typename T, typename S>
inline void print(const vector<pair<T, S>> &v) {
for (auto &&p : v)
print(p);
}
template <typename T> inline void print(const vector<T> &v, string s = " ") {
REP(i, v.size()) cout << v[i] << (i != (ll)v.size() - 1 ? s : "\n");
}
// clang-format on
/* }}} */
#ifdef DEBUG_
#define DEB
#else
// DEB と打つとデバッグ時以外はコメントアウトになる
#define DEB / ## /
#endif
// 変数ダンプ用マクロ。デバッグ時以外は消滅する
// 引数はいくつでもどんな型でも可（ストリーム出力演算子があればOK）
#define dump(...) \
DEB DUMPOUT << " "; \
DUMPOUT << #__VA_ARGS__ << " :[" << __LINE__ << ":" << __FUNCTION__ << "]" \
<< endl; \
DUMPOUT << " "; \
dump_func(__VA_ARGS__)
// デバッグ用変数ダンプ関数
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) == 0) {
DUMPOUT << " ";
} else {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
// vector出力
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
signed main() {
int N;
cin >> N;
print(180 * (N - 1));
return 0;
}
// https://github.com/kurokoji/.cpp-Template/wiki テンプレートについて
// http://www.creativ.xyz/dump-cpp-652 dump()について
// https://gist.github.com/rigibun/7905920 色々 | #include <bits/stdc++.h>
using namespace std;
// 変数ダンプ先。coutかcerr
#define DUMPOUT cerr
// 提出時はコメントアウト
#define DEBUG_
// #define int long long // intで書いたけど心配なときにlong longに変換する
struct Fast {
Fast() {
std::cin.tie(0);
ios::sync_with_stdio(false);
}
} fast;
/* cpp template {{{ */
/* short */
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
#define ALL(v) begin(v), end(v)
#define RALL(v) rbegin(v), rend(v)
#define X real()
#define Y imag()
/* REPmacro */
#define REPS(i, a, n) for (ll i = (a); i < (ll)(n); ++i)
#define REP(i, n) REPS(i, 0, n)
#define RREP(i, n) REPS(i, 1, n + 1)
#define DEPS(i, a, n) for (ll i = (a); i >= (ll)(n); --i)
#define DEP(i, n) DEPS(i, n, 0)
#define EACH(i, n) for (auto &&i : n)
/* debug */
#define debug(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n';
/* alias */
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using pii = pair<int, int>;
using D = double;
using P = complex<D>;
using vs = vector<string>;
template <typename T> using PQ = priority_queue<T>;
template <typename T> using minPQ = priority_queue<T, vector<T>, greater<T>>;
/* const */
const int INF = 1001001001;
const ll LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7;
const D EPS = 1e-9;
const int dx[] = {0, 1, 0, -1, 1, -1, 1, -1},
dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
/* func */
inline bool inside(int y, int x, int H, int W) {
return y >= 0 && x >= 0 && y < H && x < W;
}
inline int in() {
int x;
cin >> x;
return x;
}
inline ll IN() {
ll x;
cin >> x;
return x;
}
inline vs split(const string &t, char c) {
vs v;
stringstream s(t);
string b;
while (getline(s, b, c))
v.eb(b);
return v;
}
template <typename T> inline bool chmin(T &a, const T &b) {
if (a > b)
a = b;
return a > b;
}
template <typename T> inline bool chmax(T &a, const T &b) {
if (a < b)
a = b;
return a < b;
}
template <typename T, typename S> inline void print(const pair<T, S> &p) {
cout << p.first << " " << p.second << endl;
}
template <typename T> inline void print(const T &x) { cout << x << '\n'; }
template <typename T, typename S>
inline void print(const vector<pair<T, S>> &v) {
for (auto &&p : v)
print(p);
}
template <typename T> inline void print(const vector<T> &v, string s = " ") {
REP(i, v.size()) cout << v[i] << (i != (ll)v.size() - 1 ? s : "\n");
}
// clang-format on
/* }}} */
#ifdef DEBUG_
#define DEB
#else
// DEB と打つとデバッグ時以外はコメントアウトになる
#define DEB / ## /
#endif
// 変数ダンプ用マクロ。デバッグ時以外は消滅する
// 引数はいくつでもどんな型でも可（ストリーム出力演算子があればOK）
#define dump(...) \
DEB DUMPOUT << " "; \
DUMPOUT << #__VA_ARGS__ << " :[" << __LINE__ << ":" << __FUNCTION__ << "]" \
<< endl; \
DUMPOUT << " "; \
dump_func(__VA_ARGS__)
// デバッグ用変数ダンプ関数
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) == 0) {
DUMPOUT << " ";
} else {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
// vector出力
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
signed main() {
int N;
cin >> N;
print(180 * (N - 2));
return 0;
}
// https://github.com/kurokoji/.cpp-Template/wiki テンプレートについて
// http://www.creativ.xyz/dump-cpp-652 dump()について
// https://gist.github.com/rigibun/7905920 色々 | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 835,361 | 835,362 | u545411641 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int lose = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'x')
lose++;
}
if (lose >= 7)
cout << "NO" << endl;
else
cout << "YES" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int lose = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'x')
lose++;
}
if (lose > 7)
cout << "NO" << endl;
else
cout << "YES" << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 835,406 | 835,410 | u528258842 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const int INF = 1e9;
const int MOD = 1e9 + 7;
int main() {
string s;
cin >> s;
int k = s.size();
int cnt = 0;
rep(i, k) {
if (s.at(i) == 'o')
cnt++;
}
if (8 - cnt >= 15 - k)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const int INF = 1e9;
const int MOD = 1e9 + 7;
int main() {
string s;
cin >> s;
int k = s.size();
int cnt = 0;
rep(i, k) {
if (s.at(i) == 'o')
cnt++;
}
if (8 - cnt <= 15 - k)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 835,412 | 835,414 | u166218280 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define intll int long long
const intll INF = 1e9;
const int MOD = 1e9 + 7;
int main() {
string s;
cin >> s;
int now = 0;
rep(i, s.size()) {
if (s.at(i) == 'x')
now++;
}
if (now <= 7)
cout << "Yes";
else
cout << "No";
}
| #include <bits/stdc++.h>
using namespace std;
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define intll int long long
const intll INF = 1e9;
const int MOD = 1e9 + 7;
int main() {
string s;
cin >> s;
int now = 0;
rep(i, s.size()) {
if (s.at(i) == 'x')
now++;
}
if (now <= 7)
cout << "YES";
else
cout << "NO";
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,416 | 835,418 | u260907804 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int count = 0;
for (int i = 0; i < s.size(); i++) {
if (s.at(i) == 'o')
count++;
}
if (15 - s.size() + count >= 8)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int count = 0;
for (int i = 0; i < s.size(); i++) {
if (s.at(i) == 'o')
count++;
}
if (15 - s.size() + count >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,433 | 835,434 | u516876944 | cpp |
p03024 | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define pll pair<ll, ll>
#define pq priority_queue
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define ios ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define lb(c, x) distance(c.begin(), lower_bound(all(c), x))
#define ub(c, x) distance(c.begin(), upper_bound(all(c), x))
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const ll INF = 1e9 + 7;
int main() {
string s;
cin >> s;
ll n = s.length();
ll ans = 0;
rep(i, n) {
if (s[i] == 'o')
ans++;
}
if (ans >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define pll pair<ll, ll>
#define pq priority_queue
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define ios ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define lb(c, x) distance(c.begin(), lower_bound(all(c), x))
#define ub(c, x) distance(c.begin(), upper_bound(all(c), x))
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const ll INF = 1e9 + 7;
int main() {
string s;
cin >> s;
ll n = s.length();
ll ans = 0;
rep(i, n) {
if (s[i] == 'o')
ans++;
}
if (ans + 15 - n >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 835,435 | 835,437 | u882039496 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
//定数
const long long MOD1 = 1000000007;
const long long MOD2 = 998244353;
const long long INF = 1152921504606846976;
const long double PI = 3.1415926535897932;
//型名省略
#define ll long long
#define ull unsigned long long
#define ld long double
#define pll pair<long long, long long>
#define vl vector<long long>
#define vvl vector<vector<long long>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define umap unordered_map
#define Lqueue priority_queue<long long>
#define Squeue priority_queue<long long, vector<long long>, greater<long long>>
#define Fi first
#define Se second
//マクロ
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rbf(a, x) for (auto &a : x)
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define rep2(i, s, n) for (long long i = (s); i < (long long)(n); i++)
#define Maxe(x) *max_element((x).begin(), (x).end())
#define Mine(x) *min_element((x).begin(), (x).end())
#define Size(x) ((long long)(x).size())
//最大公約数
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
//最小公倍数
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
//累乗
template <typename Num> constexpr Num mypow(Num a, ll b) {
if (b == 0)
return 1;
if (a == 0)
return 0;
Num x = 1;
while (b > 0) {
if (b & 1)
x *= a;
a *= a;
b >>= 1;
}
return x;
}
// chmin,chmax
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// MODint
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
val += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr istream &operator>>(istream &is, Fp<MOD> &x) {
long long t;
is >> t;
x = t;
return (is);
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
using mint = Fp<MOD1>;
// start
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
ll res = 0;
rep(i, Size(s)) {
if (s[i] == 'x')
res++;
}
cout << (res > 7 ? "No" : "Yes") << endl;
} | #include <bits/stdc++.h>
using namespace std;
//定数
const long long MOD1 = 1000000007;
const long long MOD2 = 998244353;
const long long INF = 1152921504606846976;
const long double PI = 3.1415926535897932;
//型名省略
#define ll long long
#define ull unsigned long long
#define ld long double
#define pll pair<long long, long long>
#define vl vector<long long>
#define vvl vector<vector<long long>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define umap unordered_map
#define Lqueue priority_queue<long long>
#define Squeue priority_queue<long long, vector<long long>, greater<long long>>
#define Fi first
#define Se second
//マクロ
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rbf(a, x) for (auto &a : x)
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define rep2(i, s, n) for (long long i = (s); i < (long long)(n); i++)
#define Maxe(x) *max_element((x).begin(), (x).end())
#define Mine(x) *min_element((x).begin(), (x).end())
#define Size(x) ((long long)(x).size())
//最大公約数
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
//最小公倍数
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
//累乗
template <typename Num> constexpr Num mypow(Num a, ll b) {
if (b == 0)
return 1;
if (a == 0)
return 0;
Num x = 1;
while (b > 0) {
if (b & 1)
x *= a;
a *= a;
b >>= 1;
}
return x;
}
// chmin,chmax
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// MODint
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
val += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr istream &operator>>(istream &is, Fp<MOD> &x) {
long long t;
is >> t;
x = t;
return (is);
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
using mint = Fp<MOD1>;
// start
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
ll res = 0;
rep(i, Size(s)) {
if (s[i] == 'x')
res++;
}
cout << (res > 7 ? "NO" : "YES") << endl;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,468 | 835,473 | u190580703 | cpp |
p03024 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
#define all(x) (x).begin(), (x).end()
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int INF = 1000000000;
int main() {
string s;
cin >> s;
int k = s.size();
int cnt = 0;
for (int i = 0; i < k; i++)
if (s[i] == 'o')
cnt++;
if (cnt >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
#define all(x) (x).begin(), (x).end()
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int INF = 1000000000;
int main() {
string s;
cin >> s;
int k = s.size();
int cnt = 0;
for (int i = 0; i < k; i++)
if (s[i] == 'o')
cnt++;
if (15 - k + cnt >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"control_flow.branch.if.condition.change"
] | 835,496 | 835,497 | u593934357 | cpp |
p03024 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define allR(v) v.rbegin(), v.rend()
#define PRINT(v) \
for (auto x : (v)) \
cout << x << " "; \
cout << endl;
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
typedef pair<int, int> Pi;
const ll MOD = 1000000007;
const ll INF = 10000000000000000;
const int inf = 1001001001;
vector<int> x4 = {0, 1, 0, -1}, x8 = {0, 1, 1, 1, 0, -1, -1, -1};
vector<int> y4 = {1, 0, -1, 0}, y8 = {1, 1, 0, -1, -1, -1, 0, 1};
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline T powerM(T a, T b) {
if (b == 0)
return 1;
T tmp = powerM(a, b / 2);
if (b % 2 == 0)
return tmp * tmp % MOD;
else
return tmp * tmp % MOD * a % MOD;
}
template <class T> inline T power(T a, T b, T m = numeric_limits<T>::max()) {
if (b == 0)
return 1;
T tmp = power(a, b / 2, m);
if (b % 2 == 0)
return tmp * tmp % m;
else
return tmp * tmp % m * a % m;
}
template <class T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> inline T lcm(T a, T b) { return a / gcd(a, b) * b; }
// ax+by=gcd(a,b)を解く
template <class T> inline T extgcd(T a, T b, T &x, T &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
T d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
void hey() { cout << "hey" << endl; }
template <class T> struct edge {
int to;
T cost;
};
int main() {
string s;
cin >> s;
int batu = 0;
rep(i, s.size()) if (s[i] == 'x') batu++;
bool ok = s.size() - batu >= 8;
cout << (ok ? "YES" : "NO") << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define allR(v) v.rbegin(), v.rend()
#define PRINT(v) \
for (auto x : (v)) \
cout << x << " "; \
cout << endl;
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
typedef pair<int, int> Pi;
const ll MOD = 1000000007;
const ll INF = 10000000000000000;
const int inf = 1001001001;
vector<int> x4 = {0, 1, 0, -1}, x8 = {0, 1, 1, 1, 0, -1, -1, -1};
vector<int> y4 = {1, 0, -1, 0}, y8 = {1, 1, 0, -1, -1, -1, 0, 1};
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline T powerM(T a, T b) {
if (b == 0)
return 1;
T tmp = powerM(a, b / 2);
if (b % 2 == 0)
return tmp * tmp % MOD;
else
return tmp * tmp % MOD * a % MOD;
}
template <class T> inline T power(T a, T b, T m = numeric_limits<T>::max()) {
if (b == 0)
return 1;
T tmp = power(a, b / 2, m);
if (b % 2 == 0)
return tmp * tmp % m;
else
return tmp * tmp % m * a % m;
}
template <class T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> inline T lcm(T a, T b) { return a / gcd(a, b) * b; }
// ax+by=gcd(a,b)を解く
template <class T> inline T extgcd(T a, T b, T &x, T &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
T d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
void hey() { cout << "hey" << endl; }
template <class T> struct edge {
int to;
T cost;
};
int main() {
string s;
cin >> s;
int batu = 0;
rep(i, s.size()) if (s[i] == 'x') batu++;
bool ok = 15 - batu >= 8;
cout << (ok ? "YES" : "NO") << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.change",
"call.remove"
] | 835,502 | 835,504 | u195132800 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
int main() {
string s;
cin >> s;
int k = s.size();
int cnt = 0;
for (int i = 0; i < k; i++) {
if (s[i] == 'o')
cnt++;
}
if (15 - k + cnt >= 8)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll mod = 1e9 + 7;
int main() {
string s;
cin >> s;
int k = s.size();
int cnt = 0;
for (int i = 0; i < k; i++) {
if (s[i] == 'o')
cnt++;
}
if (15 - k + cnt >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | [
"variable_declaration.type.widen.change",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,523 | 835,525 | u191484928 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll mod = 1e9 + 7;
int main() {
string s;
cin >> s;
int k = s.size();
int cnt = 0;
for (int i = 0; i < k; i++) {
if (s[i] == 'o')
cnt++;
}
if (15 - k + cnt >= 8)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll mod = 1e9 + 7;
int main() {
string s;
cin >> s;
int k = s.size();
int cnt = 0;
for (int i = 0; i < k; i++) {
if (s[i] == 'o')
cnt++;
}
if (15 - k + cnt >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,531 | 835,525 | u191484928 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll mod = 1e9 + 7;
int main() {
string s;
cin >> s;
int k = s.size();
int cnt = 0;
for (int i = 0; i < k; i++) {
if (s[i] == 'o')
cnt++;
}
if (15 - k + cnt >= 8)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll mod = 1e9 + 7;
int main() {
string s;
cin >> s;
int k = s.size();
int cnt = 0;
for (int i = 0; i < k; i++) {
if (s[i] == 'o')
cnt++;
}
if (15 - k + cnt >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,531 | 835,533 | u191484928 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long t, i, p = 0;
string s;
cin >> s;
t = s.size();
for (i = 0; i < t; i++) {
if (s[i] == 'o')
p++;
}
p = p + 15 - t;
if (p >= 7)
cout << "YES";
else
cout << "NO";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long t, i, p = 0;
string s;
cin >> s;
t = s.size();
for (i = 0; i < t; i++) {
if (s[i] == 'o')
p++;
}
p = p + 15 - t;
if (p >= 8)
cout << "YES";
else
cout << "NO";
return 0;
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 835,535 | 835,537 | u662180008 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long int ll;
int main() {
string s;
cin >> s;
int k = s.size();
int l = 0;
rep(i, k) if (s[i] == 'x') l++;
if (l <= 7)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long int ll;
int main() {
string s;
cin >> s;
int k = s.size();
int l = 0;
rep(i, k) if (s[i] == 'x') l++;
if (l <= 7)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,539 | 835,541 | u389007679 | cpp |
p03024 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; i >= m; i--)
#define pb push_back
#define eb emplace_back
#define ppb pop_back
#define mpa make_pair
const ll INF = 1e18;
inline void chmax(ll &a, ll b) { a = max(a, b); }
inline void chmin(ll &a, ll b) { a = min(a, b); }
int main() {
string s;
cin >> s;
int k = s.size();
int ans = 0;
rep(i, k) {
if (s[i] == 'x')
ans++;
}
if (ans >= 8)
cout << "No" << endl;
else
cout << "Yes" << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; i >= m; i--)
#define pb push_back
#define eb emplace_back
#define ppb pop_back
#define mpa make_pair
const ll INF = 1e18;
inline void chmax(ll &a, ll b) { a = max(a, b); }
inline void chmin(ll &a, ll b) { a = min(a, b); }
int main() {
string s;
cin >> s;
int k = s.size();
int ans = 0;
rep(i, k) {
if (s[i] == 'x')
ans++;
}
if (ans >= 8)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,543 | 835,545 | u449123607 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
int count = 0;
for (int i = 0; i < S.size(); i++) {
if (S.at(i) == 'o') {
count++;
}
}
if (count + 15 - S.size() >= 8) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
int count = 0;
for (int i = 0; i < S.size(); i++) {
if (S.at(i) == 'o') {
count++;
}
}
if (count + 15 - S.size() >= 8) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,555 | 835,557 | u209457657 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
int cnt = 0;
for (int i = 0; i < S.size(); i++) {
if (S.at(i) == 'x')
cnt++;
}
if (cnt >= 8)
cout << "No" << endl;
else
cout << "Yes" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
int cnt = 0;
for (int i = 0; i < S.size(); i++) {
if (S.at(i) == 'x')
cnt++;
}
if (cnt >= 8)
cout << "NO" << endl;
else
cout << "YES" << endl;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,580 | 835,582 | u533566373 | cpp |
p03024 | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define PI 3.14159265359
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
const long long INF = 1e+18 + 1;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> T;
const ll MOD = 1000000007LL;
string abc = "abcdefghijklmnopqrstuvwxyz";
string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int main() {
string s;
cin >> s;
ll k = s.size();
ll count = 0;
rep(i, k) {
if (s[k] == 'o')
count++;
}
if (count + (15 - k) >= 8) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define PI 3.14159265359
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
const long long INF = 1e+18 + 1;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> T;
const ll MOD = 1000000007LL;
string abc = "abcdefghijklmnopqrstuvwxyz";
string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int main() {
string s;
cin >> s;
ll k = s.size();
ll count = 0;
rep(i, k) {
if (s[i] == 'o')
count++;
}
if (count + (15 - k) >= 8) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 835,588 | 835,590 | u614128939 | cpp |
p03024 | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define all(v) v.begin(), v.end()
using in = int64_t;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define yes cout << "yes" << endl
#define no cout << "no" << endl
const double PI = 3.14159265358979323846;
const in MOD = 1000000007;
const in INF = 1e18 + 7;
const int inf = 1e9 + 7;
using P = pair<int, int>;
vector<int> dx = {0, 1, -1, 0};
vector<int> dy = {1, 0, 0, -1};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
string s;
cin >> s;
int ct = 0;
rep(i, s.size()) if (s[i] == 'x') ct++;
cout << (ct > 6 ? "NO" : "YES");
} | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define all(v) v.begin(), v.end()
using in = int64_t;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define yes cout << "yes" << endl
#define no cout << "no" << endl
const double PI = 3.14159265358979323846;
const in MOD = 1000000007;
const in INF = 1e18 + 7;
const int inf = 1e9 + 7;
using P = pair<int, int>;
vector<int> dx = {0, 1, -1, 0};
vector<int> dy = {1, 0, 0, -1};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
string s;
cin >> s;
int ct = 0;
rep(i, s.size()) if (s[i] == 'x') ct++;
cout << (ct > 7 ? "NO" : "YES");
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"io.output.change"
] | 835,596 | 835,598 | u424602097 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
string s;
int n, win, lose, match;
int main() {
cin >> s;
n = s.length();
for (int i = 1; i <= n; i++) {
if (s[i] == 'o') {
win++;
} else {
lose++;
}
match++;
}
if ((8 - win) <= (15 - match)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
string s;
int n, win, lose, match;
int main() {
cin >> s;
n = s.length();
for (int i = 0; i < n; i++) {
if (s[i] == 'o') {
win++;
} else {
lose++;
}
match++;
}
if ((8 - win) <= (15 - match)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 835,600 | 835,602 | u851275071 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
using ll = long long; // ll は long long と同じとする。
int main() {
string S;
cin >> S;
int win = 0;
int lose = 0;
for (int i = 0; i < S.size(); i++) {
if (S.at(i) == 'o') {
win++;
} else {
lose++;
}
}
if (win >= 7 || lose < 8) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long; // ll は long long と同じとする。
int main() {
string S;
cin >> S;
int win = 0;
int lose = 0;
for (int i = 0; i < S.size(); i++) {
if (S.at(i) == 'o') {
win++;
} else {
lose++;
}
}
if (win >= 7 || lose < 8) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,604 | 835,606 | u629548179 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int count = 0;
for (int i = 0; i < s.size(); i++) {
if (s.at(i) == 'o') {
count++;
}
}
if (count + 15 - s.size() >= 8)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int count = 0;
for (int i = 0; i < s.size(); i++) {
if (s.at(i) == 'o') {
count++;
}
}
if (count + 15 - s.size() >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,374 | 835,375 | u955282280 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int x, cnt = 0;
cin >> s;
for (int i = 0; i < s.size() - 1; ++i) {
if (s[i] == 'o') {
++cnt;
}
}
x = 15 - s.size();
if (cnt + x >= 8) {
cout << "YES\n";
} else
cout << "NO\n";
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int x, cnt = 0;
cin >> s;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == 'o') {
++cnt;
}
}
x = 15 - s.size();
if (cnt + x >= 8) {
cout << "YES\n";
} else
cout << "NO\n";
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 835,376 | 835,377 | u600244905 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n;
string s, t = "ooooooooooooooooooo";
cin >> n >> s;
s += t;
ll cnt = 0;
for (int i = 0; i < 15; i++)
if (s[i] == 'o')
cnt++;
cout << (cnt >= 8 ? "YES" : "NO");
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string s, t = "ooooooooooooooooooo";
cin >> s;
s += t;
ll cnt = 0;
for (int i = 0; i < 15; i++)
if (s[i] == 'o')
cnt++;
cout << (cnt >= 8 ? "YES" : "NO");
return 0;
}
| [
"variable_declaration.remove",
"expression.operation.binary.remove"
] | 835,378 | 835,379 | u774202056 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; i++)
#define RFOR(i, a, n) for (ll i = (ll)n - 1; i >= (ll)a; i--)
#define rep(i, n) FOR(i, 0, n)
#define rrep(i, n) RFOR(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define bra(first, second) '(' << first << ',' << second << ')'
#define P(a, b) make_pair(a, b);
ll MOD = 1000000007;
// ll INF = 21474836470000000;
ll INF = 1001001001001001001;
long double EPS = 1e-11;
long double PI = 3.141592653589793238;
template <typename T> void remove(std::vector<T> &vector, unsigned int index) {
vector.erase(vector.begin() + index);
}
using Graph = vector<vector<ll>>;
int main() {
string S;
cin >> S;
ll cnt = 0;
rep(i, S.size()) if (S[i] == 'o') cnt++;
if (cnt + 15 - S.size() >= 8)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; i++)
#define RFOR(i, a, n) for (ll i = (ll)n - 1; i >= (ll)a; i--)
#define rep(i, n) FOR(i, 0, n)
#define rrep(i, n) RFOR(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define bra(first, second) '(' << first << ',' << second << ')'
#define P(a, b) make_pair(a, b);
ll MOD = 1000000007;
// ll INF = 21474836470000000;
ll INF = 1001001001001001001;
long double EPS = 1e-11;
long double PI = 3.141592653589793238;
template <typename T> void remove(std::vector<T> &vector, unsigned int index) {
vector.erase(vector.begin() + index);
}
using Graph = vector<vector<ll>>;
int main() {
string S;
cin >> S;
ll cnt = 0;
rep(i, S.size()) if (S[i] == 'o') cnt++;
if (cnt + 15 - S.size() >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,380 | 835,381 | u393754572 | cpp |
p03024 | #include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
int cnt = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'o')
cnt++;
}
if (cnt >= 8)
puts("YES\n");
else
puts("NO\n");
return 0;
} | #include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
int cnt = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'x')
cnt++;
}
if (cnt <= 7)
puts("YES\n");
else
puts("NO\n");
return 0;
} | [
"literal.string.change",
"control_flow.branch.if.condition.change"
] | 835,382 | 835,383 | u440588451 | cpp |
p03024 | #include <bits/stdc++.h>
#include <iomanip>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
string S;
int ans = 0;
cin >> S;
for (int i = 0; i < S.size(); i++) {
if (S[i] == 'o') {
ans++;
}
}
if (ans + (S.size() - 15) >= 8) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | #include <bits/stdc++.h>
#include <iomanip>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
string S;
int ans = 0;
cin >> S;
for (int i = 0; i < S.size(); i++) {
if (S[i] == 'o') {
ans++;
}
}
if (ans + (15 - S.size()) >= 8) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 835,386 | 835,387 | u353748264 | cpp |
p03024 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
string s;
cin >> s;
int cnt = 0;
rep(i, s.size()) {
if (s[i] == 'x') {
cnt++;
}
}
if (cnt < 8) {
cout << "Yes";
} else {
cout << "No";
}
cout << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
string s;
cin >> s;
int cnt = 0;
rep(i, s.size()) {
if (s[i] == 'x') {
cnt++;
}
}
if (cnt < 8) {
cout << "YES";
} else {
cout << "NO";
}
cout << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,395 | 835,396 | u828388155 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define repone(i, n) for (int i = 1; i < (int)(n); ++i)
#define repo(i, o, n) for (int i = o; i < (int)(n); ++i)
#define Rep(j, n) for (int j = 0; j < (int)(n); ++j)
#define Repo(j, o, n) for (int j = o; j < (int)(n); ++j)
#define Repone(j, n) for (int j = 1; j < (int)(n); ++j)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define int long long
#define pb(a) push_back(a)
#define eraser(v, i) (v).erase(v.begin() + (i))
#define pbpair(a, b) push_back(make_pair(a, b))
#define MOD 1000000007
#define INF 9223372036854775807
#define pairint pair<int, int>
signed main() {
int x = 0, y = 0, z = 0;
string s;
std::cin >> s;
rep(i, s.size()) {
if (s[i] == 'o')
x++;
else
y++;
}
if (x >= 8)
std::cout << "Yes" << '\n';
else if (x + 15 - s.size() >= 8)
std::cout << "Yes" << '\n';
else
std::cout << "No" << '\n';
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define repone(i, n) for (int i = 1; i < (int)(n); ++i)
#define repo(i, o, n) for (int i = o; i < (int)(n); ++i)
#define Rep(j, n) for (int j = 0; j < (int)(n); ++j)
#define Repo(j, o, n) for (int j = o; j < (int)(n); ++j)
#define Repone(j, n) for (int j = 1; j < (int)(n); ++j)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define int long long
#define pb(a) push_back(a)
#define eraser(v, i) (v).erase(v.begin() + (i))
#define pbpair(a, b) push_back(make_pair(a, b))
#define MOD 1000000007
#define INF 9223372036854775807
#define pairint pair<int, int>
signed main() {
int x = 0, y = 0, z = 0;
string s;
std::cin >> s;
rep(i, s.size()) {
if (s[i] == 'o')
x++;
else
y++;
}
if (x >= 8)
std::cout << "YES" << '\n';
else if (x + 15 - s.size() >= 8)
std::cout << "YES" << '\n';
else
std::cout << "NO" << '\n';
}
| [
"literal.string.change",
"literal.string.case.change",
"expression.operation.binary.change"
] | 835,403 | 835,404 | u893330446 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int cnt = count(s.begin(), s.end(), 'o');
if (cnt >= 8)
cout << "YES";
else
cout << "NO";
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int cnt = count(s.begin(), s.end(), 'x');
if (cnt >= 8)
cout << "NO";
else
cout << "YES";
} | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 835,409 | 835,411 | u472645805 | cpp |
p03024 | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
int main() {
string s;
cin >> s;
int c = 0;
for (int i = 0; i < s.size(); i++) {
if (s.at(i) == 'x')
c++;
}
cout << ((c >= 7) ? "NO" : "YES") << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
int main() {
string s;
cin >> s;
int c = 0;
for (int i = 0; i < s.size(); i++) {
if (s.at(i) == 'x')
c++;
}
cout << ((c > 7) ? "NO" : "YES") << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 835,413 | 835,415 | u356754940 | cpp |
p03024 | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
int main() {
string s;
cin >> s;
int c = 0;
for (int i = 0; i < s.size(); i++) {
if (s.at(i) == 'o')
c++;
}
cout << ((c >= 7) ? "Yes" : "No") << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
int main() {
string s;
cin >> s;
int c = 0;
for (int i = 0; i < s.size(); i++) {
if (s.at(i) == 'x')
c++;
}
cout << ((c > 7) ? "NO" : "YES") << endl;
return 0;
} | [
"literal.string.change",
"control_flow.branch.if.condition.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 835,419 | 835,415 | u356754940 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
typedef vector<ll> Vec;
typedef vector<int> Vi;
typedef vector<string> Vs;
typedef vector<vector<ll>> VV;
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define PER(i, a, b) for (ll i = (a); i >= (b); i--)
#define rep(i, n) REP(i, 0, n)
#define per(i, n) PER(i, n, 0)
const ll INF = 1e16 + 18;
const ll MAX = 100005;
const ll MOD = 1000000007;
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define YES(n) cout << ((n) ? "YES" : "NO") << endl;
#define ALL(v) v.begin(), v.end()
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define Each(a, b) for (auto &a : b)
#define REPM(i, mp) for (auto i = mp.begin(); i != mp.end(); ++i)
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define dbgmap(mp) \
cerr << #mp << ":" << endl; \
for (auto i = mp.begin(); i != mp.end(); ++i) { \
cerr << i->first << ":" << i->second << endl; \
}
#define dbgarr(n, m, arr) \
rep(i, n) { \
rep(j, m) { cerr << arr[i][j] << " "; } \
cerr << endl; \
}
#define dbgdp(n, arr) \
rep(i, n) { cerr << arr[i] << " "; } \
cerr << endl;
#define sum(v) accumulate(ALL(v), 0)
#define fi first
#define se second
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) {
return s << "(" << p.first << ", " << p.second << ")";
}
// vector
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
int len = v.size();
for (int i = 0; i < len; ++i) {
s << v[i];
if (i < len - 1)
s << " ";
}
return s;
}
// 2 dimentional vector
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &vv) {
int len = vv.size();
for (int i = 0; i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << std::setprecision(10);
ll n = 0;
string s;
cin >> s;
rep(i, s.length()) {
if (s[i] == 'x')
n++;
}
Yes(n <= 7);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
typedef vector<ll> Vec;
typedef vector<int> Vi;
typedef vector<string> Vs;
typedef vector<vector<ll>> VV;
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define PER(i, a, b) for (ll i = (a); i >= (b); i--)
#define rep(i, n) REP(i, 0, n)
#define per(i, n) PER(i, n, 0)
const ll INF = 1e16 + 18;
const ll MAX = 100005;
const ll MOD = 1000000007;
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define YES(n) cout << ((n) ? "YES" : "NO") << endl;
#define ALL(v) v.begin(), v.end()
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define Each(a, b) for (auto &a : b)
#define REPM(i, mp) for (auto i = mp.begin(); i != mp.end(); ++i)
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define dbgmap(mp) \
cerr << #mp << ":" << endl; \
for (auto i = mp.begin(); i != mp.end(); ++i) { \
cerr << i->first << ":" << i->second << endl; \
}
#define dbgarr(n, m, arr) \
rep(i, n) { \
rep(j, m) { cerr << arr[i][j] << " "; } \
cerr << endl; \
}
#define dbgdp(n, arr) \
rep(i, n) { cerr << arr[i] << " "; } \
cerr << endl;
#define sum(v) accumulate(ALL(v), 0)
#define fi first
#define se second
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) {
return s << "(" << p.first << ", " << p.second << ")";
}
// vector
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
int len = v.size();
for (int i = 0; i < len; ++i) {
s << v[i];
if (i < len - 1)
s << " ";
}
return s;
}
// 2 dimentional vector
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &vv) {
int len = vv.size();
for (int i = 0; i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << std::setprecision(10);
ll n = 0;
string s;
cin >> s;
rep(i, s.length()) {
if (s[i] == 'x')
n++;
}
YES(n <= 7);
return 0;
}
| [
"identifier.change",
"call.function.change"
] | 835,432 | 835,436 | u592686932 | cpp |
p03024 | #include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
int count = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'x')
count++;
}
if (count <= 7)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
int count = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'x')
count++;
}
if (count < 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,439 | 835,441 | u902803949 | cpp |
p03024 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < n; i++)
template <class T>
using reversed_priority_queue = priority_queue<T, vector<T>, greater<T>>;
int main() {
string s;
cin >> s;
int cnt = 0;
REP(i, s.size()) if (s[i] == 'o') cnt++;
int lt = (15 - (int)s.size()) + cnt;
cout << (lt < 8 ? "No" : "Yes") << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < n; i++)
template <class T>
using reversed_priority_queue = priority_queue<T, vector<T>, greater<T>>;
int main() {
string s;
cin >> s;
int cnt = 0;
REP(i, s.size()) if (s[i] == 'o') cnt++;
int lt = (15 - (int)s.size()) + cnt;
cout << (lt < 8 ? "NO" : "YES") << endl;
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,451 | 835,453 | u693386219 | cpp |
p03024 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(a) (a).begin(), (a).end()
#define SORT(a) sort(all(a))
#define rSORT(a, i) sort(all(a), (i))
using ll = long long;
constexpr ll INF = 10000000000;
constexpr ll MOD = 1000000007;
constexpr int MAX = 2000200;
using namespace std;
int main() {
string s;
cin >> s;
int cnt = 0;
rep(i, s.size()) {
if (s[i] == 'x') {
cnt++;
}
}
if (cnt > 7) {
cout << "No" << endl;
} else {
cout << "Yes" << endl;
}
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(a) (a).begin(), (a).end()
#define SORT(a) sort(all(a))
#define rSORT(a, i) sort(all(a), (i))
using ll = long long;
constexpr ll INF = 10000000000;
constexpr ll MOD = 1000000007;
constexpr int MAX = 2000200;
using namespace std;
int main() {
string s;
cin >> s;
int cnt = 0;
rep(i, s.size()) {
if (s[i] == 'x') {
cnt++;
}
}
if (cnt > 7) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,455 | 835,457 | u955534952 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define Abs(x) ((x) < 0 ? (x) * -1 : (x))
#define rep(x, y) for ((x) = 0; (x) < (y); (x)++)
#define repin(x, y) for ((x) = 0; (x) <= (y); (x)++)
#define nep(x, y) for ((x) = (y)-1; 0 <= (x); (x)--)
#define nepi(x, y, z) for ((x) = (y)-1; (z) <= (x); (x)--)
#define repi(x, y, z) for ((x) = (z); (x) < (y); (x)++)
#define repiin(x, y, z) for ((x) = (z); (x) <= (y); (x)++)
#define reps(x, y, z) for ((x) = 0; (x) < (y); (x) += (z))
#define repis(x, y, z, s) for ((x) = (z); (x) < (y); (x) += (s))
#define repiins(x, y, z, s) for ((x) = (z); (x) <= (y); (x) += (s))
#define repit(x) \
for (__typeof((x).begin()) it = (x).begin(); it != (x).end(); it++)
#define repit2(x) \
for (__typeof((x).begin()) it2 = (x).begin(); it2 != (x).end(); it2++)
#define nepit(x) \
for (__typeof((x).rbegin()) it = (x).rbegin(); it != (x).rend(); it++)
#define All(x) (x).begin(), (x).end()
#define Mem0(x) memset(x, 0, sizeof(x))
#define Mem1(x) memset(x, -1, sizeof(x))
// can be applied to string type
#define Unique(v) v.resize(unique(All(v)) - v.begin())
#define peq(p0, p1) (p0.first == p1.first && p0.second == p1.second)
#define End '\n'
#define Out(x) cout << (x) << End
#define YES cout << "YES" << End
#define NO cout << "NO" << End
#define Yes cout << "Yes" << End
#define No cout << "No" << End
template <typename T> void Outln(const string &sep, const T &val) {
cout << val << End;
}
template <typename T, typename... Args>
void Outln(const string &sep, const T &val, Args... args) {
cout << val << sep;
Outln(sep, std::forward<Args>(args)...);
}
template <typename T> void OutN(T x) {
size_t i, len = x.size() - 1;
for (i = 0; i < len; i++)
cout << x[i] << " ";
cout << x[len] << '\n';
}
#define OutaN(x) \
do { \
size_t i, len = sizeof(x) / sizeof(__typeof(x[0])) - 1; \
for (i = 0; i < len; i++) \
cout << x[i] << " "; \
cout << x[len] << '\n'; \
} while (0);
template <typename T> void Outit(T x) {
auto end = x.end();
end--;
for (auto it = x.begin(); it != end; it++)
cout << *it << " ";
cout << *end << '\n';
}
template <typename T> void Debug(const T &val) { cerr << val << End; }
template <typename T, typename... Args> void Debug(const T &val, Args... args) {
cerr << val << ' ';
Debug(std::forward<Args>(args)...);
}
template <typename T> inline bool Max(T &x, const T &y) {
return x < y ? x = y, 1 : 0;
}
template <typename T> inline bool Min(T &x, const T &y) {
return x > y ? x = y, 1 : 0;
}
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
// can be applied to string type
#define Sort(v) sort(All(v))
#define SortR(v) sort(All(v), std::greater<__typeof(v[0])>())
// array sorters
#define Sart(a) sort(a, a + sizeof(a) / sizeof(__typeof(a[0])));
#define SartR(a) \
sort(a, a + sizeof(a) / sizeof(__typeof(a[0])), \
std::greater<__typeof(a[0])>())
#define pb push_back
#define mp make_pair
#define a first
#define b second
#define lb std::lower_bound
#define ub std::upper_bound
#define lbi(v, x) lb(All(v), (x)) - v.begin()
#define ubi(v, x) ub(All(v), (x)) - v.begin()
inline bool isSame(const string &a, const string &b) {
return a.compare(b) == 0;
}
inline bool isLess(const string &a, const string &b) {
return a.compare(b) < 0;
}
inline bool isGreater(const string &a, const string &b) {
return a.compare(b) > 0;
}
inline string Str(const char &ch, const int &n) { return string(n, ch); }
inline string Str(const int &n, const char &ch) { return string(n, ch); }
vector<string> getStrLine() {
vector<string> v;
string str;
getline(cin, str);
istringstream iss(str);
for (string word; iss >> word;)
v.push_back(word);
return v;
}
static const ll MOD = 1e9 + 7;
static const double PI = 3.141592653589793;
/*** ATCODER, CODECHEF and TOPCODER ***/
// -2147483648 <= INT <= 2147483647
// -9223372036854775808 <= LONG <= 9223372036854775807
// -9223372036854775808 <= LLONG <= 9223372036854775807
/*** END ***/
/*** CODEFORCES ***/
// -2147483648 <= INT <= 2147483647
// -2147483648 <= LONG <= 2147483647
// -9223372036854775808 <= LLONG <= 9223372036854775807
/*** END ***/
#define LOCAL 0
int main() {
#if LOCAL
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
freopen("debug.txt", "w", stderr);
#endif
cin.tie(0);
ios::sync_with_stdio(false);
// std::cout.precision(18);
string s;
cin >> s;
int win = 0;
for (auto ch : s)
if (ch == 'x')
win++;
if (8 <= (15 - s.size()) + win)
YES;
else
NO;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define Abs(x) ((x) < 0 ? (x) * -1 : (x))
#define rep(x, y) for ((x) = 0; (x) < (y); (x)++)
#define repin(x, y) for ((x) = 0; (x) <= (y); (x)++)
#define nep(x, y) for ((x) = (y)-1; 0 <= (x); (x)--)
#define nepi(x, y, z) for ((x) = (y)-1; (z) <= (x); (x)--)
#define repi(x, y, z) for ((x) = (z); (x) < (y); (x)++)
#define repiin(x, y, z) for ((x) = (z); (x) <= (y); (x)++)
#define reps(x, y, z) for ((x) = 0; (x) < (y); (x) += (z))
#define repis(x, y, z, s) for ((x) = (z); (x) < (y); (x) += (s))
#define repiins(x, y, z, s) for ((x) = (z); (x) <= (y); (x) += (s))
#define repit(x) \
for (__typeof((x).begin()) it = (x).begin(); it != (x).end(); it++)
#define repit2(x) \
for (__typeof((x).begin()) it2 = (x).begin(); it2 != (x).end(); it2++)
#define nepit(x) \
for (__typeof((x).rbegin()) it = (x).rbegin(); it != (x).rend(); it++)
#define All(x) (x).begin(), (x).end()
#define Mem0(x) memset(x, 0, sizeof(x))
#define Mem1(x) memset(x, -1, sizeof(x))
// can be applied to string type
#define Unique(v) v.resize(unique(All(v)) - v.begin())
#define peq(p0, p1) (p0.first == p1.first && p0.second == p1.second)
#define End '\n'
#define Out(x) cout << (x) << End
#define YES cout << "YES" << End
#define NO cout << "NO" << End
#define Yes cout << "Yes" << End
#define No cout << "No" << End
template <typename T> void Outln(const string &sep, const T &val) {
cout << val << End;
}
template <typename T, typename... Args>
void Outln(const string &sep, const T &val, Args... args) {
cout << val << sep;
Outln(sep, std::forward<Args>(args)...);
}
template <typename T> void OutN(T x) {
size_t i, len = x.size() - 1;
for (i = 0; i < len; i++)
cout << x[i] << " ";
cout << x[len] << '\n';
}
#define OutaN(x) \
do { \
size_t i, len = sizeof(x) / sizeof(__typeof(x[0])) - 1; \
for (i = 0; i < len; i++) \
cout << x[i] << " "; \
cout << x[len] << '\n'; \
} while (0);
template <typename T> void Outit(T x) {
auto end = x.end();
end--;
for (auto it = x.begin(); it != end; it++)
cout << *it << " ";
cout << *end << '\n';
}
template <typename T> void Debug(const T &val) { cerr << val << End; }
template <typename T, typename... Args> void Debug(const T &val, Args... args) {
cerr << val << ' ';
Debug(std::forward<Args>(args)...);
}
template <typename T> inline bool Max(T &x, const T &y) {
return x < y ? x = y, 1 : 0;
}
template <typename T> inline bool Min(T &x, const T &y) {
return x > y ? x = y, 1 : 0;
}
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
// can be applied to string type
#define Sort(v) sort(All(v))
#define SortR(v) sort(All(v), std::greater<__typeof(v[0])>())
// array sorters
#define Sart(a) sort(a, a + sizeof(a) / sizeof(__typeof(a[0])));
#define SartR(a) \
sort(a, a + sizeof(a) / sizeof(__typeof(a[0])), \
std::greater<__typeof(a[0])>())
#define pb push_back
#define mp make_pair
#define a first
#define b second
#define lb std::lower_bound
#define ub std::upper_bound
#define lbi(v, x) lb(All(v), (x)) - v.begin()
#define ubi(v, x) ub(All(v), (x)) - v.begin()
inline bool isSame(const string &a, const string &b) {
return a.compare(b) == 0;
}
inline bool isLess(const string &a, const string &b) {
return a.compare(b) < 0;
}
inline bool isGreater(const string &a, const string &b) {
return a.compare(b) > 0;
}
inline string Str(const char &ch, const int &n) { return string(n, ch); }
inline string Str(const int &n, const char &ch) { return string(n, ch); }
vector<string> getStrLine() {
vector<string> v;
string str;
getline(cin, str);
istringstream iss(str);
for (string word; iss >> word;)
v.push_back(word);
return v;
}
static const ll MOD = 1e9 + 7;
static const double PI = 3.141592653589793;
/*** ATCODER, CODECHEF and TOPCODER ***/
// -2147483648 <= INT <= 2147483647
// -9223372036854775808 <= LONG <= 9223372036854775807
// -9223372036854775808 <= LLONG <= 9223372036854775807
/*** END ***/
/*** CODEFORCES ***/
// -2147483648 <= INT <= 2147483647
// -2147483648 <= LONG <= 2147483647
// -9223372036854775808 <= LLONG <= 9223372036854775807
/*** END ***/
#define LOCAL 0
int main() {
#if LOCAL
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
freopen("debug.txt", "w", stderr);
#endif
cin.tie(0);
ios::sync_with_stdio(false);
// std::cout.precision(18);
string s;
cin >> s;
int win = 0;
for (auto ch : s)
if (ch == 'o')
win++;
if (8 <= (15 - s.size()) + win)
YES;
else
NO;
return 0;
}
| [
"literal.string.change",
"control_flow.branch.if.condition.change"
] | 835,458 | 835,463 | u518883877 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define uint unsigned long long
#define double long double
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, n) for (int i = 1; i <= (n); i++)
#define all(x) (x).begin(), (x).end()
#define uniq(x) (x).erase(unique(all(x)), (x).end());
#define bit(n) (1LL << (n))
#define dump(x) cerr << #x " = " << (x) << endl
using vint = vector<int>;
using vvint = vector<vint>;
using pint = pair<int, int>;
using vpint = vector<pint>;
template <typename T>
using priority_queue_rev = priority_queue<T, vector<T>, greater<T>>;
constexpr double pi = 3.1415926535897932384626433832795028;
constexpr int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
constexpr int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int gcd(int a, int b) {
while (b) {
swap(a %= b, b);
}
return a;
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
template <typename T1, typename T2> bool chmax(T1 &a, const T2 &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2> bool chmin(T1 &a, const T2 &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &rhs) {
os << "(" << rhs.first << ", " << rhs.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &rhs) {
os << "{";
for (auto itr = rhs.begin(); itr != rhs.end(); itr++) {
os << *itr << (next(itr) != rhs.end() ? ", " : "");
}
os << "}";
return os;
}
struct Setup {
static constexpr int PREC = 20;
Setup() {
cout << fixed << setprecision(PREC);
cerr << fixed << setprecision(PREC);
};
} setup;
signed main() {
string S;
int cnt = 0;
rep(i, S.length()) { cnt += S[i] == 'x'; }
if (cnt > 7) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define uint unsigned long long
#define double long double
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, n) for (int i = 1; i <= (n); i++)
#define all(x) (x).begin(), (x).end()
#define uniq(x) (x).erase(unique(all(x)), (x).end());
#define bit(n) (1LL << (n))
#define dump(x) cerr << #x " = " << (x) << endl
using vint = vector<int>;
using vvint = vector<vint>;
using pint = pair<int, int>;
using vpint = vector<pint>;
template <typename T>
using priority_queue_rev = priority_queue<T, vector<T>, greater<T>>;
constexpr double pi = 3.1415926535897932384626433832795028;
constexpr int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
constexpr int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int gcd(int a, int b) {
while (b) {
swap(a %= b, b);
}
return a;
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
template <typename T1, typename T2> bool chmax(T1 &a, const T2 &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2> bool chmin(T1 &a, const T2 &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &rhs) {
os << "(" << rhs.first << ", " << rhs.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &rhs) {
os << "{";
for (auto itr = rhs.begin(); itr != rhs.end(); itr++) {
os << *itr << (next(itr) != rhs.end() ? ", " : "");
}
os << "}";
return os;
}
struct Setup {
static constexpr int PREC = 20;
Setup() {
cout << fixed << setprecision(PREC);
cerr << fixed << setprecision(PREC);
};
} setup;
signed main() {
string S;
cin >> S;
int cnt = 0;
rep(i, S.length()) { cnt += S[i] == 'x'; }
if (cnt > 7) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
} | [] | 835,469 | 835,470 | u450832845 | cpp |
p03024 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
int main() {
std::string s;
std::cin >> s;
int win = 0;
for (char ch : s) {
if (ch == 'o') {
win++;
}
}
for (int i = 0; i < 15 - s.length(); i++) {
win++;
}
if (win >= 8) {
std::cout << "Yes" << std::endl;
} else {
std::cout << "No" << std::endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
int main() {
std::string s;
std::cin >> s;
int win = 0;
for (char ch : s) {
if (ch == 'o') {
win++;
}
}
for (int i = 0; i < 15 - s.length(); i++) {
win++;
}
if (win >= 8) {
std::cout << "YES" << std::endl;
} else {
std::cout << "NO" << std::endl;
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"expression.operation.binary.change"
] | 835,471 | 835,472 | u430479790 | cpp |
p03024 | #include <bits/stdc++.h>
#define REP(i, n) for (int(i) = 0; (i) < (int)(n); i++)
#define FOR(i, a, b) for (int(i) = a; (i) < (int)b; i++)
#define RREP(i, n) for (int(i) = ((int)(n)-1); (i) >= 0; i--)
#define RFOR(i, a, b) for (int(i) = ((int)(b)-1); (i) >= (int)a; i--)
#define ALL(v) (v).begin(), (v).end()
#define MOD 1000000007
#define FI first
#define SE second
#define MP make_pair
#define PB push_back
#define SZ(x) (int)x.size()
#define SP(x) setprecision((int)x)
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef vector<vint> vvint;
typedef vector<string> vstr;
typedef pair<int, int> pii;
const int INF = 1e9;
const ll LINF = 1e18;
const double EPS = 1e-9;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; } //最大公約数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; } //最小公倍数
int main() {
string s;
cin >> s;
int n = SZ(s);
int cnt = 0;
REP(i, n) {
if (s.at(i) == 'o') {
cnt++;
}
}
if (n <= cnt + 7) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int(i) = 0; (i) < (int)(n); i++)
#define FOR(i, a, b) for (int(i) = a; (i) < (int)b; i++)
#define RREP(i, n) for (int(i) = ((int)(n)-1); (i) >= 0; i--)
#define RFOR(i, a, b) for (int(i) = ((int)(b)-1); (i) >= (int)a; i--)
#define ALL(v) (v).begin(), (v).end()
#define MOD 1000000007
#define FI first
#define SE second
#define MP make_pair
#define PB push_back
#define SZ(x) (int)x.size()
#define SP(x) setprecision((int)x)
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef vector<vint> vvint;
typedef vector<string> vstr;
typedef pair<int, int> pii;
const int INF = 1e9;
const ll LINF = 1e18;
const double EPS = 1e-9;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; } //最大公約数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; } //最小公倍数
int main() {
string s;
cin >> s;
int n = SZ(s);
int cnt = 0;
REP(i, n) {
if (s.at(i) == 'o') {
cnt++;
}
}
if (n <= cnt + 7) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,474 | 835,475 | u852449189 | cpp |
p03024 | // 2_m-solutions2019_b
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector> // C++
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define SZ(x) ((int)(x).size())
#define INF (1e16)
#define MOD (1000000007)
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
int cnt = 0;
int k = s.length();
rep(i, k) {
if (s[i] == 'x')
cnt++;
}
if (cnt > 7) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| // 2_m-solutions2019_b
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector> // C++
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define SZ(x) ((int)(x).size())
#define INF (1e16)
#define MOD (1000000007)
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
int cnt = 0;
int k = s.length();
rep(i, k) {
if (s[i] == 'x')
cnt++;
}
if (cnt <= 7) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 835,510 | 835,512 | u811561461 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
typedef vector<ll> vel;
typedef vector<int> vei;
typedef vector<char> vec;
typedef vector<bool> veb;
typedef vector<string> ves;
typedef vector<vector<ll>> ve_vel;
typedef vector<vector<int>> ve_vei;
typedef vector<vector<char>> ve_vec;
typedef vector<vector<bool>> ve_veb;
typedef vector<vector<string>> ve_ves;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i < (int)(n); i++)
#define rep2(i, n) for (int i = 2; i < (int)(n); i++)
#define repk(i, k, n) for (int i = k; i < (int)(n); i++)
#define fs first
#define sc second
#define pub push_back
#define puf push_front
#define pob pop_back
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define maxel(a) *max_element(all(a))
#define minel(a) *min_element(all(a))
#define acc accumulate
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define mod (1000000007)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string S;
cin >> S;
int cnt = 0;
rep(i, S.size()) {
if (S[i] == 'o')
cnt++;
}
if (cnt >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
typedef vector<ll> vel;
typedef vector<int> vei;
typedef vector<char> vec;
typedef vector<bool> veb;
typedef vector<string> ves;
typedef vector<vector<ll>> ve_vel;
typedef vector<vector<int>> ve_vei;
typedef vector<vector<char>> ve_vec;
typedef vector<vector<bool>> ve_veb;
typedef vector<vector<string>> ve_ves;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i < (int)(n); i++)
#define rep2(i, n) for (int i = 2; i < (int)(n); i++)
#define repk(i, k, n) for (int i = k; i < (int)(n); i++)
#define fs first
#define sc second
#define pub push_back
#define puf push_front
#define pob pop_back
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define maxel(a) *max_element(all(a))
#define minel(a) *min_element(all(a))
#define acc accumulate
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define mod (1000000007)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string S;
cin >> S;
int cnt = 0;
rep(i, S.size()) {
if (S[i] == 'x')
cnt++;
}
if (cnt >= 8)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| [
"literal.string.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 835,514 | 835,516 | u263715385 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
#define YES cout << "YES" << endl;
#define NO cout << "NO" << endl;
#define Yes cout << "Yes" << endl;
#define No cout << "No" << endl;
#define INF INT_MAX
#define MOD 1000000007
#define PI acos(-1)
using ll = long long;
using ull = unsigned long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; i--)
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
ll k = 0;
rep(i, s.size()) {
if (s[i] == 'x') {
k++;
}
}
if (k <= 7) {
NO;
} else {
YES;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define YES cout << "YES" << endl;
#define NO cout << "NO" << endl;
#define Yes cout << "Yes" << endl;
#define No cout << "No" << endl;
#define INF INT_MAX
#define MOD 1000000007
#define PI acos(-1)
using ll = long long;
using ull = unsigned long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; i--)
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
ll k = 0;
rep(i, s.size()) {
if (s[i] == 'x') {
k++;
}
}
if (k <= 7) {
YES;
} else {
NO;
}
return 0;
} | [
"identifier.change"
] | 835,518 | 835,519 | u458798873 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
#define dlog(str) cout << "====" << str << endl;
#define INF 999999999
#define MOD 1000000007
#define REP(i, n) for (int i = 0, i##_l = (n); i < i##_l; i++)
#define FOR(i, s, e) for (int i = s, i##_l = (e); i < i##_l; i++)
#define LLI long long int
#define _min(a, b) ((a < b) ? a : b)
#define _max(a, b) ((a < b) ? b : a)
#define chmax(a, b) a = _max(a, b)
#define chmin(a, b) a = _min(a, b)
#define bit(a, shift) ((a>>shift)&1))
#define pm(a) ((a) ? 1 : -1)
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort(ALL(v))
#define RSORT(v) sort((v).rbegin(), (v).rend())
// int 2.14E±9 lli 9.2E±18 double 1.7E±380
int main() {
string s;
cin >> s;
int cnt = 0;
REP(i, s.size()) {
if (s[i] == 'o') {
cnt++;
}
}
if (8 <= 15 - cnt) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define dlog(str) cout << "====" << str << endl;
#define INF 999999999
#define MOD 1000000007
#define REP(i, n) for (int i = 0, i##_l = (n); i < i##_l; i++)
#define FOR(i, s, e) for (int i = s, i##_l = (e); i < i##_l; i++)
#define LLI long long int
#define _min(a, b) ((a < b) ? a : b)
#define _max(a, b) ((a < b) ? b : a)
#define chmax(a, b) a = _max(a, b)
#define chmin(a, b) a = _min(a, b)
#define bit(a, shift) ((a>>shift)&1))
#define pm(a) ((a) ? 1 : -1)
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort(ALL(v))
#define RSORT(v) sort((v).rbegin(), (v).rend())
// int 2.14E±9 lli 9.2E±18 double 1.7E±380
int main() {
string s;
cin >> s;
int cnt = 0;
REP(i, s.size()) {
if (s[i] == 'x') {
cnt++;
}
}
if (8 <= 15 - cnt) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
} | [
"literal.string.change",
"control_flow.branch.if.condition.change"
] | 835,521 | 835,522 | u840105874 | cpp |
p03024 | #include <algorithm>
#include <climits>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define dlog(str) cout << "====" << str << endl;
#define INF 999999999
#define REP(i, n) for (int i = 0, i##_l = (n); i < i##_l; i++)
#define REPR(i, n) for (int i = n - 1; 0 <= i; i--)
#define FOR(i, s, e) for (int i = s; i <= e; i++)
#define FORR(i, s, e) for (int i = s; e <= i; i--)
#define LLI long long int
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
#define bit(a, shift) ((a>>shift)&1))
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort(ALL(v))
// int 2.14E±9 lli 9.2E±18 double 1.7E±380
int main() {
string s;
cin >> s;
int cnt = 0;
REP(i, s.length()) {
if (s[i] == 'o') {
cnt++;
}
}
if (8 < 15 - s.length() + cnt) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
} | #include <algorithm>
#include <climits>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define dlog(str) cout << "====" << str << endl;
#define INF 999999999
#define REP(i, n) for (int i = 0, i##_l = (n); i < i##_l; i++)
#define REPR(i, n) for (int i = n - 1; 0 <= i; i--)
#define FOR(i, s, e) for (int i = s; i <= e; i++)
#define FORR(i, s, e) for (int i = s; e <= i; i--)
#define LLI long long int
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
#define bit(a, shift) ((a>>shift)&1))
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort(ALL(v))
// int 2.14E±9 lli 9.2E±18 double 1.7E±380
int main() {
string s;
cin >> s;
int cnt = 0;
REP(i, s.length()) {
if (s[i] == 'o') {
cnt++;
}
}
if (7 < 15 - s.length() + cnt) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 835,524 | 835,526 | u840105874 | cpp |
p03024 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
int main() {
string s;
cin >> s;
int win = 0;
rep(i, s.size() - 1) {
if (s.at(i) == 'o')
win++;
}
if (win >= s.size() - 7)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | #include <algorithm>
#include <cctype>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
int main() {
string s;
cin >> s;
int win = 0;
rep(i, s.size()) {
if (s.at(i) == 'o')
win++;
}
if (win + 7 >= s.size())
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 835,528 | 835,530 | u372550522 | cpp |
p03024 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
// for(int i = 0; i<n; i++)
int main() {
string s;
cin >> s;
int a = 0;
for (int i = 0; i < (int)s.size(); i++) {
if (s[i] == 'x')
a++;
}
cout << (a >= 8 ? "No" : "Yes") << endl;
return 0;
}
| #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
// for(int i = 0; i<n; i++)
int main() {
string s;
cin >> s;
int a = 0;
for (int i = 0; i < (int)s.size(); i++) {
if (s[i] == 'x')
a++;
}
cout << (a >= 8 ? "NO" : "YES") << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,559 | 835,561 | u534417782 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int l;
for (int i = 0; i < s.size(); i++) {
if (s.at(i) == 'x')
l++;
}
if (l >= 8)
cout << "NO" << endl;
else
cout << "YES" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int l = 0;
for (int i = 0; i < s.size(); i++) {
if (s.at(i) == 'x')
l++;
}
if (l >= 8)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
| [
"variable_declaration.value.change"
] | 835,595 | 835,597 | u013203292 | cpp |
p03024 | #include <iostream>
using namespace std;
int main() {
string s;
cin >> s;
int num = s.size();
int count = 0;
// cout << num << endl;
for (int i = 0; i < num; i++) {
if (s[i] == 'x') {
count++;
}
}
if (count >= 8) {
cout << "No" << endl;
} else {
cout << "Yes" << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
string s;
cin >> s;
int num = s.size();
int count = 0;
// cout << num << endl;
for (int i = 0; i < num; i++) {
if (s[i] == 'x') {
count++;
}
}
if (count >= 8) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 835,611 | 835,613 | u689134705 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.