jiahuimbzuai/CoQuIR huggingface dataset:
//  [rust]
use proconio::{fastout, input};

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

    let mut sum = vec![0; n + 1];
    for i in (1..=n).rev() {
        let mut j = i + i;
        let mut count = 0;
        while j <= n {
            count ^= sum[j];
            j += i;
        }
        sum[i] = count ^ a[i - 1];
    }

    let mut ans = Vec::new();
    for item in &sum {
        if *item == 1 {
            ans.push(*item);
        }
    }

    println!("{}", ans.len());
    for i in 0..ans.len() {
        print!("{}{}", ans[i], if i + 1 == ans.len() { "\n" } else { " " });
    }
}
//  [rust]
use proconio::{fastout, input};

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

    let mut sum = vec![0; n + 1];
    for i in (1..=n).rev() {
        let mut j = i + i;
        let mut count = 0;
        while j <= n {
            count ^= sum[j];
            j += i;
        }
        sum[i] = count ^ a[i - 1];
    }

    let mut ans = Vec::new();
    for item in &sum {
        if *item == 1 {
            ans.push(*item);
        }
    }

    println!("{}", ans.len());
    for i in 0..ans.len() {
        print!("{}{}", ans[i], if i + 1 == ans.len() { "\n" } else { " " });
    }
}
//  [rust]
use proconio::{fastout, input};

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

    let mut sum = vec![0; n + 1];
    for i in (1..=n).rev() {
        let mut j = i + i;
        let mut count = 0;
        while j <= n {
            count ^= sum[j];
            j += i;
        }
        sum[i] = count ^ a[i - 1];
    }

    let mut ans = Vec::new();
    for item in &sum {
        if *item == 1 {
            ans.push(*item);
        }
    }

    println!("{}", ans.len());
    for item in &ans {
        print!("{} ", item);
    }
    println!();
}
//  [swift]
let n = Int(readLine()!)!

func solve(_ a: [Int]) -> [Int] {
  let n = a.count
  var ans: [Int] = .init(repeating: 0, count: n + 1)
  for i in (1...n).reversed() {
    var sum = 0
    var j = i + i
    while j <= n {
      sum ^= ans[j]
      j += i
    }
    ans[i] = sum ^ a[i]
  }
  return ans
}

var a: [Int] = .init(repeating: 0, count: n + 1)
let inputs = readLine()!
	.split(separator: " ")
	.map { Int($0)! }
	.enumerated()
	.forEach { a[$0+1] = $1 }

let ans = solve(a)
let res = ans.enumerated().filter { $1 == 1 }
print(res.count)
res.forEach { print($0.0) }
//  [swift]
let n = Int(readLine()!)!


func solve(_ a: [Int]) -> [Int] {
  let n = a.count
  var ans: [Int] = .init(repeating: 0, count: n + 1)
  for i in (1...n).reversed() {
    var sum = 0
    var j = i + i
    while j <= n {
      sum ^= ans[j]
      j += i
    }
    ans[i] = sum ^ a[i]
  }
  return ans
}

var a: [Int] = .init(repeating: 0, count: n + 1)
let inputs = readLine()!
	.split(separator: " ")
	.map { Int($0)! }
	.enumerated()
	.forEach { a[$0+1] = $1 }

let ans = solve(a)
let res = ans.enumerated().filter { $1 == 1 }
print(res.count)
res.forEach { print($0) }
//  [swift]
let n = Int(readLine()!)!


func solve(_ a: [Int]) -> [Int] {
  let n = a.count
  var ans: [Int] = .init(repeating: 0, count: n + 1)
  for i in (1...n).reversed() {
    var sum = 0
    var j = i + i
    while j <= n {
      sum ^= ans[j]
      j += i
    }
    ans[i] = sum ^ a[i]
  }
  return ans
}

var a: [Int] = .init(repeating: 0, count: n + 1)
let inputs = readLine()!
	.split(separator: " ")
	.map { Int($0)! }
	.enumerated()
	.forEach { a[$0+1] = $1 }

let ans = solve(a)

