jiahuimbzuai/CoQuIR huggingface dataset:
//  [cpp]
#include <stdio.h>

int main(void) {

int n;
 scanf("%d",&n);
 if(0<=n && n<1200){
  puts("ABC");
 }else{
  puts("ARC");
 }
	return 0;
}
//  [cpp]
#include<cstdio>

int main(){
	int x;
	scanf("%d",&x);
	if(x<1200) printf("ABC\n");
	else printf("ARC\n");
	return 0;
}
//  [cpp]
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i,0,n)
#define BFOR(bit,a,b) for(int bit = (a); bit < (1<<(b)); ++bit)
#define BREP(bit,n) BFOR(bit,0,n)
using namespace std;
using ll = long long;

int main() {
  ll x;
  cin >> x;
  ll ans = 0;
  
  ll n = x / 11;
  ans += n*2;
  x -= n*11;
  
  if(x == 0){}
  else if(x <= 6){ans += 1;}
  else{ans += 2;}
  
  
  cout << ans << endl;
    

}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
int main()
{
	int n;
	cin>>n;
	if(n<=1200)
	{
		cout<<"ABC";
	}
	else
	{
		cout<<"ARC";
	}
	return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
int main()
{
    int x;
    cin>>x;
    if(x<=1200)
    cout<<"ABC"<<endl;
    else
    cout<<"ARC"<<endl;
    return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main() {

    int x;
    scanf("%d", &x);

    puts(x<1200 ?"ABC":"ARC");
    return 0;

}
//  [c]
main(n){scanf("%d",&n);printf("A%cC\n",(n<1200?'B':'R'));}
//  [c]
#include <stdio.h>

int main(){
	int x;
	scanf("%d",&x);
	if(x<1200){
		printf("ABC\n");
	}else{
		printf("ARC\n");
	}
	
	return 0;
}
//  [c]
#include <stdio.h>

int main () {
	int x;
	scanf("%d", &x);
	if (x > 1200) {
		puts("ARC");
	}
	else {
		puts("ABC");
	}
	return 0;
}
//  [c]
#include<stdio.h>
int sum(int a){
  if(a<1200)
    return "ABC";
  else
    return "ARC";
}
int main(){
  int a;
  scnaf("%d",&a);
  printf("%s",sum(a));
  return 0;
}
//  [javascript]
'use strict'
const main = arg => {
	const input = arg.trim().split("\n");
	let N = Number(input[0].split(' ')[0])
	console.log(N >= 1200 ? 'ARC' : 'ABC')
}   
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
'use strict'

function main(arg) {
  if (1200 <= arg) {
    console.log('ARC');
  } else {
    console.log('ABC');
  }
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(a){
	(1200<=(a = stn(a.split(" "))))?console.log("ARC"):console.log("ABC");
	
}
function stn(a){
		return a.map(function(x){return parseInt(x,10);});
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
  input = input.trim();
  const a = input.split('');
  console.log(a<1200?'ABC':'ARC');
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  input = input.trim()
if(input>=1200){
console.log("ARC")
}else{
  console.log("ABC")
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
const main =(standardInput) =>{
  const s = standardInput;
  var start=0,end=0,i=0;
  while(s[i]){
    if(s[i]=='A' && start ==0){
    start=i;
    }else if(s[i]=='Z'){
    end=i;
    }
    i++;
  }
  var out;
  for(i= start;i<end;i++){
  out=s.slice(start,end+1);
  }
  console.log(out);
  
}
main(require('fs').readFileSync('/dev/stdin', 'UTF-8'));
//  [go]
package main

import (
	"fmt"
)

func main() {
	var x int

	fmt.Scan(&x)
	if x < 1200 {
		fmt.Println("ABC")
	} else {
		fmt.Println("ARC")
	}
}
//  [go]
package main

import "fmt"

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

	if x < 1200 {
		fmt.Println("ABC")
	} else {
		fmt.Println("ARC")
	}
}
//  [go]
package main

import (
  "fmt"
)

func main() {
  var x int; fmt.Scan(&x)
  var ans string = "ABC"
  if x >= 1200 {ans = "ARC"}
  fmt.Println(ans)
}
//  [go]
package main

import "fmt"

func main() {
	var (
		x int
	)

	fmt.Scan(&x)

	if x < 1200 {
		fmt.Print("ABC")
	} else if x > 1200 {
		fmt.Print("ARC")
	} else {
		fmt.Print("error")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var (
		x int
	)

	fmt.Scan(&x)

	if x < 1200 {
		fmt.Print("ABc")
	} else if x > 1200 {
		fmt.Print("ARC")
	} else {
		fmt.Print("error")
	}
}
//  [go]
package main

import (
	"fmt"
)

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

	if x < 1200 {
		println("ABC")
	} else {
		println("ARC")
	}
}
//  [ruby]
puts gets.to_i < 1200 ? "ABC" : "ARC"
//  [ruby]
puts gets.to_i < 1200 ? 'ABC' : 'ARC'
//  [ruby]
if gets.to_i < 1200
  puts "ABC"
else
  puts "ARC"
end
//  [ruby]
p 1200>gets.to_i ? "ABC" : "ARC"
//  [ruby]
puts 1200<gets.to_i ? "ABC" : "ARC"
//  [ruby]
gets.to_i < 1200 ? "ABC" : "ARC"
//  [rust]
fn read1<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn main() {
    let x = read1::<usize>();
    if x < 1200 {
        println!("ABC");
    } else {
        println!("ARC");
    }
}
//  [rust]
use std::cmp::*;
use std::io::*;
use std::num::*;
use std::str::*;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let s = stdin
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok().unwrap()
}

fn string() -> String {
    read()
}

fn int() -> i64 {
    read()
}

fn char() -> char {
    read::<String>().pop().unwrap()
}

fn vecchar() -> Vec<char> {
    string().chars().collect()
}

fn vecint(n: i64) -> Vec<i64> {
    let mut vec = Vec::new();
    for i in 0..n {
        vec.push(int())
    }
    vec
}

fn main() {
    let x = int();
    println!("{}", if x < 1200 {"ABC"} else {"ARC"})
}
//  [rust]
use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let x: i64 = read();

    if x < 1200 {
        println!("ABC");
    } else {
        println!("ARC");
    }
}
//  [rust]
use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}
fn main() {
    let s = read::<String>().chars().collect::<Vec<char>>();
    let mut idx_a = 0;
    let mut idx_z = 0;
    for j in 0..s.len() {
        if s[j] == 'A' {
            idx_a = j;
            break;
        }
    }
    for j in (0..s.len()).rev() {
        if s[j] == 'Z' {
            idx_z = j;
            break;
        }
    }
    println!("{}", idx_z - idx_a + 1);
}
//  [rust]
// Template from https://techracho.bpsinc.jp/jhonda/2019_08_05/78537

// input macro for competive-programming from https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

#[allow(unused_macros)]
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)*}
    };

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

