#include<stdio.h>
#include<stdlib.h>
int main(void){
    int num;
    int firstpoint;
    int score;
    int correct[100001];
    int point[100001];
    int minuspoint[100001]={};
    int ans=0;
    char str[20];

    scanf("%d%d%d\n",&num,&firstpoint,&score);

    for(int i=0;i<score;i++){
        gets(str);
        correct[i]=atoi(str);
        minuspoint[correct[i]-1]++;
    }

    for(int a=0;a<num;a++){
        if(firstpoint-score+minuspoint[a]>0){
            printf("Yes\n");
        }else{
            printf("No\n");
        }
    }
    return 0;

}


int main()
{
  int n, k, q;
  scanf("%d %d %d", &n, &k, &q);
  int point[n], i;
  for (i = 0; i < n; i++)
    point[i] = 0;
  int a[q];
  for (i = 0; i < q; i++)
  {
    scanf("%d", &a[i]);
    point[a[i] - 1]++;
  }
  int tmp = q - k;
  for (i = 0; i < n; i++)
  {
    if (point[i] > tmp)
    {
      printf("Yes\n");
    }
    else
    {
      printf("No\n");
    }
  }
}


#include <stdio.h>
#include <stdlib.h>

int main()
{
  int n,k,q,i,j,a;
  int *point;

  scanf("%d%d%d",&n,&k,&q );
  point = calloc(n,sizeof(int));
  for(i=0; i<n; i++)
    point[i] = k;

  for(i=0; i<q; i++){
    scanf("%d", &a);
      for(j=0; j<n; j++){
        if(j != a-1)
          point[j]--;
      }
  }

  for(i=0; i<n; i++)
  {
    if(point[i] > 0)
      puts("Yes");
    else
      puts("No");
  }
  free(point);
  return 0;
}


#ifndef LOCAL
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#else
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <memory>
#include <cctype>
#include <cstring>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <algorithm>
#include <numeric>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; }; sim > rge<c> range(c i, c j) { return rge<c>{i, j}; } sim > auto dud(c* x) -> decltype(cerr << *x, 0); sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; } eni(!=) cerr << boolalpha << i; ris; } eni(==) ris << range(begin(i), end(i)); } sim, class b dor(pair < b, c > d) { ris << "(" << d.first << ", " << d.second << ")"; } sim dor(rge<c> d) { *this << "["; for (auto it = d.b; it != d.e; ++it) *this << ", " + 2 * (it == d.b) << *it; ris << "]"; }
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// #define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>

template<typename T> void setmax(T& x, T y) {x = max(x, y);}
template<typename T> void setmin(T& x, T y) {x = min(x, y);}
#define fix(a) fixed << setprecision(a)
#define forn(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 all(V) V.begin(), V.end()
#define rall(V) V.rbegin(), V.rend()
#define len(V) (int)V.size()
#define ll long long
#define ld long double
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define endl '\n'

void solve(){
  int n, k, q;
  cin >> n >> k >> q;
  vector<int> m(n);
  forn(i,q){
    int a;
    cin >> a;
    a--;
    m[a]++;
  }
  rep(i,0,n){
    if(k+m[i]-q <= 0){
      cout << "No" << endl;
    } else {
      cout << "Yes" << endl;
    }
  }
}

int main() {
  ios::sync_with_stdio(false);
  // cin.tie(0); cout.tie(0);
  int t = 1;
  // cin >> t;
  forn(i, t){
    solve();
  }
}

/*

*/


#include <stdio.h>
int main()
{
  long long n,k,q;
  scanf("%lli%lli%lli",&n,&k,&q);
  long long p[n];
  long long t[q];
  for (long long i=0;i<q;i++) {
    scanf("%lli",&t[i]);
    p[t[i]-1] += 1;
  }
  for (long long i=0;i<n;i++) {
    if (k-q+p[i]>0) {
      printf("%s\n","Yes");
    } else {
      printf("%s\n","No");
    }
  }
  return 0;
}


function main(arg) {
	arg = arg.trim().split('\n');
  	var data = arg.shift().split(' ').map(str => parseInt(str, 10)),
        //参加者、ポイント、回答数
      	n = data[0], k = data[1], q = data[2],
        //正解者、pt数
        arg = arg.map(str => parseInt(str, 10)), pt = new Array(n).fill(0);
    //加点処理
  	for (var i = 0; i < q; i++) {
      pt[arg[i]-1] +=1
    }
  	//減点処理
  	for (var i = 0; i < n; i++) {
    	 pt[i] = pt[i]-(q-k);
    }
  	//1pt以上を判定
  	for (var i = 0; i < n; i++) {
    	pt[i] = (pt[i] > 0) ? 'Yes' : 'No';
    }
  	var out = pt.join('\n');
  console.log(out);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));


function Main(input) {
  data = input.split('\n');
  var N = data[0].split(' ')[0];
  var K = data[0].split(' ')[1];
  var Q = data[0].split(' ')[2];
  N = parseInt(N, 10);
  K = parseInt(K, 10);
  Q = parseInt(Q, 10);

  var A = input.split('\n');
  A.shift();
  for(var i = 0; i < Q; i++) {
    A[i] = parseInt(A[i], 10);
  }

  var C = [];
  for(var i = 0; i < N; i++) {
    C[i] = 0;
  }
  for(var i = 0; i < Q; i++) {
    C[A[i] - 1] += 1;
  }
    /*
    C = C.map((x)=>{
    var a;
    a = x - Q;
    a += K;
    return a;
  });
  */
  C = C.map(function(x) {
    var a;
    a = x - Q;
    a += K;
    return a;
  });

  for(var i = 0;i < N; i++) {
    if(C[i] > 0) {
      C[i] = 'Yes';
    } else {
      C[i] = 'No';
    }
  }

  console.log(C.join('\n'));
}
Main(require('fs').readFileSync('/dev/stdin', 'utf-8'));


"use strict";

const main = arg => {
    arg = arg.trim().split("\n");
    const N = parseInt(arg[0].split(" ")[0]);
    const K = parseInt(arg[0].split(" ")[1]);
    const Q = parseInt(arg[0].split(" ")[2]);

    const A = arg.slice(1, Q + 1).map(n=>parseInt(n));
    let points = new Array(N).fill(0);

    for(let i=0; i<Q; i++) {
        points[A[i]-1]++;
    }

    let answer = points.map(n=>(n + K) - Q > 0 ? "Yes" : "No");

    console.log(answer.join("\n"));
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


function Main(input){
    input = input.split('\n');

    tmp = input[0].split(" ");
    tmp= tmp.map(Number);
    const sankasha_N = tmp[0];
    const initPoints_K = tmp[1];
    const questions_Q = tmp[2];
    input.shift();
    input= input.filter(v => v);
    input = input.map(Number);

    //メンバの持ち点配列
    var memPoints = new Array(sankasha_N).fill(initPoints_K);

    var memPointsAF = [];

   input.map((v) => {
        memPoints = memPoints.map((vv,ii) => {
        if(v == ii+1){
            return vv;
        }else{
            return vv=vv-1;
        }
    });});
    memPoints.map((v) => {
        if(0 < v){
            console.log('Yes');
        }else{
            console.log('No');
        }
    });
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));