if ans.isEmpty {
  print(-1)
} else {
  let res = ans.enumerated().filter { $1 == 1 }
  print(res.count)
  res.forEach { print($0.0 + 1) }
}
//  [typescript]
function main(input) {
  input = input.trim().split("\n");
  const n = Number(input[0]);
  const as = input[1].split(" ").map(n => Number(n));
  const result = Array(n).fill(0);
  let ans1 = 0;
  const ans2 = [];
  const mid = Math.floor(n/2);
  for (let i = n-1; 0 <= i; i--) {
    const a = as[i];
    if (mid <= i) {
      result[i] = a;
      if (a === 1) {
        ans1++;
        ans2.push(i+1);
      }
      continue;
    }
    const base = i + 1;
    let cnt = 0;
    let sum = 0;
    while(true) {
      cnt++;
      const index = base *(cnt + 1) - 1;
      if (n <= index) break;
      sum += result[index];
    }
    if (sum%2 === a) {
      result[i] = 0;
    } else {
      result[i] = 1;
      ans1++;
      ans2.push(i+1);
    }
  }
  console.log(ans1);
  if (ans1 !== 0) {
    console.log(ans2.join(" ");
  }
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8').trim()

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

const a = stdin
  .split('\n')[1]
  .split(' ')
  .map(Number)

const ans = () => {
  const aLast = a.length - 1
  const halfLine = Math.ceil(n / 2)

  const b = []

  for (let i = 0; i < n; i++) {
    b[i] = 0
  }

  for (let i = 0; i < n; i++) {
    if (i < halfLine) {
      b[aLast - i] = a[aLast - i]
    } else {
      const num = aLast - i + 1

      let count = 0
      for (let j = 2; num * j <= n + 1; j++) {
        if (b[num * j - 1] === 1) count++
      }

      if (a[aLast - i] === 1) {
        b[aLast - i] = count % 2 === 1 ? 0 : 1
      } else {
        b[aLast - i] = count % 2 === 0 ? 0 : 1
      }
    }
  }

  const filtered = b.filter(e => e === 1)

  console.log(filtered.length)
  if (filtered.length === 0) return

  let str = ''
  for (let i = 0; i < n; i++) {
    if (b[i] === 1) {
      str += ` ${i + 1}`
    }
  }
  console.log(str.trim())
}

ans()
//  [typescript]
export class Main {
  static main(input): string {
    const tmp: string[] = input.split("\n");
    const n: number = parseInt(tmp[0]);
    const aList: number[] = tmp[1].split(" ").map(int => parseInt(int));
    const ballNumSet: Set<number> = new Set();
    const result: number[] = [];
    for (let i = n - 1; i >= 0; i--) {
      const num: number = i + 1;
      let isOne: boolean = aList[i] == 1;
      for (let j = 2, len = Math.min(n / num); j <= len; j++) {
        if (ballNumSet.has(num * j)) {
          isOne = !isOne;
        }
      }
      if (isOne) {
        ballNumSet.add(num);
        result.push(num);
      }
    }
    return `${result.length}\n${result.join(" ")}`;
  }
}
 console.log(Main.main(require("fs").readFileSync("/dev/stdin", "utf8")));
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8').trim()

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

const a = stdin
  .split('\n')[1]
  .split(' ')
  .map(Number)

const ans = () => {
  const aLast = a.length - 1
  const halfLine = Math.ceil(n / 2)

  const b = []

  for (let i = 0; i < n; i++) {
    b[i] = 0
  }

  for (let i = 0; i < n; i++) {
    if (i < halfLine) {
      b[aLast - i] = a[aLast - i]
    } else {
      const num = aLast - i + 1

      let count = 0
      for (let j = 2; num * j <= n + 1; j++) {
        if (b[num * j - 1] === 1) count++
      }

      if (a[aLast - i] === 1) {
        b[aLast - i] = count % 2 === 1 ? 0 : 1
      } else {
        b[aLast - i] = count % 2 === 0 ? 0 : 1
      }
    }
  }

  const filtered = b.filter(e => e === 1)

  console.log(filtered.length)
  if (filtered.length === 0) return

  let str = `${filtered[0]}`

  for (let i = 1; i < filtered.length; i++) {
    str += ` ${filtered[i]}`
  }
  console.log(str)
}

ans()
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8').trim()

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

const a = stdin
  .split('\n')[1]
  .split(' ')
  .map(Number)

const ans = () => {
  const aLast = a.length - 1
  const halfLine = Math.ceil(n / 2)

  const b = []

  for (let i = 0; i < n; i++) {
    b[i] = 0
  }

  for (let i = 0; i < n; i++) {
    if (i < halfLine) {
      b[aLast - i] = a[aLast - i]
    } else {
      const num = aLast - i + 1

      let count = 0
      for (let j = 2; num * j <= n + 1; j++) {
        if (b[num * j - 1] === 1) count++
      }

      if (a[aLast - i] === 1) {
        b[aLast - i] = count % 2 === 1 ? 0 : 1
      } else {
        b[aLast - i] = count % 2 === 0 ? 0 : 1
      }
    }
  }

  console.log(b.length)
  let str = `${b[0]}`
  for (let i = 1; i < b.length; i++) {
    str += ` ${b[i]}`
  }
  console.log(str)
}

ans()
//  [python]
a,b,c=map(int,input().split())
d=b-a
e=c-b
if d==e:
  print("YES")
else:
  print("NO")
//  [python]
# 入力　数字3つ
a, b, c = map(int, input().split())

# 柱の並び方が美しい場合 YES を、そうでない場合 NO を 1行に出力せよ。
if b-a == c-b :
    print("YES")
else :
    print("NO")
//  [python]
#! -*- coding:utf-8 -*-
import math
import sys
a,b,c = map(int,input().split())
x = b - a
y = c - b
if x == y:
    print('YES')
else:
    print('NO')
//  [python]
a,b,c=map(int, input().split())     
print("Yes" if b-a==c-b else "No")
//  [python]
#!/usr/bin/env python3

def main():
    a, b, c = map(int, input().split())
    print("YES" if b - a == c - a else "NO")


if __name__ == "__main__":
    main()
//  [python]
a,b,c = map(int,input().split())
if b-a == c-a:
    print('YES')
else:
    print('NO')
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class Main {
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		try {
			String str = br.readLine();
			String[] s = str.split(" ",0);
			int a = Integer.parseInt(s[0]);
			int b = Integer.parseInt(s[1]);
			int c = Integer.parseInt(s[2]);
			if(b - a == c - b) {
				System.out.println("YES");
			}else {
				System.out.println("NO");
			}
//			long max  = 1000000007;
		}catch (Exception e) {
			System.exit(0);
		}
	}
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str = br.readLine();
		String[] inputstr = str.split(" ");
		int[] input = new int[3];
		for (int i = 0; i < 3; i++) {
			input[i] = Integer.parseInt(inputstr[i]);
		}
		if (input[1] == (input[0] + input[2]) / 2f)
			System.out.println("YES");
		else
			System.out.println("NO");
	}
}
//  [java]
import java.util.*;
public class Main {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		// 整数の入力
        int a = sc.nextInt();
     	int b = sc.nextInt();
        int c = sc.nextInt();
        
        if(Math.abs(a - b) == Math.abs(b - c)){
          System.out.println("YES");
        }else{
          System.out.println("NO");
        }

    }
}
//  [java]