#[allow(unused_macros)]
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<_>>()
    };

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

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

    ($iter:expr, bytes) => {
        read_value!($iter, String).into_bytes()
    };

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

fn main() {
    use std::io::Read;
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();

    println!("{}", solve(&s));
}

macro_rules! test {
    ($($input:expr => $output:expr),* $(,)*) => {
        #[test]
        fn solve_test() {
            $(
                assert_eq!(solve($input), $output);
            )*
        }
    };
}

test! {
// r#","# => r#" "#,
}

fn solve(src: &str) -> String {
    input! {
        source = src,
        x: usize,
    }

    if x >= {
        "ARC"
    } else {
        "ABC"
    }.to_string()
}
//  [rust]

use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
  let stdin = stdin();
  let stdin = stdin.lock();
  let token: String = stdin
    .bytes()
    .map(|c| c.expect("failed to read char") as char)
    .skip_while(|c| c.is_whitespace())
    .take_while(|c| !c.is_whitespace())
    .collect();
  token.parse().ok().expect("failed to parse token")
}

use std::cmp::{max, min};
use std::collections::HashMap;

fn main() {
  let mut a = read::<i64>();

  println!("{}", if 0 < x && x < 1200 { "ABC" } else {"ARC"});
}
//  [swift]
print(Int(readLine()!)!<1200 ?"ABC":"ARC")
//  [swift]
let n = Int(readLine() ?? "0") ?? 0
if n < 1200 {
  print("ABC")
} else {
  print("ARC")
}
//  [swift]
if let x = Int32(readLine()!) {
    if (x < 1200) {
        print("ABC")
    } else {
        print("ARC")
    }
}
//  [swift]
import Foundation
let line = Array(readLine()!)
let aIndex = line.index(of: "a")!
let zIndex = line.index(of: "z")!
print(zIndex - aIndex)
//  [typescript]
var input: string = require('fs').readFileSync('/dev/stdin', 'utf8');
var inputLines: string[] = input.trim().split("\n");
var parts = inputLines[0].split(" ");

var x = parseInt(parts[0]);
console.log(x < 1200 ? "ABC" : "ARC");
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const x = parseInt(input[0], 10);
  
  if (1200>x) {
    console.log('ABC');
  }else{
    console.log('ARC');
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const x = stdin.split('\n')[0]
const r = Number(x)

console.log(r < 1200 ? 'ABC' : 'ARC')
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const x = parseInt(input[0], 10);
  
  if (1200>x) {
    console.log('ABC');
  }else{
    console.log('ARC');
  }
}
//  [python]
import math
R = (int(input()))

print(2*R*math.pi)
//  [python]
pi = 3.1415
r = int(input())
print(2*r*pi)
//  [python]
import math
R = int(input())
a = math.pi
print(2 * R * a)
//  [python]
r=input()
print(2*3.14*r)
//  [python]
N, M = map(int, input().split())

data = list(map(int, input().split()))

if N - sum(data) >= 0:
    print(N-sum(data))
else:
    print(-1)
//  [python]
N, M = map(int, input().split())
data = list(map(int, input().split()))

if N - sum(data) < 0:
    print(-1)
else:
    print(N - sum(data))
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;

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 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() {
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
        return (int) nl;
    }
    public double nextDouble() { return Double.parseDouble(next());}
}

public class Main {

	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ
		FastScanner fs = new FastScanner();
		int R = fs.nextInt();

		double x = R * 2.0 * Math.PI;

		System.out.println(x);
	}

}
//  [java]
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        MyScanner in = new MyScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        A solver = new A();
        solver.solve(1, in, out);
        out.close();
    }

    static class A {
        public void solve(int testNumber, MyScanner in, PrintWriter out) {
            int R = in.Int();
            out.println(R * 2 * Math.PI);
        }

    }

    static class MyScanner {
        private BufferedReader in;
        private StringTokenizer st;

        public MyScanner(InputStream stream) {
            in = new BufferedReader(new InputStreamReader(stream));
        }

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

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

    }
}
//  [java]
import java.util.Scanner;
public class Main
{
  public static void main(String[] args)
  {
    Scanner sc = new Scanner(System.in);
    int R = sc.nextInt();
    int result = 2 * 3.141592653589793238 * R;
    System.out.println(result);
  }
}
//  [java]
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println(Math.PI * sc.nextDouble());
    }
}
//  [java]
import java.util.*;
 
public class Main{
  public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N =sc.nextInt();
		int M = sc.nextInt();
		int total = 0;
		for(int i = 0;i < M;i++) {
			int x = sc.nextInt();
			total += x;
		}
		if(N - total < -1) {
			System.out.print("-1");
		}else {
			System.out.print(N - total);
		}
	}
}
//  [cpp]
#include<cstdio>
using namespace std;
int main()
{
	double r;
	scanf("%lf",&r);
	printf("%.4lf\n",r*2.0*3.1415926);
	return 0;
}
//  [cpp]
#include<cstdio>