process.stdin.resume();
process.stdin.setEncoding('utf8');

var lines = []
var reader = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

reader.on('line', (line) => {
  lines.push(line);
});

reader.on('close', () => {
 var nkq = lines[0].split(' ');
 var n = Number(nkq[0]);
 var k = Number(nkq[1]);
 var q = Number(nkq[2]);
 var points = [];
 for(i=0; i<n; i++){
   points.push(k);
 }

 for(i=1; i<=q; i++){
   var num = Number(lines[i]);
   for(j=0; j<n; j++){
     if(j == num-1){
       continue;
     }
     points[j]--;
   }
 }

 for(i=0; i<n; i++){
   if(points[i] > 0){
     console.log('Yes');
   }else{
     console.log('No');
   }
 }
});


function main(arg) {
	arg = arg.trim().split('\n');
  	var data = arg[0].split(' ').map(str =>  parseInt(str, 10));
  	var n = data[0];//参加者
    var k = data[1];//pt
    var q = data[2];//正解数
  	var seikai = [];
    var ary = [];
  	var sei_long = q+1;
  	//正解者
  	for (var i = 1; i < sei_long; i ++) {
    	seikai.push(arg[i])
    }
  	//初期ポイント
    for (var i = 0; i < n; i++) {
    	ary.push(k);
    }
  	//不正解のみ減点正解者は処理をスキップ
    for (var i = 0; i < q; i++) {
      var num = seikai[i]-1;
    	for (var a = 0; a < n; a++) {
          	if (a == num){
               continue;
        	}
        	ary[a] = ary[a] -1;
        }
    }
  	//1pt以上に'yes'を返す
    for (var a = 0; a < n; a++) {
        ary[a] = (ary[a] = ary[a] > 0) ? 'Yes' : 'No';
      	console.log(ary[a]);
    }
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));


package main

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

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

	sc := bufio.NewScanner(os.Stdin)
	ans := make([]int, n)
	for i := 0; i < q; i++ {
		sc.Scan()
		a, _ := strconv.Atoi(sc.Text())
		ans[a-1]++
	}

	wr := bufio.NewWriter(os.Stdout)
	for _, v := range ans {
		if k-(q-v) > 0 {
			wr.WriteString("Yes\n")
			continue
		}
		wr.WriteString("No\n")
	}
	wr.Flush()
}


package main

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

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)
	sc.Scan()
	n, _ := strconv.Atoi(sc.Text())
	sc.Scan()
	k, _ := strconv.Atoi(sc.Text())
	slice := make([]int, n)
	sc.Scan()
	q, _ := strconv.Atoi(sc.Text())
	for i := 0; i < q; i++ {
		sc.Scan()
		An, _ := strconv.Atoi(sc.Text())
		slice[An-1]++
	}

	writer := bufio.NewWriter(os.Stdout)
	for i := 0; i < n; i++ {
		if slice[i]-q <= k*(-1) {
			writer.WriteString("No\n")
		} else {
			writer.WriteString("Yes\n")
		}
	}
	writer.Flush()
}


package main

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

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)

	sc.Scan()
	N, _ := strconv.Atoi(sc.Text())

	sc.Scan()
	K, _ := strconv.Atoi(sc.Text())

	sc.Scan()
	Q, _ := strconv.Atoi(sc.Text())

	A := make([]int, Q)
	for i := 0; i < Q; i++ {
		sc.Scan()
		A[i], _ = strconv.Atoi(sc.Text())
	}

	points := make([]int, N)
	for i := 0; i < N; i++ {
		points[i] = K - Q
	}

	for _, person := range A {
		points[person-1]++
	}

	writer := bufio.NewWriter(os.Stdout)
	for _, point := range points {
		if point > 0 {
			writer.WriteString("Yes\n")
		} else {
			writer.WriteString("No\n")
		}
	}
	writer.Flush()
}


package main

import "fmt"

func main() {
	var n, k, q int
	fmt.Scan(&n, &k, &q)
	seq := make([]int, q)
	point := make([]int, n)
	for i:=0; i<len(point); i++{
		point[i] = k
	}

	for i:=0; i<len(seq); i++{
		fmt.Scan(&seq[i])
		for j:=0; j<len(point); j++{
			if j != seq[i]-1{
				point[j]--
			}
		}
	}

	fmt.Println("-----")
	for i:=0; i<len(point); i++{
		if point[i] >= 1{
			fmt.Println("Yes")
		}else {
			fmt.Println("No")
		}
	}

}


package main

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

func main() {
	N, K, Q := getStdinInt3()
	Pt := make([]int, N)
	for i := 0; i < N; i++ {
		Pt[i] = K
	}
	for i := 0; i < Q; i++ {
		A := getStdinInt()
		for n := 0; n < N; n++ {
			if n != A-1 {
				Pt[n]--
				if Pt[n] <= 0 {
					Pt[n] = -1000000
				}
			}
		}
	}
	for i := 0; i < N; i++ {
		if Pt[i] > 0 {
			fmt.Printf("Yes\n")
		} else {
			fmt.Printf("No\n")
		}
	}
}

var sc = bufio.NewReaderSize(os.Stdin, 1024*1024*10)

