jiahuimbzuai/CoQuIR huggingface dataset:
//  [swift]
let input = readLine()!.characters.split(" ").map{Int(String($0))!}
let (N, K, Q) = (input[0], input[1], input[2])
var cnt = (0..<N).reduce([]){a,_ in a+[0]}
for _ in 0..<Q {
  cnt[Int(readLine()!)!-1] += 1
}
cnt.forEach{print($0>Q-K ?"Yes":"No")}
//  [typescript]
import * as fs from 'fs'
const reader = (s: string) =>
  s
    .split(' ')
    .join('\n')
    .split('\n')
    .map(t => parseInt(t, 10))

function Main(input: string) {
  const [N, K, Q, ...A] = reader(input)
  const score: number[] = new Array(N).fill(K - Q)

  for (const i of A) {
    score[i - 1]++
  }

  const yes = score.map(num => {
    if (num > 0) {
      return 'Yes'
    } else {
      return 'No'
    }
  })

  console.log(yes.join('\n'))
}

Main(fs.readFileSync('/dev/stdin', 'utf8'))
//  [typescript]
import { createInterface } from 'readline';

const main = (lines: string[]) => {
  console.log(solve(lines));
};

export const solve = (lines: string[]): string => {
  const { N, K, Q, A } = parseLines(lines);
  let out = '';
  const n = +N;

  if (+K > +Q) {
    for (let i = 0; i < n; i++) {
      out += 'Yes\n';
    }
    return out.slice(0, -1);
  }

  const tgt = +Q - +K;

  const memo = A.reduce((acc, cur) => {
    if (!acc[cur]) {
      acc[cur] = 0;
    }
    ++acc[cur];

    return acc;
  }, {});

  for (let i = 0; i < n; i++) {
    out += memo[(i + 1).toString()] > tgt ? 'Yes\n' : 'No\n';
  }

  return out.slice(0, -1);
};

const parseLines = (lines: string[]) => {
  const [first, ...A] = lines;
  const [N, K, Q] = first.split(' ');
  const obj = { N, K, Q, A };
  debug(obj);
  return obj;
};

const debug = (message?: any, ...optionalParams: any[]) => {
  if (!!process.env.LOCAL_DEBUG) {
    console.log(message, ...optionalParams);
  }
};

if (!process.env.LOCAL_DEBUG) {
  const { stdin: input, stdout: output } = process;
  input.resume();
  input.setEncoding('utf8');
  const lines: string[] = [];
  createInterface({ input, output })
    .on('line', line => lines.push(line))
    .on('close', () => main(lines));
}
//  [typescript]
import { readFileSync } from 'fs'
function main() {
  const input = readFileSync('/dev/stdin', 'utf8')
  const inputs = input.trim().split('\n')
  const [n, k, q] = inputs[0].split(' ').map(v => parseInt(v))
  const winner = inputs.slice(1).map(v => parseInt(v))
  const array: number[] = []
  array.length = n
  array.fill(0)
  for (let i = 0; i < q; i++) {
    array[winner[i] - 1]++
  }
  const human: string[] = []
  human.length = n
  const border = q - k
  for (let i = 0; i < n; i++) {
    human[i] = array[i] > border ? 'Yes' : 'No'
    console.log(human[i])
  }
}
main()
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);let input_i=-1;const tn=():number=>{input_i++;return Number(input[input_i])};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{input_i++;return String(input[input_i])};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(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 sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1]}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};const deduplicate=(a):any[]=>{return Array.from(new Set(a))};
const main=()=>{
  let [n,k,q]=tnn(3)
  let ch=new Array(n)
  ch.fill(k)
  for(let i=0;i<q;i++){
    let win=tn()-1
    for(let j=0;j<n;j++){
      if(win!=j)ch[j]-=1
    }
  }
  for(let i=0;i<n;i++){
    to(ch[i]>0?'Yes':'No')
  }
}
main()
//  [typescript]
import * as fs from 'fs'
const reader = (s: string) =>
  s
    .split(' ')
    .join('\n')
    .split('\n')
    .map(t => parseInt(t, 10))

function Main(input: string) {
  const [N, K, Q, ...A] = reader(input)
  const player: number[] = new Array(N).fill(K)

  const score = player.map((sco, ply) => sco - A.filter(p => ply !== p - 1).length)

  const yes = score.map(num => {
    if (num > 0) {
      return 'Yes'
    } else {
      return 'No'
    }
  })

  console.log(yes.join('\n'))
}

Main(fs.readFileSync('/dev/stdin', 'utf8'))
//  [typescript]
import { readFileSync } from 'fs'
function main() {
  const input = readFileSync('/dev/stdin', 'utf8')
  const inputs = input.trim().split('\n')
  const [n, k, q] = inputs[0].split(' ').map(v => parseInt(v))
  const winner = inputs.slice(1).map(v => parseInt(v))
  const array: number[] = []
  array.length = n
  array.fill(0)
  for (let i = 0; i < q; i++) {
    array[winner[i] - 1]++
  }
  const human: string[] = []
  human.length = n
  const border = q - k
  for (let i = 0; i < n; i++) {
    human[i] = array[i] > border ? 'Yes' : 'No'
  }
  const result = human.join('/n')
  console.log(result)
}
main()
//  [python]
a, b = map(int, input().split())
ans = a-b*2
if ans >= 0:
  print(ans)