import java.math.BigInteger;
import java.util.*;
public class Main {





public static void main(String[] args)
{
	Scanner sc=new Scanner(System.in);
			int a=sc.nextInt();
			int b=sc.nextInt();
			int c=sc.nextInt();
			if(b==(a+c)/2) {
				System.out.println("YES");
			}else {
				System.out.println("NO");
			}
}
}

class pair{
	int x,y;
	pair(int x,int y){
		this.x=x;
		this.y=y;
	}
}
//  [java]
import java.util.*;
public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int a = sc.nextInt();
    int b = sc.nextInt();
    int c = sc.nextInt();
    if(b-a == c-b){
        System.out.println("Yes");
    }else{
        System.out.println("No");
    }
  }
}
//  [cpp]
#include<stdio.h>


int main(){
    int a,b,c;
    while(~scanf("%d%d%d",&a,&b,&c)){
        printf("%s\n",(b-a)==(c-b) ? "YES" : "NO");
    }
    return 0;
}
//  [cpp]
#include<cstdio>

int a, b, c;

int main(){
  scanf("%d %d %d", &a, &b, &c);

  if(b - a == c - b){
    printf("YES");
  }else{
    printf("NO");
  }

  return 0;
  
}
//  [cpp]
# include <stdio.h>
int main(){
	int a,b,c;
	scanf("%d %d %d",&a,&b,&c);
	if(b-a==c-b)printf("YES");
	else printf("NO");
	return 0;
}
//  [cpp]
#include <iostream>
 
int main () {
	int a,b,c;
  std::string res;
  
  if (c-b == b-a) {
  	res = "YES";
  } else {
  	res = "NO";
  }
  
  std::cout << res << std::endl;
}
//  [cpp]
#include <iostream>

int main () {
	int a,b,c;
  std::string res;
  
  if (c-b == b-a) {
  	res = "YES"
  } else {
  	res = "NO"
  }
  
  std::cout << res << std::endl;
}
//  [cpp]
#include<stdio.h>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<algorithm>
#include<cmath>
#include<bitset>
 
#define Vsort(a) sort(a.begin(), a.end())
#define Vreverse(a) reverse(a.begin(), a.end())
#define Srep(n) for(int i = 0; i < (n); i++)
#define Lrep(i,a,n) for(int i = (a); i < (n); i++)
#define Brep(n) for(int bit = 0; bit < (1<<n); bit++)
#define rep2nd(n,m) Srep(n) Lrep(j,0,m)
#define vi vector<int>
#define vi64 vector<int64_t>
#define vvi vector<vector<int>>
#define vvi64 vector<vector<int64_t>>
 
using namespace std;

int main(){
  int a,b,c;
  cin >> a >> b >> c;
  if(b - a = c - b) cout << "YES" << endl;
  else cout << "NO" << endl;
}
//  [c]
#include<stdio.h>

int main(void){
  int a,b,c;
  scanf("%d%d%d",&a,&b,&c);
  if( b-a == c-b) puts("YES");
  else puts("NO");
  return 0;
}
//  [c]
#include <stdio.h>
int main(void){
	int a,b,c;
	scanf("%d%d%d",&a,&b,&c);
	if(b-a==c-b)printf("YES\n");
	else printf("NO\n");
	return 0;
}
//  [c]
#include <stdio.h>

int main(){
	int a, b, c;
	
	scanf("%d %d %d", &a, &b, &c );
	if(b-a==c-b) printf("YES\n");
	else printf("NO\n");
	
	return 0;
}
//  [c]
#include<stdio.h>
int main(void){
	int a,b,c;
	if(b-a==c-b){
		printf("YES\n");
	}else{
		printf("NO\n");
	}
	return 0;
}
//  [c]
#include<stdio.h>
int main(void){
	int a,b,c;
	if(b-a==c-b){
		printf("Yes\n");
	}else{
		printf("No\n");
	}
	return 0;
}
//  [c]
#include <stdio.h>
int main()
{
    int a,b,c,x,y;
    scanf("%d %d %d", &a, &b, &c);

    x=b-a;

    y=c-b;


    if(x==y)
    {
        printf("yes");
    }
    else{
        printf("no");
    }
    return 0;
}
//  [javascript]
function Main (input) {
  input = input.split("\n")[0].split(" ").map(Number);
  var a = input[0], b = input[1], c = input[2];
  if (b - a == c - b) {
    console.log("YES");
  }
  else {
    console.log("NO");
  }
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	var A = parseInt(input.split(" ")[0]);
  var B = parseInt(input.split(" ")[1]);
  var C = parseInt(input.split(" ")[2]);
  if(B - A == C - B){
     console.log("YES");
     }else{
      console.log("NO"); 
     }
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input){
    input=input.split("\n");
    tmp=input[0].split(" ");
    var a = parseInt(tmp[0], 10);
    var b = parseInt(tmp[1], 10);
    var c = parseInt(tmp[2], 10);
    if(b-a == c-b){
	console.log("YES");
    }else{
	console.log("NO");
    }
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
  input = input.trim();
  const [a,b,c] = input.split(" ").map(Number);
  let A = b-a;
  let B = c-a;
  if(A==B){
    console.log("YES");
  }else{
    console.log("NO");
  }
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main (input) {
  input = inpur.split("\n")[0].split(" ").map(Number);
  var a = input[0], b = input[1], c = input[2];
  if (b - a == c - b) {
    console.log("YES");
  }
  else {
    console.log("NO");
  }
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  input = input.trim()
  input = input.split(" ").map(Number);
if(input[1]-input[0]==input[2]-input[1]){
  console.log("YES");
}else{
  console.log("NO");
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

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

type contest struct {
	in  io.Reader
	out io.Writer
}

func (con *contest) Scan(a ...interface{}) (int, error) {
	return fmt.Fscan(con.in, a...)
}
func (con *contest) Scanln(a ...interface{}) (int, error) {
	return fmt.Fscanln(con.in, a...)
}
func (con *contest) Scanf(f string, a ...interface{}) (int, error) {
	return fmt.Fscanf(con.in, f, a...)
}
func (con *contest) Print(a ...interface{}) (int, error) {
	return fmt.Fprint(con.out, a...)
}
func (con *contest) Println(a ...interface{}) (int, error) {
	return fmt.Fprintln(con.out, a...)
}
func (con *contest) Printf(f string, a ...interface{}) (int, error) {
	return fmt.Fprintf(con.out, f, a...)
}
func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()
	con := &contest{in: in, out: out}
	con.main()
}

func (con *contest) main() error {
	a := make([]int, 3)
	con.Scan(&a[0], &a[1], &a[2])
	sort.Ints(a)
	if a[1]-a[0] == a[2]-a[1] {
		con.Println("YES")
	} else {
		con.Println("NO")
	}
	return nil
}
//  [go]
package main

import (
  "fmt"
)

func main() {
  var a, b, c int; fmt.Scan(&a, &b, &c)
  ans := "NO"
  if b - a == c - b {ans = "YES"}
  fmt.Println(ans)
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

func Scan() string {
	sc.Scan()
	return sc.Text()
}
func iScan() int {
	n, _ := strconv.Atoi(Scan())
	return n
}
func fScan() float64 {
	n, _ := strconv.ParseFloat(Scan(), 64)
	return n
}
func stringToInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}
func SScan(n int) []string {
	a := make([]string, n)
	for i := 0; i < n; i++ {
		a[i] = Scan()
	}
	return a
}
func iSScan(n int) []int {
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = iScan()
	}
	return a
}
func abs(x int) int {
	if x < 0 {
		x = -x
	}
	return x
}
func larger(a, b int) int {
	if a < b {
		return b
	} else {
		return a
	}
}
func smaller(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}
func max(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x < a[i] {
			x = a[i]
		}
	}
	return x
}
func min(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x > a[i] {
			x = a[i]
		}
	}
	return x
}
func sum(a []int) int {
	x := 0
	for _, v := range a {
		x += v
	}
	return x
}