func getStdin() string {
	return readLine()
}
func getStdinInt() int {
	str := getStdin()
	rtn, _ := strconv.Atoi(str)
	return rtn
}
func getStdinInt2() (int, int) {
	list := getStdinIntArr()
	return list[0], list[1]
}
func getStdinInt3() (int, int, int) {
	list := getStdinIntArr()
	return list[0], list[1], list[2]
}
func getStdinInt64() int64 {
	str := getStdin()
	rtn, _ := strconv.ParseInt(str, 10, 64)
	return rtn
}
func getStdinIntU64() uint64 {
	str := getStdin()
	rtn, _ := strconv.ParseInt(str, 10, 64)
	return uint64(rtn)
}
func getStdinInt64_2() (int64, int64) {
	list := getStdinIntArr64()
	return list[0], list[1]
}
func getStdinInt64_3() (int64, int64, int64) {
	list := getStdinIntArr64()
	return list[0], list[1], list[2]
}
func getStdinIntArr() []int {
	str := getStdin()
	list := strings.Split(str, " ")
	rtn := make([]int, len(list))
	for idx, val := range list {
		rtn[idx], _ = strconv.Atoi(val)
	}
	return rtn
}
func getStdinIntArr64() []int64 {
	str := getStdin()
	list := strings.Split(str, " ")
	rtn := make([]int64, len(list))
	for idx, val := range list {
		rtn[idx], _ = strconv.ParseInt(val, 10, 64)
	}
	return rtn
}
func getStdinIntArrU64() []uint64 {
	str := getStdin()
	list := strings.Split(str, " ")
	rtn := make([]uint64, len(list))
	for idx, val := range list {
		r, _ := strconv.ParseInt(val, 10, 64)
		rtn[idx] = uint64(r)
	}
	return rtn
}
func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}
func min64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}
func max(a, b int) int {
	if a < b {
		return b
	}
	return a
}
func max64(a, b int64) int64 {
	if a < b {
		return b
	}
	return a
}
func abs(n int) int {
	if n < 0 {
		return -n
	}
	return n
}
func abs64(n int64) int64 {
	if n < 0 {
		return -n
	}
	return n
}
func readLine() string {
	buf := make([]byte, 0, 0)
	for {
		l, p, _ := sc.ReadLine()
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}


package main

import (
	"fmt"
)

func main() {

	var N, K, Q int
	fmt.Scanf("%d %d %d", &N, &K, &Q)

	point := make(map[int]int, N)
	for i := 0; i < N; i++ {
		point[i+1] = K
	}

	var A int
	for i := 0; i < Q; i++ {
		fmt.Scanf("%d", &A)
		for i := 0; i < N; i++ {
			point[i+1]--
		}
		point[A]++
	}

	for i := 0; i < N; i++ {
		if point[i+1] > 0 {
			fmt.Println("Yes")
		} else {
			fmt.Println("No")
		}
	}
}


n,k,q = gets.split.map(&:to_i)
a = Array.new(n,0)
q.times do
    a[gets.to_i-1] += 1
end
ans = ""
a.each {|i|
    if k - q + i > 0
        ans << "Yes\n"
    else
        ans << "No\n"
    end
}

puts ans


n, k, q = gets.split.map(&:to_i)
p = [k - q] * n
q.times { p[gets.to_i - 1] += 1}
puts p.map { |j| j > 0 ? 'Yes' : 'No'}.join("\n")


# frozen_string_literal: true

N, K, Q = gets.split.map(&:to_i)
count = Array.new(N) { K }
Q.times { count[gets.to_i.pred] += 1 }

N.times { |i| puts count[i] - Q > 0 ? 'Yes' : 'No' }


N, K, Q = gets.split.map &:to_i
ans = Array.new(N, K)

Q.times do
  a = gets.to_i - 1
  ans.each_with_index do |e, idx|
    ans[idx] += -1 unless idx == a
  end
end

ans.each do |e|
  if e <= 0
    puts 'No'
  else
    puts 'Yes'
  end
end


n,k,q=gets.split.map(&:to_i)
a=Array.new(q)
q.times do |i|
    a[i]=gets.to_i
end

n.times do |i|
    if k-q+a.count(i+1)>0
        puts "Yes"
    else
        puts "No"
    end
end


n,k,q = gets.strip.split.map(&:to_i)
array = []
while number = gets
  array << number.chomp.to_i
end
(1..n).each do |x|
  if k-q+array.count(x)>0
    puts "Yes"
  else
    puts "No"
  end
end


/*------------------------------------------------------------------*/
/*------------------------- begin template -------------------------*/
/*------------------------------------------------------------------*/

// ref: tanakh <https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8>
// diff: using Parser
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut parser = Parser::from_str($s);
        input_inner!{parser, $($r)*}
    };
    (parser = $parser:ident, $($r:tt)*) => {
        input_inner!{$parser, $($r)*}
    };
    (new_stdin_parser = $parser:ident, $($r:tt)*) => {
        let stdin = std::io::stdin();
        let reader = std::io::BufReader::new(stdin.lock());
        let mut $parser = Parser::new(reader);
        input_inner!{$parser, $($r)*}
    };
    ($($r:tt)*) => {
        input!{new_stdin_parser = parser, $($r)*}
    };
}

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

macro_rules! read_value {
    ($parser:ident, ( $($t:tt),* )) => {
        ( $(read_value!($parser, $t)),* )
    };
    ($parser:ident, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($parser, $t)).collect::<Vec<_>>()
    };
    ($parser:ident, chars) => {
        read_value!($parser, String).chars().collect::<Vec<char>>()
    };
    ($parser:ident, char_) => {
        read_value!($parser, String).chars().collect::<Vec<char>>()[0]
    };
    ($parser:ident, usize1) => {
        read_value!($parser, usize) - 1
    };
    ($parser:ident, i64_) => {
        $parser.fast_i64()
    };
    ($parser:ident, usize_) => {
        $parser.fast_i64() as usize
    };
    ($parser:ident, usize1_) => {
        ($parser.fast_i64() - 1) as usize
    };
    ($parser:ident, $t:ty) => {
        $parser.next::<$t>().expect("Parse error")
    };
}

use std::io;
use std::io::BufRead;
use std::str;

// ref: tatsuya6502 <https://qiita.com/tatsuya6502/items/cd448486f7ef7b5b8c7e>
// ref: wariuni <https://qiita.com/tatsuya6502/items/cd448486f7ef7b5b8c7e#comment-7040a5ae96305e884eb9>
// diff: using std::io::BufRead::fill_buf()
pub struct Parser<R> {
    pub reader: R,
    buf: Vec<u8>,
    pos: usize,
}

impl Parser<io::Empty> {
    pub fn from_str(s: &str) -> Parser<io::Empty> {
        Parser {
            reader: io::empty(),
            buf: s.as_bytes().to_vec(),
            pos: 0,
        }
    }
}