else:
  print(0)
//  [python]
a, b = map(int, input().split())
if a <= b:
    print(0)
else:
    bb = b * 2
    if a <= bb:
        print(0)
    else:
        print(abs(bb -a))
//  [python]
a,b=input().strip().split(" ")
a,b=[int(a),int(b)]
p=2*b
if a-p<=0:
  print(0)
else:
  print(a-p)
//  [python]
import sys
stdin=sys.stdin

ip=lambda: int(sp())
lp=lambda:list(map(int,stdin.readline().split()))
sp=lambda:stdin.readline().rstrip()

a,b=ip()

print(max(0,a-2*b))
//  [python]
A,B=map(int,input().split())
print(min(0, A-2*B))
//  [python]
A, B = map(int, input().split())
print(max(0, A - 2 * B)
//  [java]
import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        int a = sc.nextInt();
        int b = sc.nextInt();
        if (a <= 2 * b) {
            System.out.println(0);
            return;
        }
        System.out.println(a - 2 * b);
    }
}

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());
    }
}
//  [java]
import java.util.*;
import java.io.*;
 
public class Main {
    public static void main(String[] args) throws Exception {
        long mod = (long)Math.pow(10,9)+7;
        FastScanner sc = new FastScanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int a = sc.nextInt();
        int b = sc.nextInt();
        System.out.println(Math.max(0,a-b*2));
    }
}

class FastScanner {
    private BufferedReader reader = null;
    private StringTokenizer tokenizer = null;
    public FastScanner(InputStream in) {
        reader = new BufferedReader(new InputStreamReader(in));
        tokenizer = null;
    }

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

    public String nextLine() {
        if (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken("\n");
    }

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

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

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

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

    public long[] nextLongArray(int n) {
        long[] a = new long[n];
        for (int i = 0; i < n; i++)
            a[i] = nextLong();
        return a;
    } 
}
//  [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().split(" ");
	int A = Integer.parseInt(str[0]);
	int B = Integer.parseInt(str[1]);

	System.out.println(Math.max(A - 2 * B, 0));
    }
}
//  [java]
import java.util.Arrays;
import java.util.Scanner;

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

        final int N = sc.nextInt();
        int[] sticks = scanSticks(sc, N);
        Arrays.sort(sticks);

        long answer = 0;

        for (int iLeft = 0; iLeft < N - 2; iLeft++) {
            int left = sticks[iLeft];

            int iMiddle = iLeft + 1;
            int iRight = iLeft + 2;
            int middle = sticks[iMiddle];
            int right = sticks[iRight];

            while (true) {
                if (isSatisfied(left, middle, right)) {
                    if (iRight != N - 1) {
                        answer++;
                        right = sticks[++iRight];
                    }
                    else {
                        answer += iRight - iMiddle;
                        break;
                    }
                }
                else if (iMiddle + 1 == iRight) {
                    if (iRight != N - 1) {
                        middle = sticks[++iMiddle];
                        right = sticks[++iRight];
                        continue;
                    }
                    break;
                }
                else
                    middle = sticks[++iMiddle];
            }
        }

        System.out.println(answer);
    }

    private static int[] scanSticks(Scanner sc, final int N) {
        int[] sticks = new int[N];

        for (int i = 0; i < N; i++)
            sticks[i] = sc.nextInt();

        return sticks;
    }

    private static boolean isSatisfied(int left, int middle, int right) {
        return left + middle > right;
    }
}
//  [java]
import java.util.*;

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

        final int N = sc.nextInt();
        int[] sticks = scanSticks(sc, N);
        Arrays.sort(sticks);

        long answer = 0;

        for (int iLeft = 0; iLeft < N - 2; iLeft++) {
            int left = sticks[iLeft];

            int iMiddle = iLeft + 1;
            int iRight = iLeft + 2;
            int middle = sticks[iMiddle];
            int right = sticks[iRight];

            while (true) {
                if (isSatisfied(left, middle, right)) {
                    if (iRight != N - 1) {
                        answer++;
                        right = sticks[++iRight];
                    }
                    else {
                        answer += iRight - iMiddle;
                        break;
                    }
                }
                else if (iMiddle + 1 == iRight)
                    break;
                else
                    middle = sticks[++iMiddle];
            }
        }

        System.out.println(answer);
    }

    private static int[] scanSticks(Scanner sc, final int N) {
        int[] sticks = new int[N];

        for (int i = 0; i < N; i++)
            sticks[i] = sc.nextInt();

        return sticks;
    }

    private static boolean isSatisfied(int left, int middle, int right) {
        return left + middle > right;
    }
}
//  [java]
import java.util.*;

class Main{
  public static void main(String[] args){
    Scanner sc = new Scanner(System.in);
    int a = sc.nextInt();
    int b = sc.newxtInt();
    int r = a-b*2;
    if(r<0) r = 0;
    System.out.println(r);
  }
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
#define FOR(i, n) for(int i=0;i<n;i++)
#define ll long long

int main(void){
    ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    int a, b;
    cin>>a>>b;
    cout<<max(a-2*b, 0);
}
//  [cpp]
#include<bits/stdc++.h>

using namespace std;

int main(){
int a,b;
cin>>a>>b;
if(b>=a || (b*2)>=a)cout<<0;
else{
    cout<<a-(b*2);
}

return 0;
}
//  [cpp]

