jiahuimbzuai/CoQuIR huggingface dataset:
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);const nin=()=>{const r = input[0];input.shift();return Number(r)};const nrin=(n)=>{const a:number[]=[];rep(n,()=>a.push(nin()));return a};const sin=()=>{const r = input[0];input.shift();return String(r)};const out=(...a)=>{console.log(...a)};const floor=(a)=>{return Math.floor(a)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const rep=(n, callback)=>{for(let i = 0;i < n; i++){callback()}};const strrep=(s, i, v)=>{return s.slice(0, i)+v+s.slice(i+1);};const permutation=({result=[],pre=[],post,n=post.length})=>{if(n>0){post.forEach((_,i)=>{const rest=[...post];const elem=rest.splice(i, 1);permutation({result, pre: [...pre,...elem],post:rest,n:n-1})})}else{result.push(pre)}return result};const sw=(s,a:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<a.length;i+=2){if(op==='=='){if(s==a[i])return a[i+1]}else if(op==='>='){if(s>=a[i])return a[i+1]}else if(op==='<='){if(s<=a[i])return a[i+1]}else if(op==='>'){if(s>a[i])return a[i+1]}else if(op==='<'){if(s<a[i])return a[i+1]}}return a[a.length-1];};const or=(a,...b)=>{for(let i=0;i<b.length;i++)if(a==b[i])return true;return false};const maxindex=(...a)=>{return a.indexOf(Math.max.apply(null,a))};const asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.sort((a,b)=>{return b-a})};const ceil=a=>{return Math.ceil(a)};const srin=s=>{const a:string[]=[];rep(s,()=>a.push(sin()));return a};let ssinteger=-1;const ssin=()=>{ssinteger++;return input[0][ssinteger]};
const main = ()=>{
  let[a,b,c]=srin(3)
  out(a[0]+b[0]+c[0])
}
main()
//  [python]
try:
  n=int(input())
  print((1000-n%1000)%1000)
except EOFError:
  pass
//  [python]
#!/usr/bin/python3
n = int(input())
if(n%1000==0):
	print("0")
else:
	ans = n%1000
	print(1000-ans)
//  [python]
n = int(input())
while n>0:
    n -= 1000

print(-n)
//  [python]
n = int(input())
print((1000-n//1000)%1000)
//  [python]
pay = int(input())

while(pay >=0):
    pay -= 1000
otu = abs(pay)
print(otu)
//  [python]
n=int(input())
if n%1000==0:
  print(0)
elif:
  print(1000-n%1000)
//  [java]
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);

        Problem solver = new Problem();
        solver.solve(0, in, out);
        out.close();
    }

    static class Problem {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int N = in.nextInt();
            if (N % 1000 == 0)
                out.println(0);
            else
                out.println(1000 - (N % 1000));
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}
//  [java]
import java.util.*;
import java.io.*;
import static java.lang.Math.*;

public class Main {
    public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		
		// 入力
		int n = sc.nextInt();
		
		// 計算
		int result = 0;
		if(n%1000 != 0) result = 1000 - n%1000;
		
		
		// 出力
		System.out.println(result);
	}
	
	public static class Scanner {
		private BufferedReader br; private StringTokenizer tok;
		public Scanner(InputStream is) throws IOException { br = new BufferedReader(new InputStreamReader(is));}
		private void getLine() throws IOException { while(!hasNext()) tok = new StringTokenizer(br.readLine());}
		private boolean hasNext() { return tok != null && tok.hasMoreTokens();}
		public String next() throws IOException { getLine(); return tok.nextToken();}
		public int nextInt() throws IOException { return Integer.parseInt(next());}
		public long nextLong() throws IOException { return Long.parseLong(next());}
		public double nextDouble() throws IOException { return Double.parseDouble(next());}
	}
}
//  [java]
import java.util.*;
public class Main{
  public static void main(String[] args)throws Exception{
    Scanner sc=new Sanner(System.in);
    int N=Integer.perseInt(sc.next());
    System.out.println(N%1000);
  }
}
//  [cpp]
#include <iostream>
using namespace std;
int main()
{
    int N;
    cin >> N;
    if(N%1000==0)
    {
        cout<<0<<endl;
    }
    else
    {
        cout<<(1000-N%1000)<<endl;
    }
    return 0;
}
//  [cpp]
#include <stdio.h>

int main (){
   int n;
   int m;
   scanf("%d", &n);

   for(m = 0; m<n;m += 1000){
   }
   printf("%d", m-n);
return 0;
}
//  [cpp]
#include <stdio.h>
#include <string.h>

int main()
{
	int N;
	scanf("%d", &N);

	int x = (N + 999) / 1000 * 1000;
	printf("%d\n", x - N);
	return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
#define all(x) x.begin(),x.end()
#define rep(i,j,n) for (long long i = j; i < (long long)(n); i++)
#define _GLIBCXX_DEBUG
#define MOD 1000000007
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; }
//(a+b-1)/b

signed main(){
	int n;
    cin >> n ;
  cout <<(n + 1000 - 1)/1000 << endl;
	
	return 0;
}
//  [cpp]
ソースコード 

Copy
Copy
#include<bits/stdc++.h>
using namespace std;
 