impl<R: BufRead> Parser<R> {
    pub fn new(reader: R) -> Parser<R> {
        Parser {
            reader: reader,
            buf: vec![],
            pos: 0,
        }
    }
    pub fn update_buf(&mut self) {
        self.buf.clear();
        self.pos = 0;
        loop {
            let (len, complete) = {
                let buf2 = self.reader.fill_buf().unwrap();
                self.buf.extend_from_slice(buf2);
                let len = buf2.len();
                (len, buf2[len - 1] <= 0x20)
            };
            self.reader.consume(len);
            if complete {
                break;
            }
        }
    }
    pub fn next<T: str::FromStr>(&mut self) -> Result<T, T::Err> {
        loop {
            let mut begin = self.pos;
            while begin < self.buf.len() && (self.buf[begin] <= 0x20) {
                begin += 1;
            }
            let mut end = begin;
            while end < self.buf.len() && (self.buf[end] > 0x20) {
                end += 1;
            }
            if begin != self.buf.len() {
                self.pos = end;
                return unsafe { str::from_utf8_unchecked(&self.buf[begin..end]) }.parse::<T>();
            } else {
                self.update_buf();
            }
        }
    }
    pub fn fast_i64(&mut self) -> i64 {
        loop {
            let mut begin = self.pos;
            while begin < self.buf.len() && (self.buf[begin] <= 0x20) {
                begin += 1;
            }
            if begin == self.buf.len() {
                self.update_buf();
                continue;
            }
            let mut res = 0;
            let (is_positive, mut end) = match self.buf[begin] {
                b'+' => (true, begin + 1),
                b'-' => (false, begin + 1),
                _ => (true, begin),
            };
            while end < self.buf.len() && (self.buf[end] > 0x20) {
                res = res * 10 + (self.buf[end] as i64 - '0' as i64);
                end += 1;
            }
            if begin != self.buf.len() {
                self.pos = end;
                return if is_positive { res } else { -res };
            } else {
                self.update_buf();
            }
        }
    }
}

#[allow(unused_imports)]
use std::cmp::*;

fn main() {
    input! {
        new_stdin_parser = parser,
    }
    let res = solve(&mut parser);
    print!("{}", res);
}

/*------------------------------------------------------------------*/
/*-------------------------- end template --------------------------*/
/*------------------------------------------------------------------*/

use std::fmt::Write;
fn solve<R: BufRead>(parser: &mut Parser<R>) -> String {
    let mut buf = String::new();
    input! {
        parser = parser,
        n: usize,
        m: i64,
        q: usize,
        xs: [usize1; q],
    }
    let mut count = vec![0i64; n];
    for &x in &xs {
        count[x] += 1;
    }
    for i in 0..n {
        writeln!(
            buf,
            "{}",
            if q as i64 - count[i] < m { "Yes" } else { "No" }
        );
    }
    buf
}


macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let mut $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")
    };
}

use std::io::{stdout, Write, BufWriter};
// use std::cmp::{max};

fn main() {
    input! {
        n: usize,
        k: u32,
        q: usize,
        a: [usize; q],
    }

    let out = stdout();
    let mut out = BufWriter::new(out.lock());

    let mut t: Vec<u32> = vec![0; n];
    for a_ in a { t[a_ - 1] += 1 }
    for i in t {
        if i + k > q as u32 { writeln!(out, "Yes").unwrap(); }
        else { writeln!(out,"No").unwrap(); }
    }
}


// Template from https://techracho.bpsinc.jp/jhonda/2019_08_05/78537

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

#[allow(unused_macros)]
macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

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

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

#[allow(unused_macros)]
macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

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

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

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

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

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

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

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

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

test! {
r#"6 3 4
3
1
3
2"# => r#"No
No
Yes
No
No
No
"#,
}

fn solve(src: &str) -> String {
    input! {
        source = src,
        n: usize, k: usize, q: usize,
        a: [usize; q],
    }
    let mut pa = vec![k; n];

    for i in 0..q {
        pa[a[i] - 1] += 1;
    }

    let mut ans = "".to_string();
    for i in 0..n {
        ans.push_str(if pa[i] > q { "Yes" } else { "No" });
        ans.push_str("\n");
    }

    ans.to_string()
}


use proconio::{fastout, input};
use std::collections::BTreeMap;

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

    let a: Vec<i64> = a.iter().map(|x| x - 1).collect();
    let mut v: Vec<i64> = vec![k; n];
    let mut map = BTreeMap::new();

    for i in a.iter() {
        let count = map.entry(i).or_insert(0);
        *count += 1;
    }

    for (&key, value) in &map {
        v = v.iter().map(|x| x - value).collect();
        v[*key as usize] += *value as i64;
    }

    for &i in v.iter() {
        if i <= 0 {
            println!("No");
        } else {
            println!("Yes");
        }
    }

    // for i in 0..n as usize {
    //     let x = a.iter().filter(|&x| *x == i as i64).count();
    //     if k - (q as i64 - x as i64) > 0 {
    //         println!("Yes");
    //     } else {
    //         println!("No");
    //     }
    // }
}


use proconio::{fastout, input};

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

    let a: Vec<i64> = a.iter().map(|x| x - 1).collect();
    let mut v: Vec<i64> = vec![k; n];

    for &i in a.iter() {
        v = v.iter().map(|x| x - 1).collect();
        v[i as usize] += 1;
    }

    for &i in v.iter() {
        if i <= 0 {
            println!("No")
        } else {
            println!("Yes")
        }
    }

    // for i in 0..n as usize {
    //     let x = a.iter().filter(|&x| *x == i as i64).count();
    //     if k - (q as i64 - x as i64) > 0 {
    //         println!("Yes");
    //     } else {
    //         println!("No");
    //     }
    // }
}


use proconio::{fastout, input};

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

    let a: Vec<i64> = a.iter().map(|x| x - 1).collect();

    for i in 0..n as usize {
        let x = a.iter().filter(|&x| *x == i as i64).count();
        if k - (q as i64 - x as i64) > 0 {
            println!("Yes");
        } else {
            println!("No");
        }
    }
}


// 🐋💭
import Foundation

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

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

///最大公約数を返す
func gcd(_ m:Int, _ n:Int) -> Int {
    if n == 0 {return m}
    return gcd(n, m % n)
}

///素数判定(試し割り)
func isPrime(_ x:Int) -> Bool {
    if x <= 1 || x % 2 == 0 { return false }
    if x == 2 { return true }
    for i in stride(from: 3, to: Int(ceil(sqrt(Double(x)))), by: 2){
        if x % i == 0 {
            return false
        }
    }
    return true
}

//https://program-life.com/669
///実行速度の計測
func exectionTime(action: () -> Void) {
    let startDate = Date()
    action()
    let endDate = Date()
    print(endDate.timeIntervalSince(startDate))
}

// https://melheaven.hatenadiary.jp/entry/atcoder144
///約数の配列を返す
func makeDivisors(_ n:Int) -> [Int] {
    var divisors = [Int]()
    for i in 1..<Int(pow(Double(n), 0.5)) + 1 {
        if n % i == 0{
            divisors.append(i + n / i)
        }
    }

    return divisors
}