    #include <bits/stdc++.h>
    #include <cstdio>
    #include <cstring>
    #include <cmath>
    #include <cstring>
    #include <chrono>
    #include <complex>
    #define endl "\n"
    #define ll long long int
    #define vi vector<int>
    #define vll vector<ll>
    #define vvi vector < vi >
    #define pii pair<int,int>
    #define pll pair<long long, long long>
    #define mod 1000000007
    #define inf 1000000000000000001;
    #define all(c) c.begin(),c.end()
    #define mp(x,y) make_pair(x,y)
    #define mem(a,val) memset(a,val,sizeof(a))
    #define eb emplace_back
    #define f first
    #define s second
    
    using namespace std;
    int main()
    {
        std::ios::sync_with_stdio(false);

            ll a,b;
            cin>>a>>b;
            if(2*b>=a)
            {
                cout<<"0";

            }
            else
            {
                cout<<a-2*b;
            }
            
        
        return 0;
    }
//  [cpp]
#include<iostream>
using namespace std;
main()
{
   int A,B;
   cin>>A>>B;
   if(A>B)
   {
       if(B*2<A)
        cout<<B<<endl;
       else
        cout<<"0"<<endl;
   }
   else
    cout<<"0"<<endl;
   return 0;

    }
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main() {
  
  int a, b;
  cin >> a >> b;
  int p = a - (b * 2);
  if(p < 0) cout << 0 << endl;
  else cout << p << endl;
//  [cpp]
#include <bits/stdc++.h>

int main() {
  int a, b; std::cin >> a >> b;
  std::cout << std::max(2*a-b, 0) << std::endl;
  
  return 0;
}
//  [c]
#include <stdio.h>

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

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

    }
    else
    {
        printf("%d",d);

    }
}
//  [javascript]
'use strict';
const main = input => {
  input = input[0].split(' ');
  const a = parseInt(input[0]),b = parseInt(input[1]);
  console.log(a-2*b>0?a-2*b:0);
  
}
main(require("fs").readFileSync("/dev/stdin", "utf8").split('\n'));
//  [javascript]
function main(arg) {
	arg = arg.trim().split(' ');
  	arg = arg.map(str => parseInt(str, 10));
  	var a = arg[0], b = arg[1] * 2;
  	if (a <= b) {
    	console.log(0);
    } else {
    	console.log(a-b);
    } 
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input){
  input = input.split(' ').map(parseFloat);
  console.log(input[0] - input[1] * 2  > 0 ? input[0] - input[1] * 2 : 0);
}
main(require("fs").readFileSync("/dev/stdin","utf8"));
//  [javascript]
function main(input) {
    const args = input.split(' ');
    const A = parseInt(args[0], 10),
          B = parseInt(args[1], 10);
    const left = A - B * 2;
    if (left < 0) {
      console.log(0);
    ] else {
      console.log(left);
    }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
    const args = input.split('　');
    const A = parseInt(args[0], 10),
          B = parseInt(args[1], 10);
    const left = A - B * 2;
    if (left < 0) console.log(0);
    console.log(left);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
    const args = input.split(' ');
    const A = parseInt(args[0], 10),
          B = parseInt(args[1], 10);
    const left = A - B * 2;
    if (left < 0) console.log(0);
    console.log(left);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import (
	"fmt"
)

const MOD = 1000000007

func ModAdd(a, b int64) int64 {
	return (a + b) % MOD
}

func ModMul(a, b int64) int64 {
	return a * b % MOD
}

func ModSub(a, b int64) int64 {
	r := (a%MOD - b%MOD) % MOD
	if r < 0 {
		r += MOD
	}
	return r
}

func ModDiv(a, b int64) int64 {
	return a % MOD * ModInv(b) % MOD
}

func ModPow(a, n int64) int64 {
	var r int64 = 1
	for n > 0 {
		if n&1 == 1 {
			r = r * a % MOD
		}
		a = a * a % MOD
		n >>= 1
	}
	return r
}

func ModInv(a int64) int64 {
	var b, u, v int64 = MOD, 1, 0
	for b > 0 {
		t := a / b
		a -= t * b
		a, b = b, a
		u -= t * v
		u, v = v, u
	}
	u %= MOD
	if u < 0 {
		u += MOD
	}
	return u
}

func main() {
	var A, B int
	fmt.Scanf("%d %d\n", &A, &B)

	if B*2 >= A {
		fmt.Println(0)
	} else {
		fmt.Println(A - B*2)

	}

}
//  [go]
package main

import (
  "fmt"
)

func maxInt(a ...int) int {m := a[0]; for _, x := range a {if x > m {m = x}}; return m}
func minInt(a ...int) int {m := a[0]; for _, x := range a {if x < m {m = x}}; return m}

func main() {
  var a, b int
  fmt.Scan(&a, &b)
  fmt.Println(maxInt(0, a - b*2))
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)
var out = bufio.NewWriter(os.Stdout)

func next() string {
	sc.Scan()
	return sc.Text()
}
func nextInt() int {
	a, _ := strconv.Atoi(next())
	return a
}
func nextInts(n int) []int {
	ret := make([]int, n)
	for i := 0; i < n; i++ {
		ret[i] = nextInt()
	}
	return ret
}

//var done []bool = make([]bool, 10)
//var memo []int = make([]int, 10)

//func fib(n int) int {
//	fmt.Println(n)
//	if n == 0 {
//		return 0
//	}
//	if n == 1 {
//		return 1
//	}
//	if done[n] {
//		fmt.Println("done" + fmt.Sprint(n))
//		return memo[n]
//	}
//	done[n] = true
//	memo[n] = fib(n-1) + fib(n-2)
//	return memo[n]
//}

var m map[string]int = make(map[string]int)
var mInt map[int]int = make(map[int]int)

//var dp []int = make([]int, n)

//func fib(n int) int {
//	dp[0] = 0
//	dp[1] = 1
//	for i := 2; i <= n; i++ {
//		dp[i] = dp[i-1] + dp[i-2]
//	}
//	return dp[n]
//}

func main() {
	sc.Split(bufio.ScanWords)
	defer out.Flush() // !!!!coution!!!! you must use Fprint(out, ) not Print()
	a := nextInt()
	b := nextInt()
	diff := a - b*2
	if diff > 0 {
	} else {
		diff = 0
	}
	fmt.Fprint(out, diff)

	//	var dp []int = make([]int, n)
	//	sort.Ints(ns)
	//	for i := 0; i < n-1; i++ {
	//		dp[i] = ns[i] * ns[i+1]
	//	}
	//	fmt.Fprint(out, dp[k-1])
}
//  [go]
package main

import "fmt"

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	ans := a - b * b
	if ans <= 0 {
		fmt.Println(0)
		return
	}
	fmt.Println(ans)
}
//  [go]
package main