int main(){
    float x;
    scanf("%f", &x);
    x *= 2*3.14159265;
    printf("%f", x);
    return 0;
}
//  [cpp]
#include<stdio.h>
int main()
{

       float r,p=3.1416;
     scanf("%f",&r);
     printf("%lf",2*p*r);
}
//  [cpp]
#include <bits/stdc++.h>

using namespace std;
const double pi= 3.14159265;

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int r;cin>>r;

    cout<< pi * r *r<<'\n';

}
//  [cpp]
#include <iostream>
using namespace std;
 
#define PI 3.14159265358979
int main(){
  long double r;
  cout<<2*PI*r<<endl;
}
//  [cpp]
#include <iostream>
using namespace std;

int main(){
  long double r;
  cout<<2*M_PI*r<<endl;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>


int main() {
        double R;

        scanf("%lf", &R);

        printf("%lf\n", R * 2 * M_PI);

        return 0;
}
//  [c]
#include<stdio.h>
#include<math.h>
int main()
{
	double r;
	scanf("%lf", &r);
	printf("%.20lf\n", 2 * acos(-1) * r);
	return 0;
}
//  [c]
#include <stdio.h>

#define PAI 3.14

int main()
{
	int r;

	scanf("%d", &r);
	r *= 2;

	printf("%f\n", r * PAI);

	return 0;
}
//  [c]
#include<stdio.h>

int main (void)
{
	double r;
  	double s;
  	r=scanf("%lf",&r);
  	s=r*2*3.1415926535897931;
  	printf("%f\n",s);
  	return 0;
}
//  [c]
#include<stdio.h>

int main (void)
{
	double r;
  	double s;
  	r=scanf("%lf",&r);
  	printf("%f\n",r);
  	s=r*2*3.1415926535897931;
  	printf("%f\n",s);
  	return 0;
}
//  [c]
#include<stdio.h>
#include<math.h>

int main(void){
  int a;
  scanf("%d",&a);
  printf("%d\n",2*M_PI*a);
  return 0;
}
//  [javascript]
const calc_circum = (r) => {console.log(2*r*Math.PI)}
calc_circum(require('fs').readFileSync("/dev/stdin","utf8"))
//  [javascript]
const main = (inputs) => {
  console.log(calculateCircumference(inputs[0] - 0));
}
main(require('fs').readFileSync('/dev/stdin', 'UTF-8').trim().split("\n"));

function calculateCircumference(radius) {
  return 2 * Math.PI * radius;
}
//  [javascript]
function Main(input) {
    var a = input[0]-0;
    console.log(a*2*Math.PI);

}



Main(require("fs").readFileSync("/dev/stdin", "utf8").trim().split("\n"));
//  [javascript]
/**
 * @param {String} raw_input 入力
 */
function Main(raw_input) {
	const [ first, ...trail ] = raw_input.split("\n");

	const PI = 31415926535897932384626433832795028841971693993751058209749445923078164n;
	const DV = 10000000000000000000000000000000000000000000000000000000000000000000000n;
	const r = first;

	console.log(PI * r * r / DV);
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));

////////// ユーティリティ関数

/**
 * 文字列を数値配列
 * @param {String} str 文字列
 */
function toNumArray(str, delimitor = ' ') {
	return str.split(delimitor).map(s => parseInt(s, 10));
}

/**
 * 文字列をVigInt配列に変換する
 * @param {String} str 文字列
 */
function toBitIntArray(str, delimitor = ' ') {
	return str.split(delimitor).map(s => BigInt(s));
}
//  [javascript]
/**
 * @param {String} raw_input 入力
 */
function Main(raw_input) {
	const [ first, ...trail ] = raw_input.split("\n");

	const PI = 3.1415926535897932384626433832795028841971693993751058209749445923078164;
	const r = first;


	console.log(PI * r * r);
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));

////////// ユーティリティ関数

/**
 * 文字列を数値配列
 * @param {String} str 文字列
 */
function toNumArray(str, delimitor = ' ') {
	return str.split(delimitor).map(s => parseInt(s, 10));
}

/**
 * 文字列をVigInt配列に変換する
 * @param {String} str 文字列
 */
function toBitIntArray(str, delimitor = ' ') {
	return str.split(delimitor).map(s => BigInt(s));
}
//  [javascript]
/**
 * @param {String} raw_input 入力
 */
function Main(raw_input) {
	const [ first, ...trail ] = raw_input.split("\n");
	tmp = input[1].split(" ");

	const PI = 3.1415926535897932384626433832795028841971693993751058209749445923078164;
	const r = first;


	console.log(PI * r * r);
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));

////////// ユーティリティ関数

/**
 * 文字列を数値配列
 * @param {String} str 文字列
 */
function toNumArray(str, delimitor = ' ') {
	return str.split(delimitor).map(s => parseInt(s, 10));
}

/**
 * 文字列をVigInt配列に変換する
 * @param {String} str 文字列
 */