//https://riptutorial.com/ja/swift/example/14738/インデックスを知らずに配列から要素を削除する
extension Array where Element: Equatable {

    mutating func remove(_ element: Element) {
        _ = index(of: element).flatMap {
            self.remove(at: $0)
        }
    }
}

func binarySearch(rifgt:Int, key:Int, ary:[String]) -> Int{
    var left = 0
    var right = rifgt

    while abs(right - left) > 1 {
        let mid = left + (right - left) / 2

        if Int(ary[mid])! < key {
            left = mid

        } else {
            right = mid
        }
    }
    return left
}

func arrangement (prev:String, ary:[String], returnVal:[String]) -> [String] {
    var returnVal = returnVal
    if ary.count == 0 {
        returnVal.append(prev)
        return returnVal
    }

    for s in ary {
        let wprev = prev + s
        var wary = ary
        wary.remove(s)
        returnVal = arrangement(prev: wprev, ary: wary, returnVal: returnVal)
    }
    return returnVal
}

func main() {
    let nkq = readInts()
    let (n, k, q) = (nkq[0], nkq[1], nkq[2])

    var aryPoints = [Int](repeating: k - q, count: n)

    for _ in 1...q {
        aryPoints[readInt() - 1] += 1
    }

    for i in aryPoints {
        print(i > 0 ? "Yes": "No")
    }
}

main()


var X = readLine()!.characters.split{$0==" "}.map{Int(String($0))!}

var N = X[0]
var K = X[1]
var Q = X[2]
var A = [Int]()
for _ in 0..<N {
    A.append(K - Q)
}

for _ in 0..<Q {
    let n: Int = Int(readLine()!)!
    A[n-1] += 1
}

for i in 0..<N {
    if A[i] > 0 {
        print("Yes")
    }else {
        print("No")
    }
}


var arr=readLine()!.characters.split{$0==" "}.map{Int(String($0))!}

var n = arr[0]
var k = arr[1]
var q = arr[2]

var p = Array(count: n, repeatedValue: 0 )

var i = 0
var a = 0
for i in 0..<q {
  a=Int(readLine()!)!
  p[a-1] += 1
}

i = 0
for i in 0..<n {
  if( ( k - q + p[i] ) > 0) {
    print( "Yes" )
  } else {
    print( "No" )
  }
}


// 🐋💭
import Foundation

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

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

///最大公約数を返す
func gcd(_ m:Int, _ n:Int) -> Int {
    if n == 0 {return m}
    return gcd(n, m % n)
}

///素数判定(試し割り)
func isPrime(_ x:Int) -> Bool {
    if x <= 1 || x % 2 == 0 { return false }
    if x == 2 { return true }
    for i in stride(from: 3, to: Int(ceil(sqrt(Double(x)))), by: 2){
        if x % i == 0 {
            return false
        }
    }
    return true
}

//https://program-life.com/669
///実行速度の計測
func exectionTime(action: () -> Void) {
    let startDate = Date()
    action()
    let endDate = Date()
    print(endDate.timeIntervalSince(startDate))
}

// https://melheaven.hatenadiary.jp/entry/atcoder144
///約数の配列を返す
func makeDivisors(_ n:Int) -> [Int] {
    var divisors = [Int]()
    for i in 1..<Int(pow(Double(n), 0.5)) + 1 {
        if n % i == 0{
            divisors.append(i + n / i)
        }
    }

    return divisors
}

//https://riptutorial.com/ja/swift/example/14738/インデックスを知らずに配列から要素を削除する
extension Array where Element: Equatable {

    mutating func remove(_ element: Element) {
        _ = index(of: element).flatMap {
            self.remove(at: $0)
        }
    }
}

func binarySearch(rifgt:Int, key:Int, ary:[String]) -> Int{
    var left = 0
    var right = rifgt

    while abs(right - left) > 1 {
        let mid = left + (right - left) / 2

        if Int(ary[mid])! < key {
            left = mid

        } else {
            right = mid
        }
    }
    return left
}

func arrangement (prev:String, ary:[String], returnVal:[String]) -> [String] {
    var returnVal = returnVal
    if ary.count == 0 {
        returnVal.append(prev)
        return returnVal
    }

    for s in ary {
        let wprev = prev + s
        var wary = ary
        wary.remove(s)
        returnVal = arrangement(prev: wprev, ary: wary, returnVal: returnVal)
    }
    return returnVal
}

func main() {
    let nkq = readInts()
    let (n, k, q) = (nkq[0], nkq[1], nkq[2])

    var aryPoints = [Int](repeating: k, count: n)
    for _ in 1...q {
        let answer = readInt()
        for i in 0..<n {
            if i + 1 != answer {
                aryPoints[i] -= 1
            }
        }
    }
    for i in 0..<n {
        print(aryPoints[i] > 0 ? "Yes": "No")
    }
}

main()


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


import Foundation
import CoreFoundation