int main(){
  int N;
  cin >> N;
  if(N%1000==0){
    cout << "0" << endl;
    return 0;
  }
  cout << 1000-N%1000 << endl;
  return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;

int main(){
  int N;
  cin >> N;
  if(N%1000==0){
    cout << "0" << endl;
    return 0;
  }
  cout << 1000-N%1000 << endl;
  return 0;
//  [c]
#include<stdio.h>
int main(){
  int x;
  scanf("%d",&x);
  printf("%d",(x/1000+(x%1000!=0))*1000-x);
}
//  [c]
#include <stdio.h>
int main (){
  int N=0,i=0;
  scanf("%d",&N);
  for(i=0;N>=1000;i++){
    N=N-1000;
  }
  N=1000-N;
  if(N==1000){
    N=0;
  }
  printf("%d",N);
}
//  [c]
#include <stdio.h>
main(){
  int N = 0;
  int t = 0;
  int i = 0;
  scanf("%d", &N);
  i = 1000;
  while (i < N){
    i = i + 1000;
  }	
  t = i - N;
  printf("%d", t);
}
//  [c]
#include<stdio.h>
#include<string.h>


int main()
{
    int k,n,s;
    scanf("%d",&n);
    k=n%1000;
    k=1000-k;
    printf("%d",k);
    return 0;
}
//  [c]
#include <stdio.h>

int main()
{
  int N;
  scanf("%d",&N);
  int ans = N%1000;

  if(ans = 0){
    printf("%d", 0);
  }else{
    printf("%d",1000-ans);
  }

    return 0;
}
//  [javascript]
const main = (input) => {
  const change = (answer) => {
    const temp = parseInt(answer, 10);
    if (temp === 0) {
      return 0;
    } else {
      return 1000 - temp;
    }
  };

  const N = input.trim().split("");
  if (N.length <= 3) {
    console.log(change(N.join("")));
  } else {
    let answer = "";
    let cnt = 0;

    while (cnt < 3) {
      answer = N.pop() + answer;
      cnt++;
    }

    console.log(change(answer));
  }
};

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
const main = (input) => {
  const n = Number(input)
  if(n % 1000 === 0) {
    console.log(0)
  } else {
    console.log(1000 - (n % 1000))
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
function main(input) {
  console.log(Math.ceil(input / 1000) * 1000 - input);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(input) {
  input = input.split("\n");
  const N = parseInt(input[0]);

  let answer;
  if (N % 1000 === 0) {
    answer = 0;
  } else {
    answer = N % 1000;
  }

  console.log(answer);

}
// デバッグ用
function debug() {
  var input = document.getElementById("input").value;
  Main(input);
}

//* この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
const main = stdin => {
  const N = parseInt(stdin.trim())
  console.log(1000 - N % 1000)
}


// 標準入力
main(require("fs").readFileSync("/dev/stdin", "utf8"))
//  [javascript]
const main = (stdin) => {
    const input = Number(stdin)
    console.log(input % 1000)
}
 
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	mod := n % 1000
	change := mod
	if mod != 0 {
		change = 1000 - mod
	}
	fmt.Println(change)
}
//  [go]
//go:generate echo "https://atcoder.jp/contests/abc173/tasks/abc173_a"
package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"strconv"
)

type scanner struct{ *bufio.Scanner }

func newScanner(r io.Reader) *scanner {
	s := bufio.NewScanner(r)
	s.Split(bufio.ScanWords)
	s.Buffer(nil, 100000000)
	return &scanner{s}
}

func (s *scanner) Int() int {
	s.Scan()
	n, _ := strconv.Atoi(s.Text())
	return n
}

func (s *scanner) Ints(l int) []int {
	if l == 0 {
		return []int{}
	}
	sl := make([]int, l, l)
	for i := range sl {
		sl[i] = s.Int()
	}
	return sl
}

func solve(N int) int {
	return (1000 - N%1000) % 1000
}

func run(r io.Reader, w io.Writer) {
	scan := newScanner(r)
	fmt.Fprintln(w, solve(scan.Int()))
}

func main() {
	run(os.Stdin, os.Stdout)
}
//  [go]
package main
 
import "fmt"
 
func main() {
  var n int
  fmt.Scan(&n)
  i := 0
  for true {
    i+= 1
    if 1000 * i >= n {
      ans := 1000 * i - n
      fmt.Println(ans)
      break
    }
  }
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Scan(&n)

	fmt.Println(1000 - n%1000)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var N int
	fmt.Scan(&N)

	var change int = N % 1000
	fmt.Println(change)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var N int
	fmt.Scan(&N)

	change := N % 1000
	fmt.Println(change)
}
//  [ruby]
n = gets.to_i
ans = 1000 - n % 1000
puts ans == 1000 ? 0 : ans
//  [ruby]
n = gets.to_i

if n % 1000 == 0
  puts 0
else
  puts 1000 - (n % 1000)
end
//  [ruby]
ans = 1000 - (gets.chomp.to_i % 1000)
puts ans == 1000 ? 0 : ans
//  [ruby]
n = gets.chars.map(&:to_i)
change = 1000 - n[-3,3].join.to_i

if change == 1000
  puts 0
else
  puts change
end
//  [ruby]
n = gets.chomp.to_i
#p n
ans = n % 1000
ans == 0 ? 0 : 1000 - ans
p ans
//  [ruby]
n = gets.to_i
ac = wa = tle = re = 0

n.times do
  case gets.strip
    when 'AC' then ac += 1
    when 'WA' then wa += 1
    when 'TLE' then tle += 1
    when 'RE' then re += 1
  end
end
      
puts "AC x #{ac}"
puts "WA x #{wa}"
puts "TLE x #{tle}"
puts "RE x #{re}"
//  [rust]
use proconio::input;

fn main() {
    input! {
        n: i32, // 購入金額
    }

    let m = n % 1000;
    println!("{}", if m == 0 { m } else { 1000 - m });
}
//  [rust]
use itertools::interleave;
use itertools::join;
use proconio::input;
use proconio::marker::Chars;

use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
use std::io::Write;

pub trait Echo {
    fn echo(&self);
    fn echo_b(&self, out: &mut std::io::Stdout) -> Result<(), std::io::Error>;
}

macro_rules! impl_echo {
    ($($t:ty),*) => {
        $(
            impl Echo for $t {
                fn echo(&self){
                    self.echo_b(&mut std::io::stdout()).unwrap();
                }

                fn echo_b(&self, out: &mut std::io::Stdout) -> Result<(), std::io::Error>{
                    writeln!(out,"{}", &self)?;
                    Ok(())
                }
            }
        )*
    };
}

macro_rules! impl_echo_f {
    ($($t:ty),*) => {
        $(
            impl Echo for $t {
                fn echo(&self){
                    self.echo_b(&mut std::io::stdout()).unwrap();
                }

                fn echo_b(&self, out: &mut std::io::Stdout) -> Result<(), std::io::Error>{
                    writeln!(out,"{:.12}", &self)?;
                    Ok(())
                }
            }
        )*
    };
}

impl_echo!(u8, u16, u32, u64, u128, usize);
impl_echo!(i8, i16, i32, i64, i128, isize);
impl_echo!(&str, String, char);
impl_echo_f!(f32, f64);

impl<T: Echo> Echo for Vec<T> {
    fn echo(&self) {
        self.echo_b(&mut std::io::stdout()).unwrap();
    }
    fn echo_b(&self, out: &mut std::io::Stdout) -> Result<(), std::io::Error> {
        for i in self {
            i.echo_b(out).unwrap();
        }
        Ok(())
    }
}

fn main() {
    input! {
        n: usize
    };
    let res = if n % 1000 == 0 { 0 } else { 1000 - n % 1000 };
    res.echo();
}

#[allow(dead_code)]
fn yn(i: bool) {
    if i {
        println!("Yes");
    } else {
        println!("No");
    }
}
//  [rust]
//【ライブラリここから】
// 1. 入力の容易化（https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8）
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}
//【ライブラリここまで】

fn main() {
    input! {n: i32};
    println!("{}", 1000 - n % 1000);
}
//  [rust]
//【ライブラリここから】
// 1. 入力の容易化（https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8）
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}
//【ライブラリここまで】

fn main() {
    input! {n: i32};
    println!("{}", n % 1000);
}
//  [rust]
use proconio::{fastout, input}; 
#[fastout]
fn main() {
    input! {mut n:usize};
    n %= 1000;

    println!({}, n == 0 : n ? 1000 - n);
}
//  [swift]
let n = Int(readLine()!)!
var pay = 0
while pay < n {
  pay += 1000
}
print(pay - n)
//  [swift]
let N = Int(readLine()!)!
print(N % 1000 == 0 ? 0 : 1000 - (N % 1000))
//  [swift]
let a = Int(readLine()!)!
if a%1000 == 0 {
  print(0)} else {
print(1000 - a%1000)
}
//  [swift]
import Foundation
 
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ")
 
let N = Double(split[0])!

print(Int(ceil(N/1000)) - Int(N))
//  [swift]
import Foundation
 
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ")
 
let N = Double(split[0])!

print(Int(ceil(N/1000))-N)
//  [swift]
func readInt() -> Int {
    return Int(readLine()!)!
}

func main() {
    let price = readInt()
    let payment = price % 1000 == 0 ? price / 1000 : price / 1000 * 1
    let exchange = payment - price
    print(exchange)
    return
}
//  [typescript]
{
  const Main = (input: string) => {
    const n = parseInt(input.trim())
    console.log(Math.ceil(n / 1000) * 1000 - n)
  };

  Main(require("fs").readFileSync("/dev/stdin", "utf8"));
}
//  [typescript]
import * as fs from "fs";

const input: string = fs.readFileSync("/dev/stdin", "utf8");
let num: number = parseInt(input);

console.log(num % 1000 == 0 ? 0 : 1000 - num % 1000);
//  [typescript]
import { readFileSync } from 'fs'

function main(input: string) {
  const n = Number(input)

  const base = 1000
  const result = Math.ceil(n / base) * base - n

  console.log(result)
}

main(readFileSync('/dev/stdin', 'utf8').trim())
//  [typescript]
import * as fs from "fs";

const input: string = fs.readFileSync("/dev/stdin", "utf8");
let num: number = parseInt(input);

console.log(1000 - num % 1000);
//  [typescript]
"use strict";

const main = (arg: string) => {
  const input: string = arg.trim();

  let x = parseInt(input)

  while (x >= 1000) {
    x %= 1000
  }

  console.log(x)
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
import * as fs from "fs";

// inputで受け取り配列化する
const input = fs.readFileSync("/dev/stdin", "utf8");

console.log(1000 - (Number(input) % 1000));
//  [python]
data = input().split()
r = int(data[0])
g = int(data[1])
b = int(data[2])

num = 10*g + b

if(num % 4 == 0):
	print("YES")
else:
	print("NO")
//  [python]
print("YES" if eval(input().replace(" ",""))%4 == 0 else "NO")
//  [python]
r, g, b = input().split()
if int(r + g + b) % 4 == 0:
    print('YES')
else:
    print('NO')
//  [python]
N = int("".join(map(str,input().split())))
print(("No","Yes")[N % 4 == 0])
//  [python]
r, g, b = map(int, input().split())
num = 10*y + z
if num % 4 == 0:
  print("YES")
else:
  print("NO")
//  [python]
r, g, b = map(int, input().split())

N = r * 100 + g * 10 + b

if N % 4 == 0:
    print("Yes")
else:
    print("No")
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;


public class Main {
  public static void main(String[] args) {
    FastScanner sc = new FastScanner();
    int v = sc.nextInt() * 100 + sc.nextInt() * 10 + sc.nextInt();
    System.out.println(v % 4 == 0 ? "YES" : "NO");
  }

}


class FastScanner {
	public static String debug = null;

	private final InputStream in = System.in;
	private int ptr = 0;
	private int buflen = 0;
	private byte[] buffer = new byte[1024];
	private boolean eos = false;

	private boolean hasNextByte() {
		if (ptr < buflen) {
			return true;
		} else {
			ptr = 0;
			try {
				if (debug != null) {
					buflen = debug.length();
					buffer = debug.getBytes();
					debug = "";
					eos = true;
				} else {
					buflen = in.read(buffer);
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (buflen < 0) {
				eos = true;
				return false;
			} else if (buflen == 0) {
				return false;
			}
		}
		return true;
	}

	private int readByte() {
		if (hasNextByte())
			return buffer[ptr++];
		else
			return -1;
	}

	private static boolean isPrintableChar(int c) {
		return 33 <= c && c <= 126;
	}

	private void skipUnprintable() {
		while (hasNextByte() && !isPrintableChar(buffer[ptr]))
			ptr++;
	}

	public boolean isEOS() {
		return this.eos;
	}

	public boolean hasNext() {
		skipUnprintable();
		return hasNextByte();
	}

	public String next() {
		if (!hasNext())
			throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while (isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	public long nextLong() {
		if (!hasNext())
			throw new NoSuchElementException();
		long n = 0;
		boolean minus = false;
		int b = readByte();
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		if (b < '0' || '9' < b) {
			throw new NumberFormatException();
		}
		while (true) {
			if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			} else if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			}
			b = readByte();
		}
	}

	public int nextInt() {
		return (int) nextLong();
	}

	public long[] nextLongList(int n) {
		return nextLongTable(1, n)[0];
	}

	public int[] nextIntList(int n) {
		return nextIntTable(1, n)[0];
	}

	public long[][] nextLongTable(int n, int m) {
		long[][] ret = new long[n][m];
		for (int i = 0; i < n; i ++) {
			for (int j = 0; j < m; j ++) {
				ret[i][j] = nextLong();
			}
		}
		return ret;
	}

	public int[][] nextIntTable(int n, int m) {
		int[][] ret = new int[n][m];
		for (int i = 0; i < n; i ++) {
			for (int j = 0; j < m; j ++) {
				ret[i][j] = nextInt();
			}
		}
		return ret;
	}
}
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;

public class Main {
	private static FastScanner sc = new FastScanner();

	public static void main(String[] args) {
		int r = sc.nextInt();
		int g = sc.nextInt();
		int b = sc.nextInt();
		if((g%2 == 0 && b%4 == 0) || (g%2 == 1 && b%4 == 2)) {
			System.out.println("YES");
		} else {
			System.out.println("NO");
		}
	}

	static class FastScanner {
        private final InputStream in = System.in;
        private final byte[] buffer = new byte[1024];
        private int ptr = 0;
        private int buflen = 0;
        private boolean hasNextByte() {
            if(ptr < buflen) {
                return true;
            } else {
                ptr = 0;
                try {
                    buflen = in.read(buffer);
                } catch(IOException e) {
                    e.printStackTrace();
                }
                if(buflen <= 0) {
                    return false;
                }
            }
            return true;
        }
        private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
        private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
        private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
        public boolean hasNext() { skipUnprintable(); return hasNextByte();}
        public String next() {
            if (!hasNext()) throw new NoSuchElementException();
            StringBuilder sb = new StringBuilder();
            int b = readByte();
            while(isPrintableChar(b)) {
                sb.appendCodePoint(b);
                b = readByte();
            }
            return sb.toString();
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public int nextInt(){
            return Integer.parseInt(next());
        }
        public double nextDouble(){
            return Double.parseDouble(next());
        }
    }
}
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Main
{
	public static void main(String[] args)throws IOException
	{
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String card[] = br.readLine().split(" ");
		int sum = 0;
		sum = (Integer.parseInt(card[1]))*10 + (Integer.parseInt(card[2]));
		if(sum % 4 == 0) System.out.println("YES");
		else System.out.println("NO");
			
	}
}
//  [java]


import java.util.*;
import java.io.*;

public class Main {
    static class FS {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");

        String next() {
            while (!st.hasMoreTokens())
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        int[] readArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        public long[] readLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }
    }

    static final FS sc = new FS();
    static final PrintWriter out = new PrintWriter(System.out);
    static final int mod = 1000000007;

    public static void main(String[] args) {

        solve();
        out.close();

    }

    static void solve() {
        int a = sc.nextInt();
        if (a % 4 == 0){
            out.println("Yes");
        }
        else {
            out.println("No");
        }
    }
}
//  [java]

import java.util.Scanner;

public class Main {

	static Scanner scanner;

	public static void main(String[] args) {
	    scanner = new Scanner(System.in);

	    int N=gi();
	    String S=gs();

	    int s=0;
	    int e=0;
	    int sc=0;
	    for (int i=0; i<N;i++) {
	    	char c=S.charAt(i);
	    	if(c=='(') {
	    		s++;
	    	} else {
	    		e++;
	    	}
	    	sc=Math.max(sc, e-s);
	    }

	    int s2=0;
	    int e2=0;
	    int ec=0;
	    for (int i=N-1; i>=0;i--) {
	    	char c=S.charAt(i);
	    	if(c=='(') {
	    		s2++;
	    	} else {
	    		e2++;
	    	}
	    	ec=Math.max(ec, s2-e2);
	    }

	    StringBuilder sb=new StringBuilder();
	    for(int i=0; i<sc;i++) {
	    	sb.append('(');
	    }
	    sb.append(S);
	    for(int i=0; i<ec;i++) {
	    	sb.append(')');
	    }
	    String ns=sb.toString();


        System.out.println(ns);
	}

	public static class Edge {
	    private int from;
	    private int to;
	    private long cost;

	    public Edge(int f, int t, long c) {
	    	this.from=f;
	    	this.to=t;
	    	this.cost=c;
	    }

	    public int gfrom() {
	    	return from;
	    }

	    public int gto() {
	    	return to;
	    }

	    public long gcost() {
	    	return cost;
	    }

	    public void sfrom(int f) {
	    	from=f;
	    }

	    public void sto(int t) {
	    	to=t;
	    }

	    public void scost(int c) {
	    	cost=c;
	    }
	}
	// 文字列として入力を取得
	public static String gs() {
		return scanner.next();
	}

	// intとして入力を取得
	public static int gi() {
		return Integer.parseInt(scanner.next());
	}

	// longとして入力を取得
	public static long gl() {
		return Long.parseLong(scanner.next());
	}

	// doubleとして入力を取得
	public static double gd() {
		return Double.parseDouble(scanner.next());
	}
}
//  [java]
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int r = sc.nextInt();
        int g = sc.nextInt();
        int b = sc.nextInt();
      
        if (((r * 100 ) + (g * 10) + b ) % 4 == 0) {
          System.out.println("Yes");
        }
        else {
          System.out.println("No");
        }
    }
}
//  [cpp]
#include <stdio.h>

int main(){
    int a, b, c;
    scanf("%d%d%d", &a, &b, &c);
    if((100*a+10*b+c)%4) printf("NO");
    else printf("YES");
    return 0;
}
//  [cpp]
#include <stdio.h>

int main() {
    int r, g, b;
    scanf("%d %d %d", &r, &g, &b);
    printf("%s\n", (100*r+10*g+b) % 4 == 0 ? "YES" : "NO");
}
//  [cpp]
// Copyright 2017 wu_qing
#include <cstdio>
int a, b, c, tot;
int main() {
    scanf("%d%d%d", &a, &b, &c);
    tot = a * 100 + b *10 + c;
    if (tot % 4 == 0)
        printf("YES\n");
    else
        printf("NO\n");
    return 0;
}
//  [cpp]
#include <iostream>
using namespace std;
int main()
{
  int r, g, b;
  cin >> r >> g >> b;
  if ((r*100+g+10+b)%4==0) {
    cout << "YES" << endl;
  } else {
    cout << "NO" << endl;
  }
  return 0;
}
//  [cpp]
#include <iostream>
using namespace std;
int main()
{
  int r, g, b;
  cin >> r >> g >> b;
  if ((r*100+g+10+b)%4==0) {
    cout << "YES" << endl;
  } else {
    cout << "NO" endl;
  }
  return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
 int H, W;
 int seen[10000][10000];
  char S[10000][10000];
vector<pair<ll, ll>> prime_factorize(ll n) { //素因数分解と各素数の個数
    vector<pair<ll, ll>> res;

    for (ll i = 2; i * i <= n; i++)
    {
        if (n % i != 0)
        {
            continue;
        }
        int num = 0;
        
        while (n % i == 0)
        {
            ++num;
            n /= i;
        }
        res.push_back(make_pair(i, num));
       
    }
     if (n != 1) 
        {
            res.push_back(make_pair(n, 1));
        }
        return res;
        
} 
long long GCD(long long a, long long b) {
    if (b == 0) return a;
    else return GCD(b, a % b);
}
ll lcm(ll x, ll y) {
    return x / GCD(x, y) * y;//先に割り算をして掛けられる数を小さくして掛け算を行う
}
const int MAX = 510000;
const int MOD = 1000000007;

long long fac[MAX], finv[MAX], inv[MAX];

// テーブルを作る前処理
void COMinit() {
    fac[0] = fac[1] = 1;
    finv[0] = finv[1] = 1;
    inv[1] = 1;
    for (int i = 2; i < MAX; i++){
        fac[i] = fac[i - 1] * i % MOD;
        inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
        finv[i] = finv[i - 1] * inv[i] % MOD;
    }
}

// 二項係数計算
long long COM(int n, int k){
    if (n < k) return 0;
    if (n < 0 || k < 0) return 0;
    return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}

void dfs(int st, int fi) {
  //  cout << st << " " << fi <<  endl;
    if (st < 0 || fi < 0 || st >= H || fi >= W)
    {
        return ;
    }
    if (S[st][fi] == '#')
    {
        return ;
    }

    if (seen[st][fi] == 1)
    {
        return ;
    }
    
    
    if (S[st][fi] == '.')
    {
        seen[st][fi] = 1;
    }
    

    dfs(st + 1, fi);
    dfs(st, fi + 1);
    dfs(st, fi - 1);
    dfs(st - 1, fi);
    
}
int main() {
 int N;
 cin >> N;
 vector<int> a(N), sum(9);
 for(int i = 0; i < N; i++) {
     cin >> a[i];
 }
 int ans = 0;
 for (int i = 0; i < N; i++)
 {
     //cout << 1 << endl;
    if (a[i] >= 1 && a[i] <= 399)
    {
        
        sum[0]++;
       
    }else if (a[i] >= 400 && a[i] <= 799)
    {
        sum[1]++;
       
    }else if (a[i] >= 800 && a[i] <= 1199)
    {
        sum[2]++;
       
    }else if (a[i] >= 1200 && a[i] <= 1599)  
    {
        sum[3]++;
       
    }else if (a[i] >= 1600 && a[i] <= 1999)
    {
        sum[4]++;
       
    }else if (a[i] >= 2000 && a[i] <= 2399)
    {
        sum[5]++;
       
    }else if (a[i] >= 2400 && a[i] <= 2799)
    {
        sum[6]++;
       
    }else if (a[i] >= 2800 && a[i] <= 3199)
    {
        sum[7]++;
       
    }else
    {
        sum[8]++;
    }
    
 }
 for (int i = 0; i < 8; i++)
 {
    if(sum[i] >= 1) ans += 1; 
 }
 if (ans == 0)
 {
     cout << 1 << " " << sum[8] << endl;
     return 0;
 }
 
 cout << ans << " " << ans + sum[8] << endl;
    return 0;


}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
	int a, b, c;
	scanf("%d%d%d",&a,&b,&c);
	c=(a*100+b*10+c)%4;
	if (!c)printf("YES\n");
	else printf("NO\n");
	return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>

int main(void){
    //int r,g,b;
    char r,g,b;
    char str[4];
    
    scanf("%c %c %c", &r,&g,&b);
    
    //printf("%c", (char)r);
    
    str[0]=r;
    str[1]=g;
    str[2]=b;
    
    //printf("%s\n", str);

    if((atoi(str))%4==0){
        printf("YES\n");
    }else{
        printf("NO\n");
    }
    
    return 0;
}
//  [c]
#include<stdio.h>
int main(void) {
	int n, m;
	scanf("%d", &n);
	scanf("%d%d", &n, &m);
	(n * 10 + m) % 4 == 0 ? printf("YES") : printf("NO");
	return 0;
}
//  [c]
#include <bits/stdc++.h>
using namespace std;

int main() {
    int a, b, c;
    cin >> a >> b >> c;
    int re = (100 * a) + (10 * b) + c;

    if (re % 4 == 0) {
        cout << "YES" << endl;
    } else {
        cout << "NO" << endl;
    }
    return 0;
}
//  [c]
#include<bits/stdc++.h>
using namespace std;

int main() {
    int a, b, c;
    cin >> a >> b >> c;
    int re = (100 * a) + (10 * b) + c;

    if (re % 4 == 0) {
        cout << "YES" << endl;
    } else {
        cout << "NO" << endl;
    }
    return 0;
}
//  [c]
#include <stdio.h>
int main() {
  int a, b, c;
  scanf("%d %d %d", &a, &b, &c);
  (((a*100)+(b*10)+c)%4==0)?printf("YES\n");:printf("NO\n");
}
//  [javascript]
'use strict'
 
function main(s) {
  let n = s.split('\n')[0].split(' ');
  let target = Number(n[1]+n[2]);
  //console.log(target);
  let ans = target % 4 === 0? 'YES':'NO';
  console.log(ans);
}
 
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  const num = input.split(" ").join("");
  console.log(num % 4 === 0 ? "YES" : "NO");
}
Main(require("fs").readFileSync("/dev/stdin","utf8"));
//  [javascript]
function Main(input) {
	input = input.trim().split(" ").join("");
  console.log((parseInt(input) % 4 == 0) ? "YES" : "NO");
  
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input){
  input = input.split(' ');
  var r = input[0];
  var g = input[1];
  var b = input[2];
  var num = (r * 100) + (g * 10) +  b;
  if(num % 4 === 0){
    console.log('YES');
  }else{
    console.log('NO');
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
let [, g, b] = require("fs").readFileSync("/dev/stdin", "utf8").split(" ").map(Number);
console.log((g * 10 + b) % 4 == 0 ? "YES" : "No");
//  [javascript]
let [r, g, b] = require("fs").readFileSync("/dev/stdin", "utf8").split(" ");
console.log(Number(r + g + b) % 4 == 0 ? "YES" : "No");
//  [go]
package main

import "fmt"

func main() {
	var r, g, b int
	fmt.Scan(&r, &g, &b)

	ans := r * 100 + g * 10 + b
	if ans % 4 == 0 {
		fmt.Println("YES")
		return
	}
	fmt.Println("NO")
}
//  [go]
package main

import "fmt"

func main() {
	var r, g, b int
	fmt.Scan(&r, &g, &b)
	if (100*r+10*g+b)%4 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var r, g, b int
	fmt.Scan(&r, &g, &b)

	if (100*4+10*g+b)/4 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var r, g, b int
	fmt.Scan(&r, &g, &b)
	rgb := r*100 + b*10 + g
	if rgb%4 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}

}
//  [ruby]
r, g, b = gets.chomp.split(" ").map{|i| i.to_s}
if (r+g+b).to_i % 4 == 0
  puts "YES"
else
  puts "NO"
end
//  [ruby]
puts gets.split(' ').join.to_i % 4 == 0 ? 'YES' : 'NO'
//  [ruby]
io = STDIN
r,b,g=io.gets.chomp.split.map(&:to_i)
if (r*100+b*10+g)%4 == 0
  puts 'YES'
else
  puts 'NO'
end
//  [ruby]
cols = gets.chomp.split(' ').map(&:to_i).sort
if (cols[1].to_s + cols[2].to_s).to_i % 4 == 0
  puts "YES"
else
  puts "NO"
end
//  [ruby]
rgb = gets.to_i

if rgb % 4 == 0
  print "YES"
else
  print "NO"
end
//  [ruby]
input = gets.chomp.split.chars.join.to_i

if input % 4 == 0
  puts "YES"
else
  puts "NO"
end
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input!{
        r: u32,
        g: u32,
        b: u32,
    };
    println!("{}", if (g * 10 + b) % 4 == 0 {"YES"} else {"NO"});
}
//  [rust]
use std::io;

fn procon_read<T: std::str::FromStr>() ->  Vec<T> {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let iter = buf.split_whitespace();
	let mut v: Vec<T> = Vec::new();
	for i in iter {
		v.push(i.parse().ok().unwrap());
	}
	v
}

fn main() {
	let v:Vec<i32> = procon_read();
	let r = v[0];
	let g = v[1];
	let b = v[2];
	let s = format!("{}{}{}", r, g, b);
	let i : i32 = s.parse().ok().unwrap();
	if i%4 == 0 {
		println!("YES");
	}else{
		println!("NO");
	}
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
        r: u32,
        g: u32,
        b: u32,
    }
    if (100*r + 10*g + b) % 4 == 0 {
        println!("YES");
    } else {
        println!("NO");
    }
}
//  [rust]
use proconio::input;
fn main (){
let mut _a: i128;
let mut _b: i128;
let mut _c: i128;


input! {
    _a: i128,
    b: i128,
    c: i128,

}
 

let x = (b*10) + c ;



if x % 4 == 0  {
    println!("Yes");
}else {
    println!("No");


}
 
}
//  [rust]
use proconio::input;
fn main (){
let mut _a: i128;
let mut _b: i128;
let mut _c: i128;


input! {
    a: i128,
    b: i128,
    c: i128,

}
 

let x = (b*10) + c ;



if x % 4 == 0  {
    println!("Yes");
}else {
    println!("No");


}
 
}
//  [rust]
use proconio::{input, fastout};

#[fastout]
fn main() {
    input! {
        n: usize,
        an: [usize; n]
    };

    println!("{}", an.iter().max().unwrap() - an.iter().min().unwrap());
}
//  [swift]
print(Int(readLine()!.characters.split(" ").map{String($0)}.joinWithSeparator(""))!%4>0 ?"NO":"YES")
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!};print((i[1]*10+i[2])%4>0 ?"NO":"YES")
//  [swift]
print(Int(readLine()!.characters.split(" ").joinWithSeparator(""))!%4>0 ?"NO":"YES")
//  [swift]
print(Int(readLine()!.characters.split(" ").joinWithSeparator())!%4>0 ?"NO":"YES")
//  [swift]
print(Int(readLine.characters.split(" ").joinWithSeparator())!%4>0 ?"NO":"YES")
//  [typescript]
import * as fs from 'fs';

const [r, g, b]: string[] = fs.readFileSync('/dev/stdin', 'utf8').trim().split(' ');
const num: number = parseInt(r + g + b, 10);
const ans: string = (num % 4 === 0) ? 'YES' : 'NO';
console.log(ans);
//  [typescript]
const log = console.log;

function Main(input: string): void {
  const num = parseInt(input.replace(/\s/g, ""));

  log((num & 0b11) === 0 ? "YES" : "NO");
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
var input: string = require('fs').readFileSync('/dev/stdin', 'utf8');
var inputLines: string[] = input.trim().split("\n");
var parts = inputLines[0].split(" ");

var threeDigit = parseInt(parts[0] + parts[1] + parts[2]);
console.log(threeDigit % 4 == 0 ? "YES" : "NO");
//  [typescript]
function Main(input) {
    input = input.split('\n');
    var num = Number(input[0].split(' ').join(''))
    console.log(num % 4 === 0 ? 'Yes' : 'No');
    
}
 
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const r = parseInt(input[0], 10);
  const g = parseInt(input[1], 10);
  const b = parseInt(input[2], 10);
  
  if (r+g+b%4==0){
    console.log("YES");
  }else{
    console.log("NO");
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const r = parseInt(input[0], 10);
  const g = parseInt(input[1], 10);
  const b = parseInt(input[2], 10);
  
  if (r*100+g*10+b%4==0){
    console.log("YES");
  }else{
    console.log("NO");
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
s = input()
print(700+100*s.count('o'))
//  [python]
s=input()
print(700+100*s.count('o'))
//  [python]
print(700+input().count('o')*100)
//  [python]
a_price,b_price,ab_price,num_a,num_b = map(int, input().split())
total = 0

if a_price + b_price < 2 * ab_price:
	total = a_price * num_a + b_price * num_b

elif a_price + b_price >= 2 * ab_price:
	if num_a >= num_b:
		if a_price > ab_price * 2:
			total = ab_price * 2 * num_a
		else:
			total = ab_price * 2 * num_b + a_price * (num_a - num_b)
	else:
		if b_price > ab_price * 2:
			total = ab_price * 2 * num_b
		else:
			total = ab_price * 2 * num_a + b_price * (num_b - num_a)

print(total)
//  [python]
S = input()
price = 700 + 100*s.count('o')
print(price)
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    private static final BufferedReader input = new BufferedReader(new InputStreamReader(System.in));

    public static void main(String[] args) {
        String str = readLineStandardInput();
        char[] S = str.toCharArray();
        int y = 700;
        for(char s: S){
            if(s == 'o'){
                y += 100;
            }
        }
        System.out.println(y);
    }

    private static String readLineStandardInput() {
        String str;
        try {
            str = input.readLine();
        } catch(IOException e){
            str = null;
            System.out.println(e);
        }
        return str;
    }
}
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.Random;

class Main {
	public static void main(String[] args) {
		new Main().run();
	}
	
	void run() {
		FastScanner sc=new FastScanner();
		PrintWriter pw=new PrintWriter(System.out);
		char[] cs=sc.next().toCharArray();
		int ans=700;
		for(char c:cs) if(c=='o')ans+=100;
		pw.println(ans);
		pw.close();
	}

	
	static void tr(Object... objects) {
		System.out.println(Arrays.deepToString(objects));
	}

}


class FastScanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;
    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        }else{
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }
    private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
    private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
    public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
    public String next() {
        if (!hasNext()) throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while(isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    public int nextInt() {
    	return Integer.parseInt(next());
    }
    
    public long nextLong() {
    	return Long.parseLong(next());
    }
}
//  [java]
import java.util.*;

public class Main {

	public static  void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String S = sc.next();
		int count = 0;
		int y = 700;
		for(int i = 0; i < 3; i++)
		{
			if(S == "o") 
			{
				count ++;
			}
			else if(S == "x")
			{
				
			}
		}
		y = y + (100 * count);
		System.out.println(y);
	}

}
//  [java]
import java.io.IOException;
import java.util.Scanner;

public class HalfAndHalf {
    public static void main(String[] Arguments) throws IOException 
    {
        Scanner sc = new Scanner(System.in);
        long A = sc.nextInt(), B = sc.nextInt(), C = sc.nextInt(), X = sc.nextInt(), Y = sc.nextInt();
        
        // Cost of Buying A and B Pizzas separately:
        long costAB = A * X + B * Y;
        
        // Common Number of A and B Pizzas
        long Same = Math.min(X, Y);
        X = X - Same; 
        Y = Y - Same;
        long costCombine = Same * 2 * C + A * X + B * Y;
        long totalCost = Same * 2 * C + Math.max(X, Y) * 2 * C;
        
        // Is it better to buy A and B Pizzas Seperately, or should he use AB Pizzas?
        long Best = Math.min(costAB, costCombine);
        Best = Math.min(Best, totalCost);
        System.out.println(Best);
    }
}
//  [java]
public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    String s = sc.next();
    int total = 0;
    total += 700;
    for(int i = 0; i<3; i++){
      if(s.charAt(i) == 'o'){
        total += 100; 
      }
    }
    System.out.println(total);
  }
}
//  [cpp]
#include<stdio.h>
int main() {
    int ans = 700;
    char a[4];
    scanf("%s", a);
    int i;
    for (i = 0; i < 3; i++)
    {
        if (a[i] == 'o')
            ans += 100;
    }
    printf("%d\n", ans);
    return 0;
}
//  [cpp]
#include <stdio.h>