function toBitIntArray(str, delimitor = ' ') {
	return str.split(delimitor).map(s => BigInt(s));
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

const initBufSize, maxBufSize = 10000, 1000000

func nextStr() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func nextInts(n int) []int {
	res := make([]int, n)
	for i := range res {
		res[i] = nextInt()
	}
	return res
}

func min(nums ...int) int {
	if len(nums) == 0 {
		panic("funciton min() requires at least one argument.")
	}
	res := nums[0]
	for i := 0; i < len(nums); i++ {
		res = int(math.Min(float64(res), float64(nums[i])))
	}
	return res
}

func max(nums ...int) int {
	if len(nums) == 0 {
		panic("funciton max() requires at least one argument.")
	}
	res := nums[0]
	for i := 0; i < len(nums); i++ {
		res = int(math.Max(float64(res), float64(nums[i])))
	}
	return res
}

func abs(n int) int {
	return int(math.Abs(float64(n)))
}

func pow(r, n int) int {
	return int(math.Pow(float64(r), float64(n)))
}

func main() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, initBufSize), maxBufSize)
	r := nextInt()
	fmt.Printf("%.20f\n", 2.0 * float64(r) * math.Pi)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var r float64
	fmt.Scan(&r)
	const pi float64 = 3.14159265358979
	fmt.Println(r * 2.0 * pi)
}
//  [go]
package main

import "fmt"

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


	pi :=3.14
	fmt.Println(2*n*pi)


}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"log"
	"math"
	"os"
	"strconv"
	"strings"
)

func out(x ...interface{}) {
	fmt.Println(x...)
}

var sc = bufio.NewScanner(os.Stdin)

func getInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		log.Fatal(e)
	}
	return i
}

func getString() string {
	sc.Scan()
	return sc.Text()
}

func asub(a, b int) int {
	if a > b {
		return a - b
	}
	return b - a
}

func main() {
	sc.Split(bufio.ScanWords)

	r := getInt()
	out(math.Pi * 2 * float64(r))
}
//  [go]
package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	z := make([]int, n-1)
	ans := make([]int, n)
	for i, _ := range z {
		fmt.Scan(&z[i])
		ans[z[i]-1]++
	}
	for _, v := range ans {
		fmt.Println(v)
	}
}
//  [go]
import (
	"fmt"
	"math"
)

func main()  {
	var a int
	fmt.Scan(&a)
	fmt.Println(a * 2 * math.Pi)
}
//  [ruby]
puts gets.to_i * 2 * Math::PI
//  [ruby]
def get_i() #空白区切の入力を数値(整数)の配列で返す
  return gets.chomp.split(" ").map(&:to_i)
end
def get_f() #空白区切の入力を数値(実数)の配列で返す
  return gets.chomp.split(" ").map(&:to_f)
end
def get() #空白区切の入力を文字列の配列で返す
  return gets.chomp.split(" ")
end
def get_nsp() #入力されたものを一文字ずつに区切った文字列の配列で返す
  return gets.chomp.split("")
end
def yn_judge(bool,y="Yes",n="No") #boolに真偽を投げることで、trueならy、falseならnの値を出力する
  return bool ? y : n 
end
def array(size1,init=nil,size2=-1) #size2に二次元配列時の最初の要素数、size1に次の配列の大きさ、initに初期値を投げることでその配列を返す
  if size2==-1
    return Array.new(size1){init}
  else
    return Array.new(size2){Array.new(size1){init}}
  end
end

puts 2*Math::PI*gets.to_i
//  [ruby]
p gets.to_i * Math::PI * 2
//  [ruby]
puts gets.to_i * 2 * Math::Pi
//  [ruby]
puts gets.to_i * Math: :pi * 2
//  [ruby]
R = gets.chomp.to_i
ensyuuritsu = Math::PI.to_i

puts R * R * ensyuuritsu
//  [rust]
#![allow(non_snake_case)]
#![allow(dead_code)]
#![allow(unused_macros)]
#![allow(unused_imports)]

use std::str::FromStr;
use std::io::*;
use std::collections::*;
use std::cmp::*;
use std::f64::consts;

struct Scanner<I: Iterator<Item = char>> {
    iter: std::iter::Peekable<I>,
}

macro_rules! exit {
    () => {{
        exit!(0)
    }};
    ($code:expr) => {{
        if cfg!(local) {
            writeln!(std::io::stderr(), "===== Terminated =====")
                .expect("failed printing to stderr");
        }
        std::process::exit($code);
    }}
}

impl<I: Iterator<Item = char>> Scanner<I> {
    pub fn new(iter: I) -> Scanner<I> {
        Scanner {
            iter: iter.peekable(),
        }
    }

    pub fn safe_get_token(&mut self) -> Option<String> {
        let token = self.iter
            .by_ref()
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect::<String>();
        if token.is_empty() {
            None
        } else {
            Some(token)
        }
    }

    pub fn token(&mut self) -> String {
        self.safe_get_token().unwrap_or_else(|| exit!())
    }

    pub fn get<T: FromStr>(&mut self) -> T {
        self.token().parse::<T>().unwrap_or_else(|_| exit!())
    }

    pub fn vec<T: FromStr>(&mut self, len: usize) -> Vec<T> {
        (0..len).map(|_| self.get()).collect()
    }

    pub fn mat<T: FromStr>(&mut self, row: usize, col: usize) -> Vec<Vec<T>> {
        (0..row).map(|_| self.vec(col)).collect()
    }

    pub fn char(&mut self) -> char {
        self.iter.next().unwrap_or_else(|| exit!())
    }

    pub fn chars(&mut self) -> Vec<char> {
        self.get::<String>().chars().collect()
    }

    pub fn mat_chars(&mut self, row: usize) -> Vec<Vec<char>> {
        (0..row).map(|_| self.chars()).collect()
    }

    pub fn line(&mut self) -> String {
        if self.peek().is_some() {
            self.iter
                .by_ref()
                .take_while(|&c| !(c == '\n' || c == '\r'))
                .collect::<String>()
        } else {
            exit!();
        }
    }

    pub fn peek(&mut self) -> Option<&char> {
        self.iter.peek()
    }
}

fn main() {
    let cin = stdin();
    let cin = cin.lock();
    let mut sc = Scanner::new(cin.bytes().map(|c| c.unwrap() as char));
    let R: f64 = sc.get();
    println!("{}", 2. * R * consts::PI);
}
//  [rust]
#[allow(unused_macros)]
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)*}
    };
}