#if swift(>=4.0)
prefix operator *
infix operator **: PowerPrecedence
precedencegroup PowerPrecedence {
    higherThan: MultiplicationPrecedence
    lowerThan: BitwiseShiftPrecedence
    associativity: right
}
#else
extension String {
    func split(separator separator: Character) -> [String] {
        return self.characters.split(separator).map{String($0)}
    }
    var count: Int {
        return self.characters.count
    }
    var first: Character? {
        return self.characters.first
    }
    var last: Character? {
        return self.characters.last
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
    func reversed() -> ReverseCollection<String.CharacterView> {
        return self.characters.reverse()
    }
    func forEach(body: (Character) -> Void) {
        return self.characters.forEach{body($0)}
    }
    func map<T>(transform: (Character) -> T) -> [T] {
        return self.characters.map{transform($0)}
    }
    func reduce<Result>(initialResult: Result, _ nextPartialResult: (Result, Character) -> Result) -> Result {
        return self.characters.reduce(initialResult){nextPartialResult($0, $1)}
    }
    func filter(isIncluded: (Character) -> Bool) -> String {
        return String(self.characters.filter{isIncluded($0)})
    }
    func enumerated() -> EnumerateSequence<String.CharacterView> {
        return self.characters.enumerate()
    }
}
extension Array where Element: Comparable {
    func max() -> Element? {
        return self.maxElement()
    }
    func min() -> Element? {
        return self.minElement()
    }
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool = {$0 < $1}) -> [Element] {
        return self.sort(areInIncreasingOrder)
    }
    mutating func sort(by areInIncreasingOrder: (Element, Element) -> Bool = {$0 < $1}) {
        self.sortInPlace(areInIncreasingOrder)
    }
}
extension Array {
    mutating func swapAt(i: Int, _ j: Int) {
        swap(&self[i], &self[j])
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func reverse() {
        self = self.reversed()
    }
    func enumerated() -> EnumerateSequence<[Element]> {
        return self.enumerate()
    }
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
extension _ArrayType where Generator.Element == String {
    func joined(separator separator: String = "") -> String {
        return self.joinWithSeparator(separator)
    }
}
extension Range {
    func reversed() -> [Element] {
        return self.reverse()
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
prefix operator * { }
infix operator ** {
    precedence 155      // 乗除算より強く，ビットシフトより弱い
    associativity right // 右結合
}
#endif
prefix func * <T> (a: [T]) -> (T, T)             { return (a[0], a[1]) }
prefix func * <T> (a: [T]) -> (T, T, T)          { return (a[0], a[1], a[2]) }
prefix func * <T> (a: [T]) -> (T, T, T, T)       { return (a[0], a[1], a[2], a[3]) }
prefix func * <T> (a: [T]) -> (T, T, T, T, T)    { return (a[0], a[1], a[2], a[3], a[4]) }
prefix func * <T> (a: [T]) -> (T, T, T, T, T, T) { return (a[0], a[1], a[2], a[3], a[4], a[5]) }
func **(lhs: Int, rhs: Int) -> Int {
    return Int(pow(Double(lhs), Double(rhs)))
}
func **(lhs: Int, rhs: Double) -> Double {
    return pow(Double(lhs), rhs)
}
func * <Element> (lhs: [Element], rhs: Int) -> [Element] {
    return (0..<rhs).reduce([]){a,_ in a+lhs}
}
func *(lhs: String, rhs: Int) -> String {
    return (0..<rhs).reduce(""){s,_ in s+lhs}
}
let MOD = 10 ** 9 + 7
let alphabets = "abcdefghijklmnopqrstuvwxyz"
let ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
protocol Container {
    associatedtype Item
    mutating func append(item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}
struct Stack<Element>: Container {
    var items = [Element]()
    mutating func push(item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
    mutating func append(item: Element) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
}
struct Queue<Element>: Container {
    var items = [Element]()
    mutating func push(item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeFirst()
    }
    mutating func append(item: Element) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
}
struct Heap<Element: Comparable>: Container {
    var items = [Element]()
    mutating func push(item: Element) {
        var i = items.count
        while i > 0 {
            let p = (i - 1) / 2
            if items[p] <= item {
                break
            }
            if i == items.count {
                items.append(items[p])
            } else {
                items[i] = items[p]
            }
            i = p
        }
        if i == items.count {
            items.append(item)
        } else {
            items[i] = item
        }
    }
    mutating func pop() -> Element {
        let ret = items[0]
        let x = items[items.count - 1]
        var i: Int = 0
        while i * 2 + 1 < items.count - 1 {
            var a = i * 2 + 1
            let b = i * 2 + 2
            if b < items.count - 1 && items[b] < items[a] {
                a = b
            }
            if items[a] >= x {
                break
            }
            items[i] = items[a]
            i = a
        }
        items[i] = x
        _ = items.removeLast()
        return ret
    }
    mutating func append(item: Element) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
}
extension Array where Element: Equatable {
    func count(of value: Element) -> Int {
        return self.reduce(0){$0+($1==value ? 1 : 0)}
    }
}
extension String {
    func count(of value: Character) -> Int {
        return self.reduce(0){$0+($1==value ? 1 : 0)}
    }
    subscript(i: Int) -> Character {
        return self.map{$0}[i]
    }
}
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringsSplit(by separator: Character = " ") -> [String] {
    return readLine()!.split(separator: separator).map{String($0)}
}
func readIntsSplit(by separator: Character = " ") -> [Int] {
    return readLine()!.split(separator: separator).map{Int($0)!}
}
func gcd(x: Int, _ y: Int) -> Int {
    return y>0 ? gcd(y, x%y) : x
}
func lcm(x: Int, _ y: Int) -> Int {
    return x * y / gcd(x, y)
}
func manhattanDistance(x1: Int, _ y1: Int, _ x2: Int, _ y2: Int) -> Int {
    return abs(x1 - x2) + abs(y1 - y2)
}
func euclideanDistance(x1: Int, _ y1: Int, _ x2: Int, _ y2: Int) -> Double {
    return sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
}

/*************** メインプログラム ***************/

let (N, K, Q) = *readIntsSplit()
var cnt = [0] * N
for _ in 0..<Q {
  cnt[readInt()!-1] += 1
}
cnt.forEach{print($0>Q-K ?"Yes":"No")}


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'))


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


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()


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()


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'))


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()


a, b = map(int, input().split())
ans = a-b*2
if ans >= 0:
  print(ans)
else:
  print(0)


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))


a,b=input().strip().split(" ")
a,b=[int(a),int(b)]
p=2*b
if a-p<=0:
  print(0)
else:
  print(a-p)


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))


A,B=map(int,input().split())
print(min(0, A-2*B))


A, B = map(int, input().split())
print(max(0, A - 2 * B)


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


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


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


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


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


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


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


#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;
}


    #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;
    }


#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;

    }


#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;


#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;
}


#include <stdio.h>

int main(){
  int a, b;
  scanf("%d %d", &a, &b);
  printf("%d\n", (2 * b < a) * (a - 2 * b));
  return 0;
}


#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;
}


#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;
}


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


#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;
}


#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);

    }
}


'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'));


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'));


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


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'));


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'));


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'));


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)

	}

}


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


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])
}


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


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)

}


a, b = gets.split.map(&:to_i)
puts [a - 2 * b, 0].max


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


a, b = gets.chomp.split(' ').map(&:to_i)
if a > b * 2
  puts a - (b * 2)
else
  puts 0
end


a,b=gets.split.map(&:to_i);p a - (b*2) >= b ? a - (b*2) : 0


a,b = gets.chomp.split(" ").map(&:to_i)
if a>=b*2
  puts 0
else
  puts a-(2*b)
end


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

ans = a - 2*b

if ans < 0
  puts "0"
end

puts ans


macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

    ($iter:expr, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $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")
    };
}

pub trait LexicalPermutation {
    /// Return `true` if the slice was permuted, `false` if it is already
    /// at the last ordered permutation.
    fn next_permutation(&mut self) -> bool;
    /// Return `true` if the slice was permuted, `false` if it is already
    /// at the first ordered permutation.
    fn prev_permutation(&mut self) -> bool;
}