import (
	"fmt"
	//"math"
    //"sort"
	//"strconv"
)

func main() {

	var N int

	var S string

	fmt.Scan(&N,&S)

	cnt :=0

	for i:=0;i<N-1;i++{
      
		if S[i:i+1] == S[i+1:i+2] {
			cnt++
		} 

	}

	fmt.Println(N-cnt)

}
//  [ruby]
a, b = gets.split.map(&:to_i)
puts [a - 2 * b, 0].max
//  [ruby]
inputs = gets.chomp.split(" ")
if inputs[0].to_i <= inputs[1].to_i * 2
  puts 0
else
  puts inputs[0].to_i - inputs[1].to_i*2
end
//  [ruby]
a, b = gets.chomp.split(' ').map(&:to_i)
if a > b * 2
  puts a - (b * 2)
else
  puts 0
end
//  [ruby]
a,b=gets.split.map(&:to_i);p a - (b*2) >= b ? a - (b*2) : 0
//  [ruby]
a,b = gets.chomp.split(" ").map(&:to_i)
if a>=b*2
  puts 0
else
  puts a-(2*b)
end
//  [ruby]
a, b = gets.chomp.split.map(&:to_i)

ans = a - 2*b

if ans < 0
  puts "0"
end

puts ans
//  [rust]

#![allow(unused)]

use std::io::stdin;
use std::str::FromStr;

fn input<T: FromStr>() -> Result<T, T::Err> {
    let mut buf = String::new();
    stdin().read_line(&mut buf).unwrap();
    buf.trim().parse()
}

fn input_vec<T: FromStr>() -> Result<Vec<T>, T::Err> {
    let mut buf = String::new();
    stdin().read_line(&mut buf).unwrap();
    buf.trim()
        .split_whitespace()
        .map(|x| x.parse())
        .collect()
}

use std::cmp::max;

fn main() {
    let (a, b): (i32, i32) = {
        let tmp = input_vec().unwrap();
        (tmp[0], tmp[1])
    };

    let ans = max(0, a - 2 * b);
    println!("{}", ans);
}
//  [rust]
/* {{{ */
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

fn main() {
    input! {
        a: i32,
        b: i32
    }
    println!("{}", std::cmp::max(a - b * 2, 0));
}
/* vim:set foldmethod=marker: */
//  [rust]

#![allow(unused)]

use std::io::stdin;
use std::str::FromStr;

fn input<T: FromStr>() -> Result<T, T::Err> {
    let mut buf = String::new();
    stdin().read_line(&mut buf).unwrap();
    buf.trim().parse()
}

fn input_vec<T: FromStr>() -> Result<Vec<T>, T::Err> {
    let mut buf = String::new();
    stdin().read_line(&mut buf).unwrap();
    buf.trim()
        .split_whitespace()
        .map(|x| x.parse())
        .collect()
}

use std::cmp::max;

fn main() {
    let (a, b): (i32, i32) = (input().unwrap(), input().unwrap());

    let ans = max(0, a - 2 * b);
    println!("{}", ans);
}
//  [rust]
fn read<T: std::str::FromStr>() -> T {
  let mut s = String::new();
  std::io::stdin().read_line(&mut s).ok();
  s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
  read::<String>().split_whitespace()
    .map(|e| e.parse().ok().unwrap()).collect()
}

fn read_vec2<T: std::str::FromStr>(n: u32) -> Vec<Vec<T>> {
  (0..n).map(|_| read_vec()).collect()
}