#[allow(unused_macros)]
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)*}
    };

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

#[allow(unused_macros)]
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, bytes) => {
        read_value!($next, String).into_bytes()
    };

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

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

fn main() {
    input!{
        r: i32
    }
    println!("{}", 2.0*3.141592653589*(r as f64));

}
//  [rust]
// -*- coding:utf-8-unix -*-

use proconio::input;

fn main() {
    input! {
        n: u64,
    }

    let mut boss_cnt = vec![0; (n + 1) as usize];
    for i in 0..n - 1 {
        input! {
            a: usize,
        }
        boss_cnt[a] += 1;
    }

    for i in 1..n + 1 {
        println!("{}", boss_cnt[i as usize]);
    }
}
//  [rust]
// -*- coding:utf-8-unix -*-

use proconio::input;

fn main() {
    input! {
        n: u64,
    }

    let mut boss_cnt = vec![0; (n + 1) as usize];
    for i in 0..n - 1 {
        input! {
            a: usize,
        }

        boss_cnt[a] += 1;
    }

    for i in 1..n + 1 {
        println!("{}", boss_cnt[i as usize]);
    }
}
//  [rust]
use text_io::*;fn main() {let mut a:f64 = read!();println!("{}",a*3.1415926535897932);}
//  [swift]
let input = readLine()!
let a = Double(input)!
let length = a * 2 * Double.pi

print(length)
//  [swift]
protocol InitFromString {
    init?(_ str: String)
}

extension Int: InitFromString {}
extension Int8: InitFromString {}
extension Int16: InitFromString {}
extension Int32: InitFromString {}
extension Int64: InitFromString {}
extension Double: InitFromString {}
extension String: InitFromString {}

func input<T: InitFromString>() -> [T] {
    readLine()!.split(separator: " ").map(String.init).compactMap(T.init)
}

let a: [Double] = input()
let d = a[0]
print(Double.pi * d * 2)
//  [swift]
let r = Int(readLine()!)!

print(3.1415 * 2 * Float(r))
//  [swift]
// Circle Pond

func main() {
    let r = Float(readLine()!)!
    print(Float.pi * r)
}

main()
//  [swift]
// Circle Pond

func main() {
    let r = Int(readLine()!)!
    print(Float.pi * r)
}

main()
//  [swift]
let R = Int(readLine()!)!
print(R * 6.28)
//  [typescript]
"use strict";
const Main = (input) =>{
   let xs = input.trim().split(' ').map(v=>parseInt(v,10));
   let R = xs[0]*2;
   console.log(R*3.14);



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

const input = (fs.readFileSync('/dev/stdin', 'utf8') as string).split('\n')
const n = input[0]
const result = 2 * Math.PI * parseInt(n, 10)

console.log(result.toFixed(2))
//  [typescript]
import * as fs from 'fs';

// parameter "input" gets all data
function Main(input: string) {
    const r = parseInt(input);
    // const c = 2 * Math.PI * r;
    const c = 6.283185307179586 * r;

    //output
    console.log(c);
}

// Don't edit this line!
Main(fs.readFileSync("/dev/stdin", "utf8"));
//  [typescript]
import * as fs from 'fs';

// parameter "input" gets all data
function Main(input: string) {
    const lines = input.split('\n');
    const [n, m] = lines[0].split(' ').map(int => parseInt(int));
    const a = lines[1].split(' ').map(int => parseInt(int));

    let left = n;
    for (let i = 0; i < m; i++) {
        left -= a[i];
        if (left < 0) {
            left = -1;
            break;
        }
    }

    //output

    let result = left;
    console.log(result);
    return result;
}

// Don't edit this line!
Main(fs.readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
import * as fs from 'fs';

// parameter "input" gets all data
function Main(input: string) {
    const lines = input.split('\n');
    const [n, m] = lines[0].split(' ').map(int => parseInt(int));
    const a = lines[1].split(' ').map(int => parseInt(int));

    let sum = 0;
    for (let i = 0; i < m; i++) {
        sum += a[i];
    }

    //output
    console.log(n - sum >= 0 ? n - sum : -1);
}

// Don't edit this line!
Main(fs.readFileSync('/dev/stdin', 'utf8'));
//  [python]
A = list(map(int,input().split()))
A.sort()
if A == [5,5,7]:
    print("YES")
else:
    print("NO")
//  [python]
S = input()
if S == "5 5 7" or S == "5 7 5" or S == "7 5 5":
  print("YES")
else:
  print("NO")
//  [python]
a, b, c= map(int,input().split())

list = [a,b,c]

if(7 in list):
    if list.count(5)==2:
        print("YES")
    else:
        print("NO")
else:
    print("NO")
//  [python]
a, b, c = map(int, input().split())
iroha=[a,b,c]

if iroha.count(2)==5 and iroha.count(1)==7:
  print("YES")
else:
  prnt("NO")
//  [python]
queue=list(map(int,input().split()))
queue.sort()
if queue[0]==5 and queue[1]==5 and queue[2]==7:
  print("Yes")
else:
  print("No")
//  [java]

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		String s = br.readLine();
		String[] array = s.split(" ");

		int count1 = 0;
		int count2 = 0;
		for (int i = 0; i < 3; i++) {
			if (Integer.parseInt(array[i]) == 5) {
				count1 += 1;
			} else if (Integer.parseInt(array[i]) == 7) {
				count2 += 1;
			}
		}
		if (count1 == 2 && count2 == 1) {
			System.out.println("YES");
		} else {
			System.out.print("NO");
		}
	}
}
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main{
  public static void main(String [] args)throws Exception{

    BufferedReader br = new BufferedReader (new InputStreamReader(System.in));
    String [] inp = br.readLine().split(" ");
    int a = Integer.parseInt(inp[0]);
	int b = Integer.parseInt(inp[1]);
	int c = Integer.parseInt(inp[2]);
    if(a<5||a>7||b<5||b>7||c<5||c>7){
      System.out.println("NO");
    }else if((a+b+c)==17){
      if(a!=6 &&b!=6 && c!=6){
        System.out.println("YES");
      }else{
        System.out.println("NO");
      }
    }
  	else{
      System.out.println("NO");
    }

    
  }
}
//  [java]
import java.io.*;
import java.util.*;
class Main{
    public static void main(String[] args) throws Exception {
		hayami saori = new hayami();
		int[] num = new int[3];
		
		int five = 0;
		int seven = 0;
		for(int i = 0;i < num.length;i++){
			num[i] = saori.saori_hayami();
			if(num[i] == 5){
				five++;
			}
			if(num[i] == 7){
				seven++;
			}
		}
		if(five == 2 && seven == 1){
			System.out.println("YES");
		} else {
			System.out.println("NO");
		}
		
    }
}