impl<T> LexicalPermutation for [T]
where
    T: Ord,
{
    /// Original author in Rust: Thomas Backman <serenity@exscape.org>
    fn next_permutation(&mut self) -> bool {
        // These cases only have 1 permutation each, so we can't do anything.
        if self.len() < 2 {
            return false;
        }

        // Step 1: Identify the longest, rightmost weakly decreasing part of the vector
        let mut i = self.len() - 1;
        while i > 0 && self[i - 1] >= self[i] {
            i -= 1;
        }

        // If that is the entire vector, this is the last-ordered permutation.
        if i == 0 {
            return false;
        }

        // Step 2: Find the rightmost element larger than the pivot (i-1)
        let mut j = self.len() - 1;
        while j >= i && self[j] <= self[i - 1] {
            j -= 1;
        }

        // Step 3: Swap that element with the pivot
        self.swap(j, i - 1);

        // Step 4: Reverse the (previously) weakly decreasing part
        self[i..].reverse();

        true
    }

    fn prev_permutation(&mut self) -> bool {
        // These cases only have 1 permutation each, so we can't do anything.
        if self.len() < 2 {
            return false;
        }

        // Step 1: Identify the longest, rightmost weakly increasing part of the vector
        let mut i = self.len() - 1;
        while i > 0 && self[i - 1] <= self[i] {
            i -= 1;
        }

        // If that is the entire vector, this is the first-ordered permutation.
        if i == 0 {
            return false;
        }

        // Step 2: Reverse the weakly increasing part
        self[i..].reverse();

        // Step 3: Find the rightmost element equal to or bigger than the pivot (i-1)
        let mut j = self.len() - 1;
        while j >= i && self[j - 1] < self[i - 1] {
            j -= 1;
        }

        // Step 4: Swap that element with the pivot
        self.swap(i - 1, j);

        true
    }
}

#[allow(dead_code)]
fn sieve_of_eratosthenes(n: usize) -> Vec<usize> {
    // spf:
    // store smallest prime factor of number
    // 最小の素因数を格納
    // is_prime:
    // 配列番号が素数であるかどうかを示す
    let mut spf = vec![None; n + 1];
    let mut is_prime = vec![true; n + 1];
    let mut primes = Vec::new();

    // 0 と 1 は素数ではない
    is_prime[0] = false;
    is_prime[1] = false;

    for i in 2..n + 1 {
        // is_prime[i]:
        // それ以下の素数で割り切られていなければ True となる
        if is_prime[i] {
            // この if 文より i は素数なので
            primes.push(i);

            // 素数はそれ自身の最も小さい素因数であるから
            spf[i] = Some(i);
        }

        // 全ての prime の倍数(prime * i)を取り除く
        for prime in &primes {
            // prime が i の最も小さい因数よりも大きくなってしまったら探索終了
            if i * prime >= n + 1 || prime > &spf[i].unwrap() {
                break;
            }

            is_prime[i * prime] = false;

            // i * primes[j] の最も小さい素数は primes[j] 自身
            spf[i * prime] = Some(*prime);
        }
    }
    primes
}
use std::cmp::Ordering;
#[derive(Eq, PartialEq, Clone, Debug)]
pub struct Rev<T>(pub T);

impl<T: PartialOrd> PartialOrd for Rev<T> {
    fn partial_cmp(&self, other: &Rev<T>) -> Option<Ordering> {
        other.0.partial_cmp(&self.0)
    }
}

impl<T: Ord> Ord for Rev<T> {
    fn cmp(&self, other: &Rev<T>) -> Ordering {
        other.0.cmp(&self.0)
    }
}
#[allow(dead_code)]
fn gcd(a: u64, b: u64) -> u64 {
    if b == 0 {
        a
    } else {
        gcd(b, a % b)
    }
}
#[allow(dead_code)]
fn lcm(a: u64, b: u64) -> u64 {
    a / gcd(a, b) * b
}

#[allow(dead_code)]
fn expected(p: u64) -> f64 {
    let p = p as f64;
    ((p * (p + 1.0)) / 2.0) / p
}

#[allow(unused_imports)]
use std::collections::BTreeSet;
#[allow(unused_imports)]
use std::collections::VecDeque;

#[allow(unused_mut)]
#[allow(unused_variables)]
#[allow(non_snake_case)]
fn main() {
    input! {A: i32, B: i32};

    println!("{}", if A - 2 * B < 0 { 0 } else { A - 2 * B });
}


#![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);
}


/* {{{ */
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: */


#![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);
}


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


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


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


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


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()


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]))


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))


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))


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'))


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)


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


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


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


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


A, B, C = map(int, input().split())

if A == B:
    print(C)
elif B == C:
    print(A)
else:
    print(B)


a, b, c = [int(i) for i in input().split()]

if a == b:
	print(c)
elif b == c:
	print(a)
else:
	print(b)


a,b,c=map(int,input().split())
if a==b:
    print(c)
elif a==c:
    print(b)
else:
    print(a)


a,b,c = map(int,input().split())
if a != b and a == c:
    print(a)
else:
    print(b)


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)


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)


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

	}

}


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


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


/**
 *
 */
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);
    	}

	}

}


/**
 *
 */
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);
    	}

	}

}


#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;
}


#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;
}


#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;
}


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;

}


#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;
}


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


#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;
}


#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;
}


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


#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;}
}


#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;}
}


#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;
   }


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


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


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


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


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


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


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


package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"math"
	"os"
	"strconv"
)

const (
	initialBufSize = 10000
	maxBufSize     = 1000000
	mod            = 1e9 + 7
)

var (
	sc *bufio.Scanner = func() *bufio.Scanner {
		sc := bufio.NewScanner(os.Stdin)
		buf := make([]byte, initialBufSize)
		sc.Buffer(buf, maxBufSize)
		sc.Split(bufio.ScanWords)
		return sc
	}()
)

func main() {
	A := getInt()
	B := getInt()
	C := getInt()

	if A == B {
		fmt.Println(C)
	} else if B == C {
		fmt.Println(A)
	} else {
		fmt.Println(B)
	}
}

type Graph struct {
	n     int
	edges [][]int
}

func NewGraph(n int) *Graph {
	g := &Graph{
		n:     n,
		edges: make([][]int, n),
	}
	return g
}

func (g *Graph) AddEdge(u, v int) {
	g.edges[v] = append(g.edges[v], u)
	g.edges[u] = append(g.edges[u], v)
}

func dfs(c int, edges [][]int, visited map[int]struct{}) {
	visited[c] = struct{}{}

	for _, v := range edges[c] {
		_, flag := visited[v]
		if flag {
			continue
		}
		dfs(v, edges, visited)
	}
}