// UnionFind 構造体 for tree
type UnionFind struct {
	par []int
}

/*コンストラクタ*/
func newUnionFind(N int) *UnionFind {
	u := new(UnionFind)
	u.par = make([]int, N)
	for i := range u.par {
		u.par[i] = -1
	}
	return u
}
func (u UnionFind) root(x int) int {
	if u.par[x] < 0 {
		return x
	}
	u.par[x] = u.root(u.par[x])
	return u.par[x]
}
func (u UnionFind) unite(x int, y int) {
	xr := u.root(x)
	yr := u.root(y)
	if xr == yr {
		return
	}
	u.par[yr] += u.par[xr]
	u.par[xr] = yr
}
func (u UnionFind) same(x, y int) bool {
	if u.root(x) == u.root(y) {
		return true
	}
	return false
}
func (u UnionFind) size(x int) int {
	return -u.par[u.root(x)]
}

var mod int = 1000000007

type pair struct {
	fi int
	se int
}

func main() {
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	//予備
	a := iScan()
	b := iScan()
	c := iScan()

	if b-a == c-a {
		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 b-a == c-b {
		fmt.Println("YES")
	} else {
		fmt.Println("YES")
	}
}
//  [ruby]
a,b,c = gets.chomp.split(' ').map(&:to_i)
if b-a == c-b
  puts "YES"
else
  puts "NO"
end
//  [ruby]
a,b,c = gets.split.map(&:to_i)
puts b - a == c - b ? "YES" : "NO"
//  [ruby]
a, b, c = gets.split(" ").map(&:to_i)
puts ((b - a) == (c - b) ? "YES" : "NO")
//  [ruby]
a,b,c = map(int, input().split())
if b-a==c-b:
  print("YES")
else:
  print("NO")
//  [ruby]
a=gets.split.map(&:to_i).sort;puts a[0] + a[1] == a[2] ? "YES" : "NO"
//  [ruby]
def l(a, b, c)
  puts b - a == c - b ? "YES" : "No"
end

a, b, c= gets.chomp.split(" ").map(&:to_i)
l(a, b, c)
//  [rust]
use std::io::prelude::*;

fn input<T>() -> T
where T: std::str::FromStr {
    let stdin = std::io::stdin();
    let token: String = stdin
        .lock()
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().unwrap()
}

fn main() {
    let a = input::<i32>();
    let b = input::<i32>();
    let c = input::<i32>();

    if b - a == c - b {
        println!("YES");
    } else {
        println!("NO");
    }
}
//  [rust]
// 参考
// https://techracho.bpsinc.jp/jhonda/2019_08_05/78537

// Input macro
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! stdin {
    () => {{
        use std::io::Read;
        let mut s = String::new();
        std::io::stdin().read_to_string(&mut s).unwrap();
        s
    }};
}

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")
    };
}

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

test! {
r"2 4 6
" => r"YES",

r"2 5 6
" => r"NO",

r"3 2 1
" => r"YES"
}

use std::cmp;
use std::cmp::{max, min};
use std::collections::HashSet;
use std::f32::MAX;

fn main() {
    println!("{}", solve(&stdin!()));
}

fn solve(src: &str) -> String {
    input! {
        source = src,
        a: i32,
        b: i32,
        c: i32,
    }

    if b - a == c - b {
        "YES".to_string()
    } else {
        "NO".to_string()
    }
}
//  [rust]
#![allow(unused, non_snake_case, dead_code, non_upper_case_globals)]
use std::cmp::*;
use std::collections::*;
use std::mem::*;