fn main() {
  let n: usize = read();
  let mut L: Vec<usize> = read_vec();

  L.sort_by(|a, b| a.cmp(b));

  let mut ans = 0;

  for i in 0..n-2 {
    for j in i+1..n-1 {
      let ab = L[i] + L[j];
      let mut l = j;
      let mut r = n;
      while r-l > 1 {
        let mut m = (l+r)/2;
        if ab > L[m] {
          l = m;
        } else {
          r = m;
        }
      }
      ans += l-j;
    }
  }

  println!("{}", ans);
}
//  [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 a: u32 = read();
    let b: u32 = read();
	if b*2 <= a {
		println!("{}", b*2-a);
	} else {
		println!("0");
	}
}
//  [swift]
let input_line = readLine()!.characters.split{$0==" "}.map { Int(String($0))! }
let a = input_line[0]
let b = input_line[1]
let value = a - (b * 2)
if value < 0 {
	print(0)
} else {
	print(value)
}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
    
let ab = readInts()
let a = ab[0]
let b = ab[1]
if a-2*b>0{
  print(a-2*b)
}else{
  print(0)
}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func main() {
    let ab = readInts()
    if ab[0] < ab[1] * 2 {
        print("0")
    } else {
        print(ab[0] - ab[1] * 2)
    }
}

main()
//  [swift]
func LI() -> [Int] {
    return readLine()!.split(separator: " ").map{ Int{$0}! }
}

func I() -> Int {
    return Int(readLine()!)!
}

func S() -> String {
    return readLine()!
}

let line = LI()
print(max(0,line[0]-2*line[1]))
//  [swift]
func LI() -> [Int] {
    return readLine()!.split(separator: " ").map{ Int{$0}! }
}

func I() -> Int {
    return Int(readLine()!)!
}

func S() -> String {
    return readLine()!
}
int a
int b
a,b = LI()
print(max(0,a-2*b))
//  [swift]
func LI() -> [Int] {
    return readline()!.split(separator: " ").map{ Int{$0}! }
}

func I() -> Int {
    return Int(readline()!)!
}

func S() -> String {
    return readline()!
}
int a,b
a,b = LI()
print(max(0,a-2*b))
//  [typescript]
const main = (input) => {
  const [houseW, curtainW] = input.split(' ');
  console.log( eval(houseW - eval(curtainW * 2)) > 0 ? eval(houseW - (curtainW * 2)) : 0 );  
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [typescript]
import * as fs from 'fs'
import {debug} from '../util'

const input = fs.readFileSync('/dev/stdin', 'utf8').split(' ')

const a = parseInt(input[0], 10)
const b = parseInt(input[1], 10)

const result = a - b * 2

result > 0 ? console.log(result) : console.log(0)
//  [typescript]
import * as fs from 'fs';

const input = fs.readFileSync("/dev/stdin", "utf8").split(" ");
const a = +input[0];
const b = +input[1];

const res = a - b * 2;

if (res > 0) {
  console.log(res);
} else {
  console.log(0);
}
//  [typescript]
import * as fs from 'fs';

const input = fs.readFileSync("/dev/stdin", "utf8");


const a = +input[0];
const b = +input[1];

if (res > 0) {
    console.log(res);
} else {
    console.log(0);
}
//  [typescript]
import * as fs from "fs";

function main(input: string[]) {
  const windowWidth = parseInt(input[0]);
  const cartainWidth = parseInt(input[1]) * 2;

  const uncoveredWidth = Math.min(windowWidth, cartainWidth);
}

main(fs.readFileSync("/dev/stdin", "utf8").split(" "));
//  [typescript]
import * as fs from "fs";
const input = fs.readFileSync("/dev/stdin", "utf8");

const A = input.split("");
let a = Number(A[0]);
let b = Number(A[1]);
const res = a - b * 2;
if (res > 0) {
  console.log(res);
} else {
  console.log(0);
}
//  [python]
A, B, C = map(int, input().split())

if A == B:
    print(C)
elif B == C:
    print(A)
else:
    print(B)
//  [python]
a, b, c = [int(i) for i in input().split()]

if a == b:
	print(c)
elif b == c:
	print(a)
else:
	print(b)
//  [python]
a,b,c=map(int,input().split())
if a==b:
    print(c)
elif a==c:
    print(b)
else:
    print(a)
//  [python]
a,b,c = map(int,input().split())
if a != b and a == c:
    print(a)
else:
    print(b)
//  [python]
a,b,c=map(int,input().split())

if a==b:
    ans=c
elif b==c:
    ans=a
else:
    ans=b
print(a+b+c-ans)
//  [python]
a,b,c=map(int,input().split())

if a==b:
    ans=c
elif b==c:
    ans=a:
else:
    ans=b
print(a+b+c-ans)
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String input = br.readLine();
		
		String[] tmpArray = input.split(" ");
		
		if(tmpArray[1].equals(tmpArray[2])){
			System.out.println(tmpArray[0]);
		}
		if(tmpArray[2].equals(tmpArray[0])){
			System.out.println(tmpArray[1]);
		}
		if(tmpArray[1].equals(tmpArray[0])){
			System.out.println(tmpArray[2]);
		}
		
	}

}
//  [java]
import java.util.*;
import java.io.*;

public class Main {
    BufferedReader br;
    PrintWriter out;
    StringTokenizer stok;