func bfs(c int, graph *Graph) {
	next := make([]int, 0)
	next = append(next, c)
	visited := make(map[int]struct{})

	for ; len(next) != 0; {
		u := next[0]
		next = next[1:]
		visited[u] = struct{}{}

		for _, v := range graph.edges[u] {
			_, flag := visited[v]
			if flag {
				continue
			}

			// なにか処理

			next = append(next, v)
		}
	}
}

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

func getIntArray(n int) []int {
	array := make([]int, n)
	for i := 0; i < n; i++ {
		array[i] = getInt()
	}
	return array
}

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

func getStringArray(n int) []string {
	array := make([]string, n)
	for i := 0; i < n; i++ {
		array[i] = getString()
	}
	return array
}

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

func pow(p, q int) int {
	return int(math.Pow(float64(p), float64(q)))
}

func powMod(n, p int) int {
	if p == 0 {
		return 1
	} else if p%2 == 0 {
		t := powMod(n, p/2)
		return calcMod(t * t)
	} else {
		return calcMod(n * powMod(n, p-1))
	}
}

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

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

func strSearch(a []string, b string) bool {
	for i := 0; i < len(a); i++ {
		if a[i] == b {
			return true
		}
	}
	return false
}

func printIntArray(array []int) {
	strArray := fmt.Sprint(array)
	fmt.Println(strArray[1 : len(strArray)-1])
}

func calcMod(x int) int {
	return x % mod
}

func reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func isPrime(n int) bool {
	if n < 2 {
		return false
	} else if n == 2 {
		return true
	} else if n % 2 == 0 {
		return false
	}

	sqrtN := int(math.Sqrt(float64(n)))
	for i := 3; i <= sqrtN; i += 2 {
		if n % i == 0 {
			return false
		}
	}

	return true
}

func contains(s []int, e int) bool {
	for _, v := range s {
		if e == v {
			return true
		}
	}
	return false
}

func makeRange(min, max int) []int {
	a := make([]int, max-min+1)
	for i := range a {
		a[i] = min + i
	}
	return a
}

func powerset2(nums []int) [][]int {
	length := int(math.Pow(2, float64(len(nums))))
	result := make([][]int, length)

	index := 0
	result[index] = []int{}
	index++

	for _, n := range nums {
		max := index
		for i := 0; i < max; i++ {
			result[index] = copyAndAppend(result[i], n)
			index++
		}
	}

	return result
}

func copyAndAppend(nums []int, n int) []int {
	dst := make([]int, len(nums)+1)
	copy(dst, nums)
	dst[len(nums)] = n
	return dst
}

func calcGcd(x, y int) int {
	if y == 0 {
		return x
	} else if x >= y {
		return calcGcd(y, x % y)
	} else {
		return calcGcd(x, y % x)
	}
}

func getDivisor(n int) []int {
	var divisor []int
	divisor = append(divisor, 1)
	if n != 1 {
		divisor = append(divisor, n)
	}

	sqrt := int(math.Sqrt(float64(n)))
	for i := 2; i <= sqrt; i++ {
		if n % i == 0 {
			divisor = append(divisor, i)
			divisor = append(divisor, n/i)
		}
	}
	return divisor
}

type intHeap []int

func (h intHeap) Len() int {
	return len(h)
}

func (h intHeap) Less(i, j int) bool {
	return h[i] > h[j]
}

func (h intHeap) Swap(i, j int) {
	h[i], h[j] = h[j], h[i]
}

func (h *intHeap) Push(x interface{}) {
	*h = append(*h, x.(int))
}

func (h *intHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

func initHeap() *intHeap {
	ih := &intHeap{}
	heap.Init(ih)
	return ih
}

func (h *intHeap) pushHeap(n int) {
	heap.Push(h, n)
}

func (h *intHeap) popHeap() int {
	return heap.Pop(h).(int)
}

func factMod(n int) int {
	value := 1
	for ; n > 1; n-- {
		value = calcMod(value * n)
	}
	return value
}

func combinationMod(n, k int) int {
	factN := factMod(n)
	factK := factMod(k)
	factNK := factMod(n - k)
	factKR := powMod(factK, mod - 2)
	factNKR := powMod(factNK, mod - 2)
	return calcMod(factN * calcMod(factKR * factNKR))
}


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


/**
 *    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;
}


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


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


a=gets.split.map(&:to_i).sort;p a[0] == a[1] ? a[2] : a[0]


puts (gets.chomp.split.group_by(&:itself)
  .select{|_k, v| v.size == 1}.first.first)


#!/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


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


a,b,c = gets.chomp.split.map(&:to_i)
if a == b
    print(c)
elsif a == c
    print(b)
else
    print(a)


puts gets.split.map(&:to_i).goup_by(&:itself).select{|k,v|v.size==1}.values[0]


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


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


#[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}
    );

}


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


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


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

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

use std::cmp::min;

fn main() {
    let a: usize = read();
    let b: usize = read();
    let c: usize = read();
    if a == b {
        println!("{}", c);
    }
    if c == b {
        println!("{}", a);
    }
    if a == c {
        println!("{}", b);
    }
}


import Glibc
extension String: CollectionType {}

var abc = readLine()!.split(" ").map { Int($0)! }
if abc[0] == abc[1] {
  print(abc[2])
} else if abc[1] == abc[2] {
  print(abc[0])
} else {
  print(abc[1])
}


var i=readLine()!.characters.split(" ").map{Int(String($0))!},a=i[0];if i[0]==i[1]{a=i[2]};if i[0]==i[2]{a=i[1]};print(a)


import Foundation

let line = readLine()!
let comps = line.componentsSeparatedByString(" ")
var dic = [String:Int]()
comps.forEach({ dic[$0] = (dic[$0] ?? 0) + 1 })
print(dic.filter({ $0.1 == 1 }).first!.0)


var i=readLine()!.characters.split(" ").map{Int(String($0))!},a=i[0];if i[0]==i[1]{a=i[1]};if i[0]==i[2]{a=i[1]};print(a)


import * as fs from 'fs';

namespace AtCoder {
    export interface Paramable {
        readonly args: string[][];
    }

    export interface Task {
        main(this: Task): void;
    }
}

namespace AtCoder.abc001 {
    export class TaskA implements AtCoder.Task, AtCoder.Paramable {
        public constructor(public readonly args: string[][]) {
        }

        public main(this: TaskA): void {
            const abc: number[] = this.args[0].map(Number);

            abc.sort();

            if (abc[0]===abc[1]) {
                console.log(abc[2]);
            } else{
                console.log(abc[0]);
            }
        }
    }

    const args: string[][] = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n').map(r => r.split(' '));
    const task: AtCoder.Task = new TaskA(args);
    task.main();
}