fn main() {
    let (r, w, e) = (std::io::stdin(), std::io::stdout(), std::io::stderr());
    let mut io = IO::new(r.lock(), w.lock(), e.lock());

    let mut o = io.chars();
    let mut e = io.chars();
    for (&a, &b) in o.iter().zip(e.iter()) {
        io.write(a);
        io.write(b);
    }
    if o.len() > e.len() {
        io.write(o.last().unwrap());
    }
}

static MX: usize = 1010101;
static MOD: i64 = 1000000007;
static INF: i64 = std::i64::MAX >> 1;
// IO
use std::io::*;
struct IO<R: Read, W: Write, E: Write> {
    Read: R,
    Write: BufWriter<W>,
    Error: BufWriter<E>,
}
impl<R: Read, W: Write, E: Write> IO<R, W, E> {
    fn new(r: R, w: W, e: E) -> IO<R, W, E> {
        IO {
            Read: r,
            Write: BufWriter::new(w),
            Error: BufWriter::new(e),
        }
    }
    fn read<T>(&mut self) -> T
    where
        T: std::str::FromStr,
    {
        let next: String = self
            .Read
            .by_ref()
            .bytes()
            .map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect();
        next.parse().ok().unwrap()
    }
    fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
    fn chari(&mut self) -> Vec<i64> {
        self.chars()
            .iter()
            .map(|&c| (c as u8 - b'0') as i64)
            .collect::<Vec<i64>>()
    }
    fn readn<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read::<T>()).collect::<Vec<_>>()
    }
    fn readmat<T: std::str::FromStr>(&mut self, n: usize, m: usize) -> Vec<Vec<T>> {
        (0..n).map(|_| self.readn(m)).collect()
    }
    fn write<S: ToString>(&mut self, val: S) {
        self.Write.write(val.to_string().as_bytes());
    }
    fn writeln<S: ToString>(&mut self, val: S) {
        self.Write.write(val.to_string().as_bytes());
        self.Write.write(b"\n");
    }
    fn debug<S: std::fmt::Debug>(&mut self, val: S) {
        writeln!(self.Error, "(debug) {:?}", &val);
    }
    fn debug2<S: std::fmt::Debug, T: std::fmt::Debug>(&mut self, val1: S, val2: T) {
        writeln!(self.Error, "(debug2) {:?} -> {:?}", val1, val2);
    }
    fn debug3<S: std::fmt::Debug, T: std::fmt::Debug, U: std::fmt::Debug>(
        &mut self,
        val1: S,
        val2: T,
        val3: U,
    ) {
        writeln!(
            self.Error,
            "(debug3) {:?} -> {:?} -> {:?}",
            val1, val2, val3
        );
    }
}
//  [rust]
#![allow(unused, non_snake_case, dead_code, non_upper_case_globals)]
use std::cmp::*;
use std::collections::*;
use std::mem::*;

fn main() {
    let (r, w, e) = (std::io::stdin(), std::io::stdout(), std::io::stderr());
    let mut io = IO::new(r.lock(), w.lock(), e.lock());
    assert_eq!(!0usize, std::usize::MAX); //🙊
    assert!(0 == 0); //😇
    let mut o = io.chars();
    let mut e = io.chars();
    for (&a, &b) in o.iter().zip(e.iter()) {
        io.write(a);
        io.write(b);
    }
    if o.len() > e.len() {
        io.write(o.last().unwrap());
    }
}

static MX: usize = 1010101;
static MOD: i64 = 1000000007;
static INF: i64 = std::i64::MAX >> 1;
// IO
use std::io::*;
struct IO<R: Read, W: Write, E: Write> {
    Read: R,
    Write: BufWriter<W>,
    Error: BufWriter<E>,
}
impl<R: Read, W: Write, E: Write> IO<R, W, E> {
    fn new(r: R, w: W, e: E) -> IO<R, W, E> {
        IO {
            Read: r,
            Write: BufWriter::new(w),
            Error: BufWriter::new(e),
        }
    }
    fn read<T>(&mut self) -> T
    where
        T: std::str::FromStr,
    {
        let next: String = self
            .Read
            .by_ref()
            .bytes()
            .map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect();
        next.parse().ok().unwrap()
    }
    fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
    fn chari(&mut self) -> Vec<i64> {
        self.chars()
            .iter()
            .map(|&c| (c as u8 - b'0') as i64)
            .collect::<Vec<i64>>()
    }
    fn readn<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read::<T>()).collect::<Vec<_>>()
    }
    fn readmat<T: std::str::FromStr>(&mut self, n: usize, m: usize) -> Vec<Vec<T>> {
        (0..n).map(|_| self.readn(m)).collect()
    }
    fn write<S: ToString>(&mut self, val: S) {
        self.Write.write(val.to_string().as_bytes());
    }
    fn writeln<S: ToString>(&mut self, val: S) {
        self.Write.write(val.to_string().as_bytes());
        self.Write.write(b"\n");
    }
    fn debug<S: std::fmt::Debug>(&mut self, val: S) {
        writeln!(self.Error, "(debug) {:?}", &val);
    }
    fn debug2<S: std::fmt::Debug, T: std::fmt::Debug>(&mut self, val1: S, val2: T) {
        writeln!(self.Error, "(debug2) {:?} -> {:?}", val1, val2);
    }
    fn debug3<S: std::fmt::Debug, T: std::fmt::Debug, U: std::fmt::Debug>(
        &mut self,
        val1: S,
        val2: T,
        val3: U,
    ) {
        writeln!(
            self.Error,
            "(debug3) {:?} -> {:?} -> {:?}",
            val1, val2, val3
        );
    }
}
//  [swift]
import Foundation