int main(void)
{
	char a[4]={0}, c=0;
	
	scanf("%s" ,&a[1]);
	
	for(int i=1; i<=3; i++)
		if(a[i]=='o') c++;
	
	printf("%d\n" ,700+c*100);
	return 0;
}
//  [cpp]
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<string>
#include<cstring>
using namespace std;

int main()
{
	char a[3];
	int ans = 0;
	scanf("%c%c%c",&a[0],&a[1],&a[2]);
	for(int i = 0; i < 3; i++) {
		if(a[i] == 'o') ans++;
	}
	printf("%d\n", 700 + ans*100);
}
//  [cpp]
#include <iostream>
#include <cmath>
#include <iomanip>

using namespace std;

int main() {
	string s;
	cin >> s;
	int t = 0;
	if (s[0] == '◦') t += 100;
	if (s[1] == '◦') t += 100;
	if (s[2] == '◦') t += 100;
	cout << 700 + t << endl;
	return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define All(a) (a).begin(),(a).end()

int main(){ 
  int a,b,c,x,y;
  ll ans=0;
  cin >> a>> b>>c>>x>>y;
  if(a+b<2*c){
    cout<<a*x+b*y<<endl;
    return 0;
  }else{
    int tmp=min(x,y);
    x-=tmp;y-=tmp;
    ans+=c*tmp*2;

    if(x>0 && a>2*c){
      ans+=x*c*2;
      x=0;
    }else if(y>0 && b>2*c){
      ans+=y*c*2;
      y=0;
    }else{
      ans+=a*x+b*y;
    }
    cout << ans <<endl;
  }

  return 0;
}