    String nextToken() throws IOException {
        while (stok == null || !stok.hasMoreTokens()) {
            String s = br.readLine();
            if (s == null) {
                return null;
            }
            stok = new StringTokenizer(s);
        }
        return stok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    char nextChar() throws IOException {
        return (char) (br.read());
    }

    String nextLine() throws IOException {
        return br.readLine();
    }

    void solve() throws IOException {
        int a = nextInt();
        int b = nextInt();
        int c = nextInt();
        if (a==b) out.println(c);
        if (a==c) out.println(b);
        if (c==b) out.println(a);

    }

    void run() throws IOException {
        // br = new BufferedReader(new FileReader("dragons.in"));
        //out = new PrintWriter("dragons.out");
        // br = new BufferedReader(new FileReader("input.txt"));
        // out = new PrintWriter("output.txt");
        br = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        solve();
        br.close();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        // Locale.setDefault(Locale.US);
        new Main().run();
    }
}
//  [java]
import java.util.*;
import java.io.*;

public class Main {
	
	public static void main(String[] args) throws IOException {
		InputReader in = new InputReader(System.in);
		int a = in.readInt();
		int b = in.readInt();
		int c = in.readInt();
		if(a == c ) System.out.println(b);
		else if(a == b) System.out.println(c);
		else System.out.println(a);
	}
}
class InputReader {

	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	public int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int readInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public String readString() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	public long readLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9') {
				throw new InputMismatchException();
			}
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}
	
	public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	public String next() {
		return readString();
	}

	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}
//  [java]
/**
 * 
 */
package One_out_of_Three;
  
import java.util.Scanner;

public class Main {


	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ
      
		Scanner scanner = new Scanner(System.in);
		int A = scanner.nextInt();
    	int B = scanner.nextInt();
    	int C = scanner.nextInt();
		if(A==B){
			System.out.println(C);
	    }
    	if(B==C){
    		System.out.println(A);
    	}
		if(A==C){
    		System.out.println(B);
    	}
		
      
      
	}

}
//  [java]
/**
 * 
 */
package One_out_of_Three;
  
import java.util.Scanner;

public class Main {


	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ
		int A = scanner.nextInt();
    	int B = scanner.nextInt();
    	int C = scanner.nextInt();
		if(A==B){
			System.out.println(C);
	    }
    	if(B==C){
    		System.out.println(A);
    	}
		if(A==C){
    		System.out.println(B);
    	}
		
      
      
	}

}
//  [cpp]
#include <cstdio>

int main(){
int a,b,c;
scanf("%d %d %d",&a,&b,&c);
if(a==b) printf("%d",c);
if(a==c) printf("%d",b);
if(b==c) printf("%d",a);
return 0;
}
//  [cpp]
#include<cstdio>
int main()
{
	int a,b,c;
	scanf("%d %d %d",&a,&b,&c);
	if(a==b) printf("%d",c); else if(a==c) printf("%d",b); else if (b==c) printf("%d",a);
	return 0;
}
//  [cpp]
#include<stdio.h>
int main(){
    int a,b,c;
    while(scanf("%d%d%d",&a,&b,&c)!=EOF){
        if(a==b)
            printf("%d\n",c);
        else if(a==c)
            printf("%d\n",b);
        else if(b==c)
            printf("%d\n",a);

    }
    return 0;
}
//  [cpp]
int main() {
  int a,b,c;
  cin >>a>>b>>c;
  if(a==b) cout <<c<<endl;
  if(b==c) cout <<a<<endl;
  if(a==c) cout <<b<<endl;
  
}
//  [cpp]
#include<iostream>
using namespace std;
int main(){
  int a,b,c;
  cin>>a>>b>>c;
  if(a==b&&b!=c){
    cout<<c<<endl;
  }
  else(a!=b&&b==c){
    cout<<a<<endl;
  }
  else{
    cout<<b<<endl;
  }
  return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
  int a, b, c;
  cin >> a >> b >> c;
  if(a == b) cout << c << "\n";
  else{
    if(a == c) cout << b << "\n";
    e;se cout << a << "\n";
  }
}
//  [c]
#include <stdio.h>

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

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

	if (a == b) printf("%d\n", c);
	else if (b == c) printf("%d\n", a);
	else printf("%d\n", b);

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

int a,b,c;
int x;
void compare()
{
    if(a==b)
    {
        x=c;
    }

    else
        if(a==c)
        {
           x=b;
        }
        else
           x=a;
}
int main()
{
    scanf("%d %d %d",&a,&b,&c);
    compare();
    printf("%d\n",x);
    return 0;
}
//  [c]
#define _CRT_SECURE_NO_WARNINGS

//#define DEBUG
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>


int main(){
#ifdef DEBUG
	
#endif
	int A, B, C;
	int ans;
	scanf("%d %d %d", &A, &B, &C);

	if (A == B) {
		ans = C;
	}
	else if (A == C) {
		ans = B;
	}
	else {
		ans = A;
	}

	printf("%d\n", ans);
}
//  [c]
#include<bits/stdc++.h>
using namespace std;
int main()
{
    int a,b,c;
    cin>>a>>b>>c;
    if(a==b){cout<<c;}
    else if(a==c){cout<<b;}
    else{cout<<a;}
}
//  [c]
#include<iostream>
using namespace std;
int main()
{
    int a,b,c;
    cin>>a>>b>>c;
    if(a==b){cout<<c;}
    else if(a==c){cout<<b;}
    else{cout<<a;}
}
//  [c]
#include <stdio.h>