let str = readLine()!
let abc = str.componentsSeparatedByString(" ").map{Int($0)!}
let a = abc[0]
let b = abc[1]
let c = abc[2]

if a-b == b-c {
    print("YES")
} else {
    print("NO")
}
//  [swift]
import Foundation
let line1 = readLine()!

let abc = line1.componentsSeparatedByString( " " )

let aa:String = abc[0]
let bb:String = abc[1]
let cc:String = abc[2]

let a:Int = Int(aa)!
let b:Int = Int(bb)!
let c:Int = Int(cc)!

if b-a == c-b{
    
    print("YES")
    
}
else {
    print("NO")
    
}
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!};print(i[1]-i[0]==i[2]-i[1] ?"YES":"NO")
//  [swift]
import Foundation
let line1 = readLine()!
let line2 = readLine()!
let line3 = readLine()!

let a:Int = Int(line1)!
let b:Int = Int(line2)!
let c:Int = Int(line3)!

if b-a == c-b{
    
    print("YES")
    
}
    
else {print("NO")
    
}
//  [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]=nrin(3)
  out(b-a==c-b?'YES':'NO')
}
main()
//  [typescript]
function main(input):void {
	// 1行目がinput[0], 2行目がinput[1], …に入る
	const inpt: Array<string> = input.split('\n');

	const list = inpt[0].split(' ');

	const num1: number = +list[1] - +list[0];
	const num2: number = +list[2] - +list[1];

	console.log((num1 === num2) ? 'YES' : 'NO');
}

// *** debug start ***
function debug(): void{
	const input = (<HTMLInputElement>document.getElementById('input')).value;
	input && main(input);
}
// *** debug end ***

//
declare function require(x: string): any;
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const a = parseInt(input[0], 10);
  const b = parseInt(input[1], 10);
  const c = parseInt(input[2], 10);
  
  if (b-a===c-b) {
    console.log('YES');
  }else{
    console.log('NO');
  }
}
 
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
import * as fs from 'fs';

const [a, b, c]: number[] = fs.readFileSync('/dev/stdin', 'utf8').trim().split(' ').map(Number);
// b-a=c-b
const ans: string = (b - a === c - b) ? 'YES' : 'No';
console.log(ans);
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const a = parseInt(input[0], 10);
  const b = parseInt(input[1], 10);
  const c = parseInt(input[2], 10);
  
  if (b-a===c-b) {
    console.log('YES');
  }else{
    console.log('No');
  }
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
a,b,c = map(int,input().split())
print("Yes" if a == b == c else "No")
//  [python]
a,b,c=map(int,input().split())
print("Yes") if a==b==c else print("No")
//  [python]
a, b, c = [int(x) for x in input().split(' ')]

if a==b and b==c:
    print('Yes')
else:
    print('No')
//  [python]
a=input().split()
if set(a)==a:
    print('Yes')
else:
    print('No')
//  [python]
a, b, c = map(int, input().split(' '))
if (a+b>c and b+c>a and c+a>b) and (a == b or b==c or c==a):
  print('Yes')
else:
  print('No')
//  [java]
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;

public class Main {

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		int A = sc.nextInt();
		int B = sc.nextInt();
		int C = sc.nextInt();

		if (A == B && B == C) {
			System.out.println("Yes");
		} else {
			System.out.println("No");
		}
	}

	private static boolean isDebug = System.getProperty("sun.desktop") != null;

	private static void debug(Object... o) {
		if (isDebug) {
			System.err.println(Arrays.deepToString(o));
		}
	}

	public static class Pair {
		private int A;
		private int B;

		public Pair(int a, int b) {
			super();
			A = a;
			B = b;
		}

		public int getA() {
			return A;
		}

		public int getB() {
			return B;
		}
	}

	public static class Scanner {
		private BufferedInputStream inputStream;

		public Scanner(InputStream in) {
			inputStream = new BufferedInputStream(in);
		}

		public int nextInt() throws IOException {
			int num = 0;
			int sign = 1;

			int read = skip();
			if (read == '-') {
				sign = -1;
				read = inputStream.read();
			}

			do {
				num = num * 10 + sign * (read - 0x30);
			} while ((read = inputStream.read()) > 0x20);

			return num;
		}

		public void fill(int[] a) throws IOException {
			for (int i = 0; i < a.length; i++) {
				a[i] = nextInt();
			}
		}

		public void fill(int[] a, int[] b) throws IOException {
			if (a.length != b.length) {
				throw new IllegalArgumentException();
			}

			for (int i = 0; i < a.length; i++) {
				a[i] = nextInt();
				b[i] = nextInt();
			}
		}

		public long nextLong() throws IOException {
			long num = 0;
			int sign = 1;

			int read = skip();
			if (read == '-') {
				sign = -1;
				read = inputStream.read();
			}

			do {
				num = num * 10 + sign * (read - 0x30);
			} while ((read = inputStream.read()) > 0x20);

			return num;
		}

		public void fill(long[] a) throws IOException {
			for (int i = 0; i < a.length; i++) {
				a[i] = nextLong();
			}
		}

		public void fill(long[] a, long[] b) throws IOException {
			if (a.length != b.length) {
				throw new IllegalArgumentException();
			}

			for (int i = 0; i < a.length; i++) {
				a[i] = nextLong();
				b[i] = nextLong();
			}
		}

		public long[] nextLong(int n) throws IOException {
			long[] array = new long[n];
			for (int i = 0; i < n; i++) {
				array[i] = nextLong();
			}

			return array;
		}

		public String next() throws IOException {
			StringBuilder builder = new StringBuilder();

			int read = skip();
			do {
				builder.append((char) read);
			} while ((read = inputStream.read()) > 0x20);

			return builder.toString();
		}

		private int skip() throws IOException {
			int read;
			while ((read = inputStream.read()) <= 0x20)
				;

			return read;
		}
	}
}
//  [java]
import java.io.*;
import java.util.*;
class Main{
	static final long MOD = 1_000_000_007; // 10^9+7
    static final int MAX = 2_147_483_646; // intMax 
    static final int INF = 1_000_000_000; // 10^9  
    public static void main(String[] args) throws Exception {
		hayami saori = new hayami();
		int a = saori.saori_hayami();
		int b = saori.saori_hayami();
		int c = saori.saori_hayami();
		if(a == b && b == c){
			System.out.println("Yes");
		} else {
			System.out.println("No");
		}
		
		saori.close();
    }
}

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]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        Set<String> set = new HashSet<>();
        String[] reading = null;
        try {
        reading = reader.readLine().split(" ");

        set.add(reading[0]);
        set.add(reading[1]);
        set.add(reading[2]);

        if (set.size() > 1) {
            System.out.println("No");
        } else {
            System.out.println("Yes");
        }

        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}