class hayami implements Closeable {
	private final InputStream in = System.in;
	private final byte[] hayami = new byte[1024];
	private int Hayami = 0;
	private int saori = 0;
	private boolean HayamiSaori() {
		if (Hayami < saori) {
			return true;
		}else{
			Hayami = 0;
			try {
				saori = in.read(hayami);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (saori <= 0) {
				return false;
			}
		}
		return true;
	}
	private int SaoriHayami() { 
		if (HayamiSaori()) {
            return hayami[Hayami++];
         }else{
             return -1;
         }
	}
	private static boolean hayami_saori(int hayami) { 
		return 33 <= hayami && hayami <= 126;
	}
	public boolean hayamisaori() { 
		while(HayamiSaori() && !hayami_saori(hayami[Hayami])) Hayami++; return HayamiSaori();
	}
	public String nextHayami() {
		if (!hayamisaori()) throw new NoSuchElementException();
		StringBuilder hayamin = new StringBuilder();
		int saori = SaoriHayami();
		while(hayami_saori(saori)) {
			hayamin.appendCodePoint(saori);
			saori = SaoriHayami();
		}
		return hayamin.toString();
	}
	public long saorihayami() {//nextLong
		if (!hayamisaori()) throw new NoSuchElementException();
		long hayami = 0;
		boolean misao = false;
		int saori = SaoriHayami();
		if (saori == '-') {
			misao = true;
			saori = SaoriHayami();
		}
		if (saori < '0' || '9' < saori) {
			throw new NumberFormatException();
		}
		while(true){
			if ('0' <= saori && saori <= '9') {
				hayami *= 10;
				hayami += saori - '0';
			}else if(saori == -1 || !hayami_saori(saori)){
				return misao ? -hayami : hayami;
			}else{
				throw new NumberFormatException();
			}
			saori = SaoriHayami();
		}
	}
	public int saori_hayami() {//nextInt
		long hayami = saorihayami();
		if (hayami < Integer.MIN_VALUE || hayami > Integer.MAX_VALUE) throw new NumberFormatException();
		return (int) hayami;
	}
	public double Hayamin() { //nextDouble
		return Double.parseDouble(nextHayami());
	}
	public void close() {
		try {
			in.close();
		} catch (IOException e) {
		}
    }
    
}
//  [java]
Scanner input = new Scanner (System.in);
		int A,B,C;
		A = input.nextInt();
		B = input.nextInt();
		C = input.nextInt();
	if ((A==5&&B==5&& C== 7)|| (A==5&&B==7&& C== 5) || (A==7&&B==5&& C== 5) )
 { System.out.println("YES");}		
		else { System.out.println("NO");}

				
	}

}
//  [java]
pbulic boolean canMake575(String str){
	String[] strArray = str.split(" ");
	int countFive = 0;
	int countSeven = 0;
  	for (int i = 0; i < strArray.length, i++) {
		if (strArray.equals("5")) {
          	countFive++;
        } else if (strArray.equals("7")) {
          	countSeven++;
        }
    }

	if (countFive == 2 && countSeven == 1) {
    	return true;
    }
  	return false;
}
//  [cpp]
#include<stdio.h>
int main(void){
	int A,B,C;
	scanf("%d %d %d",&A,&B,&C);
	if (A == 7){
		if (B == C && B == 5){
			printf("YES\n");
		}
		else{
			printf("NO\n");
		}
	}
	else if (B == 7){
		if (A == C && C == 5){
			printf("YES\n");
		}
		else{
			printf("NO\n");
		}
	}
	else if (C == 7){
		if (B == A && A == 5){
			printf("YES\n");
		}
		else{
			printf("NO\n");
		}
	}
	return 0;
}
//  [cpp]
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<string>
#include<math.h>
#include<stdlib.h>
#include<time.h>
#include<map>
#include<queue>
#include<set>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)
using namespace std;
int f[20],x;
int main(){
	fo(i,1,3){
		scanf("%d",&x);
		f[x]++;
	}
	if (f[5]==2&&f[7]==1) printf("YES\n");else printf("NO\n");
	return 0;
}
//  [cpp]
#include<stdio.h>
int main()
{
    int a,b,c;
    scanf("%d%d%d",&a,&b,&c);
    if((a==5 && b==5 && c==7)||(a==5 && b==7 && c==5)||(a==7 && b==5 && c==5)){

          printf("YES\n");
    }

    else{
          printf("NO\n");
    }
}
//  [cpp]
#include<bits/stdc++.h>
#define ll long long int
using namespace std;
int main(){
	int a[3];
  int x=0,y=0;
  for(int i=0;i<3;i++){
    if(a[i]==5)
      x++;
    else if(a[i]==7)
      y++;
  }
  if(x==2 && y==1){
    cout<<"YES\n";
  }
else{
  cout<<"NO\n";
}
	return 0;
}
//  [cpp]
#include<bits/stdc++.h>
#define ll long long int
using namespace std;
int main(){
	int a[3];
  int x=0,y=0;
  for(int i=0;i<3;i++){
    if(a[i]==5)
      x++;
    else
      y++;
  }
  if(x==2){
    cout<<"YES\n";
  }
else{
  cout<<"NO\n";
}
	return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn = 1 + 1e5;
const ll mod = 1e9 + 7;

typedef pair<int,int> II;

int h, w, a, b, dp[maxn];
ll gt[2 * maxn + 100], igt[2 * maxn + 100];
ll ans;

ll C(int n, int k) {
	return ((gt[n] * igt[k]) % mod * igt[n - k]) % mod;
}

ll Pow (int i, int j) {
	if (j == 0) return 1;
	if (j % 2) {
		return (i * Pow (i, j - 1)) % mod;
	}
	ll val = Pow (i, j / 2);
  return (val * val) % mod;
}

void calc () {
	gt[0] = 1;
	for (int i = 1; i <= 2 * maxn; ++i) {
		gt[i] = (gt[i - 1] * i) % mod;
	}
	igt[2 * maxn] = Pow (gt[2 * maxn], mod - 2);
  for (int i = 2 * maxn - 1; i >= 0; --i) {
    igt[i] = (igt[i + 1] * (i + 1) + mod) % mod;
  }
}

int main()
{
	#ifndef ONLINE_JUDGE
	freopen("abc.inp","r",stdin);freopen("abc.out","w",stdout);
//	freopen("abc.inp","r",stdin);freopen("abc.out","w",stdout);
	#endif //ONLINE_JUDGE
	ios_base::sync_with_stdio(0);
	cin.tie();
	cout.tie();
	calc();

	cin >> h >> w >> a >> b;
	int _a = h - a, _b = w - b;
	for (int i = 0; i < _b; ++i)
		dp[i] = C(_a + b + i - 1, _a - 1);
	for (int i = 0; i < _b; ++i) {
		ans += (C (a + i - 1, i) * dp[_b - i - 1] ) % mod;
		ans %= mod;
//		cout << C (a + i - 1, i) << " " << dp[_b - i - 1] << '\n';
	}
	cout << ans;
   return 0;
}
//  [c]
#include<stdio.h>
#include<stdlib.h>
int main(){
       int five=0,seven=0,n;
       for(int i=0;i<3;i++){
              scanf("%d",&n);
              if(n==5) five++;
              if(n==7) seven++;
       }
       if(five==2&&seven==1) printf("YES");
       else printf("NO");
       return 0;
}
//  [c]
#include <stdio.h>

int main(void) {
	int a, b, c;
	scanf("%d", &a);
	scanf("%d", &b);
	scanf("%d", &c);
	
	if (a+b+c ==17) {
		if (a == 5) {
			if (b == 5 && c == 7 || b == 7 && c == 5) {
				printf("YES\n");
			} else {
				printf("NO\n");
			}
		} else if (a == 7) {
				if (b==5&&c==5) {
					printf("YES\n");
				} else { 
					printf("NO\n"); 
				}
		}
	} else {
		printf("NO\n");
	}


	return 0;
}
//  [c]
#include <stdio.h>

int ok(int a, int b, int c) {
	return a == 5 && b == 7 && c == 5;
}

int main() {
	int a, b, c;

	scanf("%d%d%d", &a, &b, &c);
	printf("%s\n", ok(a, b, c) || ok(a, c, b) || ok(b, a, c) || ok(b, c, a) || ok(c, a, b) || ok(c, b, a) ? "YES" : "NO");
	return 0;
}
//  [c]
#include<stdio.h>

int main(void){
  int a, b, c;
  scanf("%d %d %d", &a, &b, &c);
  if((a == 5 && ((a == b && c == 7) || (a == c && b == 7))) || (b == 5 && b == c && a == 7)){
    printf("YES/n");
  }else{
    printf("NO/n");
  }
  return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    int a,b,c
    while(scanf("%d%d%d",&a,&b,&c)==3)
    {
        if(a==5&&b==5&&c==7)
            printf("YES\n");
        else if(a==5&&b==7&&c==5)
            printf("YES\n");
        else if(a==7&&b==5&&c==5)
            printf("YES\n");
        else
            printf("NO\n");
    }
    return 0;
}
//  [c]
#include<stdio.h>
int main(){
    int a[3],i,cnt=0,s=0;
    for(i=0;i<3;i++){
        scanf("%d",&a[i]);
    }
    for(i=0;i<3;i++){
        if(a[i]==5){
            cnt++;
        }
        if(a[i]==7){
            s++;
        }
    }
    if(cnt==2 && s==1){
        printf("Yes\n");
    }
    else{
        printf("No\n");
    }
    return 0;
}
//  [javascript]
function main(input) {
    const nums = input.split(" ");
    var count5 = 0, count7 = 0;
    
    nums.forEach( num => {
        if(num == 5) {
            count5 += 1;
        }
        if(num == 7) {
            count7 += 1;
        }
    })
    console.log(count5 === 2 && count7 === 1 ? "YES" : "NO");
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(n) {
  console.log((n=="5 5 7"||n=="5 7 5"||n=="7 5 5")?"YES":"NO")
}Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
	input = input.split(" ");
	//文字列から10進数に変換するときはparseIntを使います
	var a = parseInt(input[0], 10);
	var b = parseInt(input[1], 10);
	var c = parseInt(input[2], 10);
    var total = a + b + c;
	//出力
  if (a > 4 && b > 4 && c > 4 && total === 17) {
	console.log('YES');
  }else {
	console.log('NO');
  }
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
  input = input.trim();
  const a = input.split(' ').map(Number);
  console.log(a[0]*a[1]*a[2]==175?'Yes':'No');
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
  input = input.trim();
  const [a,b,c] = input.split(" ").map(Number);
  console.log(a*b*c==175?'Yes':'No');
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
  input = input.trim();
  const [a,b,c] = input.split(" ").map(Number);
  let set = new Set([a,b,c]);
  let num = set.size;
  if(num==2){
    if(a==5||a==7||b==5||b==7||c==5||c==7){
       console.log('Yes');
    }else{
       console.log('No');
    }
  }else{
    console.log('No');
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import "fmt"

func main() {
	slice := make([]int, 3)
	fmt.Scanf("%d %d %d", &slice[0], &slice[1], &slice[2])

	count5 := 0
	count7 := 0

	for i := 0; i < 3; i++ {
		if slice[i] == 5 {
			count5++
		} else if slice[i] == 7 {
			count7++
		}
	}

	if count5 == 2 && count7 == 1 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
//  [go]
package main
 
import "fmt"
 
func main(){
	var  i int;
  	var num5,num7 int;
  	num5 = 2;
  	num7 = 1;
  for a:=0;a<3;a++{
    fmt.Scan(&i);  	
    if(i==5){
    	num5--;
    }else if(i==7){
    	num7--;
    }else{
    	continue;
    }
  }
  if(num5==0 && num7==0){
    fmt.Println("YES")	
  }else{
    fmt.Println("NO")
  }
  
}
//  [go]
package main

import "fmt"

func main() {
	var a, b, c int
	fmt.Scan(&a, &b, &c)

	if (a == 7 && b == 5 && c == 5) || (a == 5 && b == 7 && c == 5) || (a == 5 && b == 5 && c == 7) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	//3つの整数を受け取れるようにスライスを作る
	slice := make([]int, 3)

	//標準入力から空白区切りの数列を読み取り、スライスに代入する
	fmt.Scanln(&slice[0], &slice[1], &slice[2])

	//それぞれに値が入っていることを確認する
	//for i := 0; i < 3; i++ {
	//	fmt.Printf("%d\n", slice[i])
	//}

	//こちらの方法でも確認可能
	//fmt.Printf("%d", slice)

	//slice[0]が5のとき[5, ?, ?]
	if slice[0] == 5 {
		//slice[1]が5のとき[5, 5, ?]
		if slice[1] == 5 {
			//slice[2]が7のとき[5, 5, 7]
			if slice[2] == 7 {
				sayYes()
			}
		}
		//slice[1]が7のとき[5, 7, ?]
		if slice[1] == 7 {
			//slice[2]が5のとき[5, 7, 5]
			if slice[2] == 5 {
				sayYes()
			}
		}
		//slice[0]が7のとき[7, ?, ?]
	} else if slice[0] == 7 {
		//slice[1]とslice[2]が両方5のとき[7, 5, 5]
		if slice[1] == 5 && slice[2] == 5 {
			sayYes()
		}
	} else {
		sayNo()
	}
}

//あえて練習のために作った関数(ただ"YES"と出力するだけ)
func sayYes() {
	fmt.Println("YES")
}

//コンテストには必要ないけど、一応間違っているとわかるようにするために作成
func sayNo() {
	fmt.Println("NO")
}
//  [go]
package main

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

func main() {
	s := bufio.NewScanner(os.Stdin)
	s.Scan()
	text := s.Text()

	words := strings.Split(text, " ")

	var add int
	for _, v := range words {
		val, _ := strconv.Atoi(v)
		add += val
	}

	if add == 19 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}

}
//  [go]
package main

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

func main() {
	s := bufio.NewScanner(os.Stdin)
	s.Scan()
	text := s.Text()

	words := strings.Split(text, " ")

	var add int
	for _, v := range words {
		val, _ := strconv.Atoi(v)
		add += val
	}

	if add == 31 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}

}
//  [ruby]
puts"557"==gets.split.sort*""?:YES: :NO
//  [ruby]
arr = [5, 5, 7]
n = gets.chomp.split(" ").map(&:to_i)
n.sort!

if n == arr
  puts "YES"
else
  puts "NO"
end
//  [ruby]
array = Array.new(3)
array=gets
array=array.split(" ")
array=array.sort
if array[0]=="5"&&array[1]=="5"&&array[2]=="7" then
    puts "YES"
else
    puts "NO"
end
//  [ruby]
puts [5,5,5]==gets.split.map(&:to_i).sort ? "YES" : "NO"
//  [ruby]
word = gets.split
puts word
//  [ruby]
class A042
  def call(a, b, c)
    (a == 5 || a== 7) &&
        (b == 5 || b== 7) &&
        (c == 5 || c== 7) &&
        a + b + c == 17
  end

  def main
    inputs = gets.split(' ')
    puts call(inputs[0].to_i, inputs[1].to_i, inputs[2].to_i)
  end
end

A042.new.main
//  [rust]
fn read_parameters<T>() -> Result<Vec<T>, String>
where
    T: std::str::FromStr,
{
    let mut line = String::new();
    std::io::stdin()
        .read_line(&mut line)
        .map_err(|err| format!("{:?}", err))?;

    let xs = line.trim().split_whitespace();
    let mut result = Vec::new();

    for x in xs {
        let ans = x.parse::<T>().map_err(|_| format!("{}", "parse error"))?;
        result.push(ans);
    }
    Ok(result)
}

fn main() {
    let mut a = read_parameters::<usize>().unwrap();
    a.sort();

    let mut sum = 0;
    for x in a {
        sum = 10 * sum + x;
    }

    if sum == 557 {
        println!("YES");
    } else {
        println!("NO");
    }
}
//  [rust]
fn main() {
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).unwrap();

    let sum: u8 = line
        .trim()
        .split(' ')
        .map(|s| s.parse::<u8>().unwrap())
        .sum();
    if sum == 17 {
        println!("YES");
    } else {
        println!("NO");
    }
}