int main(void){
  int A, B, C;
  scanf ("%d %d %d", &A, &B, &C);
  if ( A == B){
    printf("%d\n",C);
  } else if (A == C){
      printf("%d\n",C);
  }  else if (B == C){
      printf("%d\n",A);
  }
    return 0;   
   }
//  [javascript]
'use strict';

function Main(INPUT) {
    const input = INPUT.split("\n")[0].split(" ");
    if (input[0] == input[1]) {
        console.log(input[2]);
    } else {
        console.log(input[0] == input[2] ? input[1] : input[0]);
    }
}

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 (a == b){
        console.log("%d",c);
    } else if(a == c){
        console.log("%d",b);
    } else{
        console.log("%d",a);
    }
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict'

function main(s) {

  s = s.split('\n')[0].split(' ');
  let ans = '';
  
  if (s[0] !== s[1] && s[1] === s[2]) ans = s[0];
  if (s[0] !== s[1] && s[1] !== s[2]) ans = s[1];
  if (s[0] === s[1] && s[1] !== s[2]) ans = s[2];

  console.log(ans);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
  input = input.trim();
  const a = input.split(" ").map(Number);
  if(a[0]==a[1]){
    console.log(a[2]);
  }
  if(a[1]==a[2]){
    console.log(a[0]);
  }
  if(a[0]==a[2]){
    console.log(a[1]);
  }      
  console.log((a[0]*a[1])%2==0?'Even':'Odd');
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  input = input.trim()
  input = input.split(" ").map(Number);
if(input[0]!=input[1]&&input[0]=input[2]){

console.log(input[1])
}else if(input[0]==input[1]){

  console.log(input[2])
}else{
  console.log(input[0])
}
}Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	let array = input.split('\n');
	const h = array[0].split(' ')[0]*1
	const w = array[0].split(' ')[1]*1
	array = array.filter((elm,i)=>i>=1);

	const empty_num = input.match(/(\.)/g);

	if(!empty_num){
		//爆弾しかない
		console.log(array.join('\n'));
		
	}else if(empty_num.length==w*h){
		//爆弾がない
		console.log(array.join('\n').replace(/./g,'0'));

	}else{
		for(var i=0;i<array.length;i++){
			for(var j=0;j<array[i].length;j++){
				if(array[i][j]!='.') continue;
				u = !array[i-1]? null : array[i-1][j], //上
				d = !array[i+1]? null : array[i+1][j], //下
				r = j==w ? null : array[i][j+1], //右
				l = j==0 ? null : array[i][j-1], //左
				ur = !(u && r) ? null : array[i-1][j+1], //右上
				ul = !(u && l) ? null : array[i-1][j-1], //左上
				dr = !(d && r) ? null : array[i+1][j+1], //右下
				dl = !(d && l) ? null : array[i+1][j-1]; //左下
				var num = (u+r+d+l+ur+ul+dr+dl).match(/#/g);
				num = !num ? 0 : num.length;
				array[i] = array[i].replace('.', num);
			};
		}
		console.log(array.join('\n'));
	}
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import "fmt"

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

	if a == b {
		fmt.Println(c)
	} else if b == c {
		fmt.Println(a)
	} else {
		fmt.Println(b)
	}
}
//  [go]
package main

import (
  "fmt"
  "sort"
)

func main() {
  var a = make([]int, 3)
  for i := 0; i < 3; i++ {fmt.Scan(&a[i])}
  sort.Ints(a)
  var ans int
  if a[0] == a[1] {
    ans = a[2]
  } else {
    ans = a[0]
  }
  fmt.Println(ans)
}
//  [go]
/**
 *    author:  otera    
**/
#include<iostream>
#include<string> 
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<algorithm> 
#include<functional>
#include<iomanip>
#include<queue>
#include<deque>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
using namespace std;

//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
typedef long double ld;
const int inf=1e9+7;
const ll INF=1LL<<60 ;
const ll mod=1e9+7 ;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef complex<ld> Point;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<int, int> P;
typedef pair<ld, ld> LDP;
typedef pair<ll, ll> LP;
#define fr first
#define sc second
#define all(c) c.begin(),c.end()
#define pb push_back
#define debug(x)  cerr << #x << " = " << (x) << endl;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }

void solve() {
	map<int, int> mp;
    rep(i, 3) {
        int a; cin >> a;
        mp[a] ++;
    }
    for(P p: mp) {
        if(p.sc == 1) {
            cout << p.fr << endl;
        }
    }
}

signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	//cout << fixed << setprecision(10);
	//int t; cin >> t; rep(i, t)solve();
	solve();
    return 0;
}
//  [go]
package main

import "fmt"


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

import (
	"fmt"
)

func main() {
	var A, B, C int
	var ans string
	fmt.Scan(&A, &B, &C)

	if A == B {
		ans = C
	} else if B == C {
		ans = A
	} else {
		ans = B
	}

	fmt.Println(ans)
}
//  [ruby]
a=gets.split.map(&:to_i).sort;p a[0] == a[1] ? a[2] : a[0]
//  [ruby]
puts (gets.chomp.split.group_by(&:itself)
  .select{|_k, v| v.size == 1}.first.first)