//  [java]
import java.util.*;
public class Main{
  public static void main(String[] args){
    Scanner sc = new Scanner(System.in);
    int a = sc.nextInt();
    int b = sc.nextInt();
    int c = sc.nextInt();
    if(a==b&&b==c)System.out.println("Yes");
    else SYstem.out.println("No");
  }
}
//  [java]
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner scn = new Scanner(System.in);

		int a = scn.nextInt();
		int b = scn.nextInt();
		String c = scn.next();
		String[] strArray = c.split("");

		List<String> moji = new ArrayList<>();
		List<Integer> golem = new ArrayList<>();

		for (int i = 0; i < strArray.length; i++) {
			moji.add(strArray[i]);
		}
		for(int i = 0; i < moji.size(); i++) {
			golem.add(1);
		}

		for(int i = 0; i < b; i++) {
			String d = scn.next();
			String e = scn.next();

			for(int j = 0; j < moji.size(); j++) {
				if(moji.get(j).equals(d)) {
					if(e.equals("L")) {
						if(golem.get(j) > 0 && j != 0) {
							golem.set(j - 1, golem.get(j) + golem.get(j - 1));
						}
					} else {
						if(golem.get(j) > 0 && j != moji.size() - 1) {
							golem.set(j + 1, golem.get(j) + golem.get(j + 1));
						}
					}
					golem.set(j, 0);
				}
			}
		}

		System.out.println(golem.stream().mapToInt(n -> n).sum());
	}

}
//  [java]
import java.util.Arrays;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

public class Main {


    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        //
        int a[]=new int[3];
        for(int i=0;i<3;i++){
            a[i]=in.nextInt();
        }
        Arrays.sort(a);
        //
        boolean ans=a[0]+a[1]>a[2]?true:false;
        System.out.println(ans==true?"Yes":"No");
    }

}
//  [cpp]
#include <cstdio>

int main() {
  int a, b, c;
  scanf("%d%d%d", &a, &b, &c);
  if (a == b && b == c)
    printf("Yes");
  else
    printf("No");
}
//  [cpp]
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int gi(){
	int x=0,w=1;char ch=getchar();
	while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
	if(ch=='-')w=0,ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
	return w?x:-x;
}
int main(){
	int a=gi(),b=gi(),c=gi();
	puts(a==b&&b==c?"Yes":"No");
	return 0;
}
//  [cpp]
#include <iostream>
using namespace std;
int main() {
  int a, b, c;
  cin >> a >> b >> c;
  if(a == b && b == c && c == a) cout << "Yes" << endl;
  else cout << "No" << endl;
}
//  [cpp]
    #include<iostream>
    #include<stdio.h>
    //#include <bits/stdc++.h>
    #include<vector>
    #include<float.h>
    #include<iomanip>
    #include<algorithm>
    #include<string>
    #include<cstring>
    #include<math.h>
    #include<cmath>
    #include<sstream>
    #include<set>
    #include<map>
    #include<queue>
    #include<cassert>
    #include<cmath>
    #include<cstdint>
    #include<numeric>
    #include<array>
     
    #define INF 1e9
    #define rep(i,n)for(int i=0;(i)<(int)(n);i++)
    #define REP(i,a,b)for(int i=(int)(a);(i)<=(int)(b);i++)
    #define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
    #define vec(type,n) vector<type>(n)
    #define vvec(m,n) vector<vector<int>> (int(m),vector<int>(n))
    #define ALL(a)  (a).begin(),(a).end()
    #define chmin(a, b) a = min(a, b)
    #define chmax(a, b) a = max(a, b)
    #define Vl vector<ll>
     
    using namespace std;
    using ll = long long;
    using Graph = vector<vector<ll>>;
    using P = pair<ll, ll>;
     
const ll MOD = 1e9 + 7;
const ll ZER = 0;

int main(){
    vector<int> a(3);
    rep(i, 3)cin >> a[i];
    sort(ALL(a));
    if(a[0] == a[1])cout << "Yes" << endl;
    else cout << "No" << endl;
}
//  [cpp]
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;

int main() {
  int A, B, C;
  cin >> A >> B >> C;

  if (max({A, B, C}) * 2 < A + B + C)
    cout << "Yes" << endl;
  else
    cout << "No" << endl;
  return 0;
}
//  [cpp]
#pragma region
#define _USE_MATH_DEFINES
#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <map>
#include <queue>
#include <stack>
#include <set>
#include <list>
#include <iomanip>
#include <cstdint>
#include <bitset>
#include <fstream>

using namespace std;
typedef long long ll;
//#define rep(i, s, e) for (int(i) = (s); (i) < (e); ++(i))
#define rep(i, e) for (int(i) = 0; (i) < (e); ++(i))
#define rrep(i, s) for (int(i) = (s) - 1; (i) >= 0; --(i))
#define all(x) x.begin(),x.end()

#pragma region UnionFind
struct UnionFind
{
	vector<int> par;

	UnionFind(int n) : par(n, -1) {}
	void init(int n) { par.assign(n, -1); }

	int root(int x)
	{
		if (par[x] < 0) return x;
		else return par[x] = root(par[x]);
	}

	bool issame(int x, int y)
	{
		return root(x) == root(y);
	}

	bool merge(int x, int y)
	{
		x = root(x); y = root(y);
		if (x == y) return false;
		if (par[x] > par[y]) swap(x, y);
		par[x] += par[y];
		par[y] = x;
		return true;
	}

	int size(int x)
	{
		return -par[root(x)];
	}
};
#pragma endregion
#pragma region GCD
int gcd(int a, int b)
{
	if (a%b == 0)return b;
	return gcd(b, a%b);
}
#pragma endregion
#pragma region chmin
template<class T> inline bool chmin(T& a, T b)
{
	if (a > b)
	{
		a = b;
		return true;
	}
	return false;
}
#pragma endregion
#pragma region chmax
template<class T> inline bool chmax(T& a, T b)
{
	if (a < b)
	{
		a = b;
		return true;
	}
	return false;
}
#pragma endregion
#pragma endregion


int main()
{
	int a, b, c; cin >> a >> b >> c;
	if (a + b > c && a + c > b && b + c > a)cout << "Yes" << endl;
	else cout << "No" << endl;
}
//  [c]
#include <stdio.h>


int main(void){

        int a,b,c;

        scanf("%d%d%d",&a,&b,&c);

    
        if(a==b && b==c){
                printf("Yes\n");
        }else{
                printf("No\n");
        }   
return 0;
}
//  [c]
main(a,b,c){scanf("%d%d%d",&a,&b,&c)<puts(a-b|b-c?"No":"Yes");}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>

int main(){
    int a,b,c;
    scanf("%d%d%d",&a,&b,&c);
    if (a==b&&b==c) {
        printf("Yes\n");
    }else{
        printf("No\n");
    }
    return 0;
}
//  [c]
#include <stdio.h>
int main() {
	int a,b,c;
	scanf("%d%d%d", &a,&b,&c);
	if (a==b==c) {
		printf("Yes\n");
	} else {
		printf("No\n");
	}
	return 0;
}
//  [c]
#include <stdio.h>
int main (void){
  int A,B,C;
  scanf("%d %d %d",&A,&B,&C);
  if(A==B==C){
    printf("Yes");
  }
  else {
    printf("No");
  }
  return 0;
}
//  [c]
#include <stdio.h>
int main (void){
  int A,B,C;
  scanf("%d %d %d ",&A,&B,&C);
  if(A==B==C){
    printf("Yes");
  }
  else {
    printf("No");
  }
  return 0;
}
//  [javascript]
'use strict'

const main = input => {
	const args = input.split('\n').map(arg => arg.split(' '))
	const A = parseInt(args[0][0], 10)
	const B = parseInt(args[0][1], 10)
	const C = parseInt(args[0][2], 10)
	console.log((A === B && B === C) ? 'Yes' : 'No')
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
function MainA(input) {
	input = input.split("\n")[0].split(" ");
	var a = input[0];
	var b = input[1];
	var c = input[2];
	var result = (a == b && b == c) ? "Yes" : "No";

	console.log('%s',result);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
MainA(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	var values = input.split(" ");
	console.log((values[0] == values[1] && values[0] == values[2]) ? "Yes" : "No");
}

Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
  input = input.split(' ').map(val => parseInt(val));
  
  var ans = 'YES'
  for (var i of input) {
    if(input[0] !== i) {
      ans = 'NO';
      break;
    }
  }

  console.log(ans);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
  input = input.split(' ').map(val => parseInt(val));
  
  let ans = 'YES'
  for (let i of input) {
    if(input[0] !== i) {
      ans = 'NO';
      break;
    }
  }

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

var rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.on('line', function(input) {
    lines.push(input);
});

rl.on('close', function() {
    var inputsAsArr = lines[0].split(' ');
    var sideA = inputsAsArr[0];
    var sideB = inputsAsArr[1];
    var sideC = inputsAsArr[2];

    var outputStr = sideA === sideB === sideC ? 'Yes' : 'No';
    console.log(outputStr);
});
//  [go]
// ProblemURL : https://atcoder.jp/contests/exawizards2019/tasks/exawizards2019_a
// ---------------------------------------------
package main

import "fmt"

func main() {
	var a, b, c int
	fmt.Scan(&a, &b, &c)
	ok := a == b && b == c
	if ok {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

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

func nextInt() int {
	sc.Scan()
	i, _ := strconv.Atoi(sc.Text())
	return i
}

func nextFloat64() float64 {
	f, _ := strconv.ParseFloat(next(), 64)
	return f
}

func nextInts(n int) []int {
	slice := make([]int, n)
	for i := 0; i < n; i++ {
		slice[i] = nextInt()
	}
	return slice
}

func main() {
	sc.Split(bufio.ScanWords)
	a, b, c := nextInt(), nextInt(), nextInt()
	if a == b && b == c {
		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 == b && b == c {
    fmt.Println("Yes")
  } else {
    fmt.Println("No")
  }

}
//  [go]
package main

import (
	"fmt"
	"sort"
)

func main() {
	xs := make([]int, 3)
	for i := range xs {
		fmt.Scan(&xs[i])
	}
	sort.Ints(xs)
	if v := xs[0] + xs[1]; v <= xs[2] || v > xs[2] {
		fmt.Println("No")
	} else {
		fmt.Println("Yes")
	}
}