//  [ruby]
#!/usr/bin/env ruby
# require 'pry'

a,b,c = gets.split(' ').map(&:to_i)

if a == b
  puts c
elsif
  a == c
  puts b
else
  puts a
end
//  [ruby]
a,b,c=gets.split.map(&:to_i)
p a==b ? c : a==c ? b :c
//  [ruby]
a,b,c = gets.chomp.split.map(&:to_i)
if a == b
    print(c)
elsif a == c
    print(b)
else
    print(a)
//  [ruby]
puts gets.split.map(&:to_i).goup_by(&:itself).select{|k,v|v.size==1}.values[0]
//  [rust]
use std::io;

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

fn main() {
	let v:Vec<i32> = procon_read();
	let a = v[0];
	let b = v[1];
	let c = v[2];
	if b-a == 0 {
		println!("{}", c);
	}else if c-a == 0 {
		println!("{}", b);
	}else{
		println!("{}", a);
	}
}
//  [rust]
use std::str::FromStr;
use std::fmt::Debug;
use std::cmp;
#[allow(dead_code)]
fn read_as_vec<T>() -> Vec<T>
where T: FromStr, <T as FromStr>::Err : Debug{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().split_whitespace().map(|c| T::from_str(c).unwrap()).collect()

}

#[allow(dead_code)]
fn read_as_string() -> String{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().to_string()
}

fn main(){
    let line = read_as_vec::<i64>();
    let (a, b, c) = (line[0], line[1], line[2]);

    println!("{}", a ^ b ^ c);
}
//  [rust]
#[allow(unused_imports)]
use std::char::*;
#[allow(unused_imports)]
use std::cmp::*;
#[allow(unused_imports)]
use std::collections::*;

#[allow(unused_macros)]
macro_rules! debug {($($a:expr),*) => {println!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);}}
#[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 ) * } } ; }
#[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 , usize1 ) => { read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( "Parse error" ) } ; }

#[derive(PartialEq, PartialOrd)]
pub struct Total<T>(pub T);
impl<T: PartialEq> Eq for Total<T> {}
impl<T: PartialOrd> Ord for Total<T> { fn cmp(&self, other: &Total<T>) -> std::cmp::Ordering { self.0.partial_cmp(&other.0).unwrap() }}

#[allow(dead_code)]
const MAX:usize = 100006;
#[allow(dead_code)]
const INF_U32:u32 = 1 << 31;
#[allow(dead_code)]
const INF_I32:i32 = 1 << 30;
#[allow(dead_code)]
const INF_U64:u64 = 1 << 63;
#[allow(dead_code)]
const INF_I64:i64 = 1 << 62;


fn main() {
    input! {a:i32,b:i32,c:i32};

    println!("{}",
        if a == b {c}
        else if b == c {a}
        else {b}
    );

}
//  [rust]
use std::io;

fn main() {
	// reading H W 
	let mut line = String::new();
	io::stdin().read_line(&mut line).unwrap();
	let vec : Vec<&str> = line.split_whitespace().collect();

	let h : usize = vec[0].parse().unwrap();
	let w : usize = vec[1].parse().unwrap();

	// prepareing h x w grid
	let mut grid = vec![vec!['.'; w]; h];

	// reading strings which stand for empty squares and bomb squares
	for hi in 0..h {
		let mut line = String::new();
		io::stdin().read_line(&mut line).unwrap();
		
		let mut wi = 0;
		for c in line.trim_end().chars() {
			if c == '#' {
				grid[hi][wi] = '#';
			}
			wi += 1;
		}
	}
	
	// preparing arrays for neigher search
	let dw: [i64; 8] = [-1, 0, 1, -1, 1, -1, 0, 1];
	let dh: [i64; 8] = [-1, -1, -1, 0, 0, 1, 1, 1];

	// counting '#' adjacent to each '.' square in grid
	for hi in 0..h {
		let mut out_row = String::from("");
		for wi in 0..w {
			if grid[wi][hi] == '#' {
				out_row.push(grid[wi][hi]);
				continue;
			}

			let mut cnt = 0;
			for d in 0..8 {
				let nwi = wi as i64 + dw[d];
				let nhi = hi as i64 + dh[d];

				if nwi < 0 || nwi >= w as i64 {
					continue;
				}
				if nhi < 0 || nhi >= h as i64 {
					continue;
				}

				if grid[nwi as usize][nhi as usize] == '#' {
					cnt += 1;
				}
			}
			grid[wi][hi] = cnt.to_string().chars().next().unwrap();
			out_row.push(grid[wi][hi]);
		}
		println!("{}", out_row);
	}

	// output
	// for hi in 0..h {
	// 	let mut out_row = String::from("");
	// 	for wi in 0..w {
	// 		out_row.push(grid[wi][hi]);
	// 	}
	// 	println!("{}", out_row);
	// }
}
//  [rust]
use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {
        a:i32,
        b:i32,
        c:i32
    }
    if a != b && a != c {
        println!("{}", a);
    } else if b != a && b != c {
        println!("{}", b);
    } else {
        println!("{}", c);
    }
}