jiahuimbzuai/CoQuIR huggingface dataset:
//  [rust]
// -*- coding:utf-8-unix -*-

use proconio::input;

fn main() {
    input! {
        n: i32,
        m: i32,
        k: i32,
    }

    for i in 0..n + 1 {
        for j in 0..m + 1 {
            if (m * i) + j * (m - 2 * i) == k {
                println!("Yes");
                return;
            }
        }
    }
    println!("No");
}
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!},N=i[0],M=i[1],K=i[2]
var ans="No"
for i in 0...N {
  for j in 0...M {
    if (N-i)*j+(M-j)*i==K {
      ans="Yes"
    }
  }
}
print(ans)
//  [swift]
import Foundation

extension String {
    func toIntList() -> [Int] {
        return self.split(separator: " ").map{Int($0)!}
    }
    
    func toList() -> [String] {
        return self.map{String($0)}
    }
    
    func count(c:Character) -> Int{
        var result = 0

        for e in self{
            if e == c{
                result += 1
            }
        }
        return result
    }

    func counter() -> Dictionary<Character, Int>{
        var result:[Character:Int] = [:]
        
        for c in self{
            guard let _ = result.index(forKey: c) else {
                result[c] = 1
                continue
            }
            result[c]! += 1
        }
        return result
    }
}

extension Int {
    func toBin() -> String {
        return String(self, radix: 2)
    }
    
    func toD() -> Double {
        return Double(self)
    }
}

extension Double {
    func toI() -> Int {
        return Int(self)
    }
}

extension Array where Element: Equatable{
    func count(n:Self.Element) -> Int{
        var result = 0
        for e in self{
            if e == n{
                result += 1
            }
        }
        return result
    }
}


func codefes2017a() -> String {
    let NMK = readLine()!.toIntList()
    let N = NMK[0]
    let M = NMK[1]
    let K = NMK[2]
    var tmp = 0
    for n in 0...N{
        for m in 0...M{
            var x = n*(M-m)
            var y = m*(N-n)
            if (x+y) == K{
                return "Yes"
            }
        }
    }
    return "No"
}


print(codefes2017a())
//  [swift]
import Foundation

extension String {
    func toIntList() -> [Int] {
        return self.split(separator: " ").map{Int($0)!}
    }
    
    func toList() -> [String] {
        return self.map{String($0)}
    }
    
    func count(c:Character) -> Int{
        var result = 0

        for e in self{
            if e == c{
                result += 1
            }
        }
        return result
    }

    func counter() -> Dictionary<Character, Int>{
        var result:[Character:Int] = [:]
        
        for c in self{
            guard let _ = result.index(forKey: c) else {
                result[c] = 1
                continue
            }
            result[c]! += 1
        }
        return result
    }
}

extension Int {
    func toBin() -> String {
        return String(self, radix: 2)
    }
    
    func toD() -> Double {
        return Double(self)
    }
}

extension Double {
    func toI() -> Int {
        return Int(self)
    }
}

extension Array where Element: Equatable{
    func count(n:Self.Element) -> Int{
        var result = 0
        for e in self{
            if e == n{
                result += 1
            }
        }
        return result
    }
}


func codefes2017a() -> String {
    let NMK = readLine()!.toIntList()
    let N = NMK[0]
    let M = NMK[1]
    let K = NMK[2]
    var tmp = 0
    for n in 0..<N{
        for m in 0..<M{
            var x = n*(M-m)
            var y = m*(N-n)
            if (x+y) == K{
                return "Yes"
            }
        }
    }
    return "No"
}


print(codefes2017a())
//  [typescript]
declare function require(x: string): any;

var input = require("fs").readFileSync("/dev/stdin", "utf8");
input = input.split("\n");
const [n, m, k] = input[0].split(" ").map((x: string): number => +x);

let flg_yes = false;
top:
for (let h = 0; h <= n; h++) {
	for (let w = 0; w <= m; w++) {
		const num = h*m+w*n-h*w*2;
		if(num == k) {
			flg_yes = true;
			break top;
		}
	}
}

if(flg_yes) console.log("Yes");
else console.log("No");
//  [typescript]
declare function require(x: string): any;

var input = require("fs").readFileSync("/dev/stdin", "utf8");
input = input.split("\n");
const [n, m, k] = input[0].split(" ").map((x: string): number => +x);

let flg_yes = false;
top:
for (let h = 0; h < n; h++) {
	for (let w = 0; w < m; w++) {
		const num = h*m+w*n-h*w*2;
		if(num == k) {
			flg_yes = true;
			break top;
		}
	}
}

if(flg_yes) console.log("Yes");
else console.log("No");
//  [python]
n = int(input())
d = []

for i in range(n):
    v = int(input())
    if v in d:
        pass
    else:
        d.append(v)

print(len(d))
//  [python]
N=int(input())
alist=[]
for i in range(N):
    alist.append(int(input()))
#print(alist)
hh = [0]*101
for i in range(N):
    hh[alist[i]] = max(1,hh[alist[i]])
#print(hh)
ss = sum(hh)
print(ss)
//  [python]
n = int(input())
d = []
for i in range(n):
	a = int(input())
	d.append(a)
newd = list(set(d))
print(len(newd))
//  [python]
num = int(input())
a = []

for i in range(num):
    n = int(input())
    a.append(n)
    
myset = set(a)

len_list = len(frozenset(myset))

print(myset)

print(len_list)
//  [python]
s = list(str(input()))
t = list(str(input()))

asc_s = sorted(s)
desc_t = sorted(t, reverse=True)

print("Yes" if ''.join(asc_s) < ''.join(desc_t) else "No")
//  [python]
import sys

a = []
for l in sys.stdin:
    a.append(int(l))
    
myset = set(a)

len_list = len(frozenset(myset))

print(len_list - 1)
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;

import java.util.Arrays;
import java.util.Collections;
import java.util.ArrayList;
import java.util.List;
import java.util.HashSet;

public class Main {
    // 標準入力
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    // 標準入力数値配列用 int
    static int[] inputval() throws Exception {
        String[] strarray = br.readLine().trim().split(" ");
        int[] intarray = new int[strarray.length];
        for (int i = 0; i < intarray.length; i++) {
            intarray[i] = Integer.parseInt(strarray[i]);
        }
        return intarray;
    }

    // 標準入力数値配列用 integer ソート用
    static Integer[] inputvalInteger() throws Exception {
        String[] strarray = br.readLine().trim().split(" ");
        Integer[] intarray = new Integer[strarray.length];
        for (int i = 0; i < intarray.length; i++) {
            intarray[i] = Integer.parseInt(strarray[i]);
        }
        return intarray;
    }

    public static void main(String[] args) throws Exception {
	// write your code here
        int n = Integer.parseInt(br.readLine().trim());
        List<Integer> tmp = new ArrayList<Integer>();
        for (int i=0; i<n; i++){
            int d = Integer.parseInt(br.readLine().trim());
            tmp.add(d);
        }
        List<Integer> dl = new ArrayList<Integer>(new HashSet<>(tmp));
        System.out.println(dl.size());
    }

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

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

import java.util.HashSet;

public class Main {
    public static void main(String[] args) throws IOException {
        try (
            BufferedReader reader = new BufferedReader(
                new InputStreamReader(System.in))) {
            FastScanner fs = new FastScanner();

            final int N = fs.nextInt();

            HashSet<Integer> hs = new HashSet<Integer>();

            for (int i = 0 ; i < N; i++) {
                int d = fs.nextInt();
                hs.add(d);
            }

            System.out.println(hs.size());
        }
    }
}

class FastScanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;
    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        } else {
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }
    private int readByte() {
        if (hasNextByte()) return buffer[ptr++];
        else return -1;
    }
    private static boolean isPrintableChar(int c) {
        return 33 <= c && c <= 126;
    }
    public boolean hasNext() {
        while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
        return hasNextByte();
    }
    public String next() {
        if (!hasNext()) throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while(isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }
    public long nextLong() {
        if (!hasNext()) throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while(true) {
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            } else if(b == -1 || !isPrintableChar(b)) {
                return minus ? -n : n;
            } else {
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }
    public int nextInt() {
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
            throw new NumberFormatException();
        return (int) nl;
    }
    public double nextDouble() {
        return Double.parseDouble(next());
    }
}
//  [java]
import java.io.*;
import java.util.*;

public class Main {

	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		int count = scn.nextInt();
		int[] mochi = new int[count];
		for (int i = 0; i < count; i++) {
			 mochi[i] = scn.nextInt();
		}
		//int[] mochiSort = new int[count];
		Arrays.sort(mochi);
		int total = 0;
		int tmp = 0;
		for (int i = 0; i < mochi.length; i++) {
			if(tmp != mochi[i] ) {
				tmp = mochi[i];
				total++;
			}
		}
		System.out.println();

	}

}


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 String[] nextArray(int n) {
        String[] a = new String[n];
        for (int i = 0; i < n; i++)
            a[i] = next();
        return a;
    }

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

    public long[] nextLongArray(int n) {
        long[] a = new long[n];
        for (int i = 0; i < n; i++)
            a[i] = nextLong();
        return a;
    }
}
//  [java]
import java.util.*;

public class Main {
	public static void main(String[] args) throws Exception{
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] d = new int[n];
		for(int i=0; i<n; i++){
			d[i] = sc.nextInt();
		}
      	Arrays.sort(d);
      	int count = 0;
      	for(int i=1; i<n; i++){
          if(d[i]!=d[i-1]) count++;
        }
      	System.out.println(count);
	}
}
//  [java]
import java.util.*;

class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        List<Integer> list = new ArrayList<>();
        for(int i = 0 ; i < n ; i ++){
          list.add(sc.nextInt());
        }
		 List<Integer> listB = new ArrayList<Integer>(new HashSet<>(list));
      
      	 System.out.print(listB.length());

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



int main(){
	int N;
	cin>>N;

	vector<int> D(N);

	for(int i=0;i<N;i++)cin>>D[i];

	sort(D.begin(), D.end(),greater<int>());

	int ans=1;


	for(int i=1;i<N;i++){
		if(D[i-1]!=D[i]){
			ans++;
		}

	}

	cout << ans;
	
	
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
 
int main() {
  int N,count;
  count=1;
  cin>>N;
  vector<int> vec(N);
  for (int i=0;i<N;i++)
    cin>>vec.at(i);
  sort (vec.begin(),vec.end());
  reverse (vec.begin(),vec.end());
  if(N==1)
    cout<<1<<endl;
  else{
    for (int i=0;i<N-1;i++){
      if(vec.at(i)>vec.at(i+1))
        count++;
      else
        continue;
    }
    cout<<count<<endl;
  }
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main() {
  int N;
  cin >> N;
  
  vector<int>mochi(N);
  for(int i; i<N; i++){
    cin >> mochi.at(i);
  }
  
  sort(mochi.begin(), mochi.end());
  reverse(mochi.begin(), mochi.end());
 
  int count = 0;
  for(int i=0; i<N; i++){
    if(N != 1){
    	if(mochi[i] == mochi[i-1]){ count--; }
    }
    count++;
  } 
  
  cout << count << endl;
}
//  [cpp]
// ABC 085 B- Kagami Mochi

#include <bits/stdc++.h>
using namespace std;

int main() {
  int N;
  cin >> N;
  // Kagami Mochi 配列
  vector<int> vec(N);
  for (int i = 0; i < N; i++) {
    cin >> vec.at(i);
  }
  // 大きい順に並べる
  sort(vec.begin(), vec.end());
  reverse(vec.begin(), vec.end());

  // 同じ大きさがないか確認
  int count = 1;
  if (N == 1) {
    cout << count << endl;
  }
  else {
    for (int i = 0; i < N-1; i++) {
      if (vec.at(i) != vec.at(i+1)) {
        count++;
      }
    }
  }
  cout << count << endl;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main() {
  int N. num, count;
  cin >> N;
  
  vector<int> vec(N);
  
  for (int i=0; i<N+ i++) {
    cin >> vec.at(i);
  }
  
  sort(vec.begin(), vec.end()); //sort
  reverse(vec.begin(), vec.end());

  num = 0;
  count = 1;
  for (int i=0; i<N+ i++) {
    if (num == vec.at(i) {
      count++;
    }
    num = vec.at(i); // num に大きい方からvecを代入
  }
  cout << num << endl;
  
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
int desc(const void *a, const void *b) {
  return *(int *)b - *(int *)a;
}

int main(void){
    int n,i,r=1,before;
    int arr[999];
    scanf("%d",&n);
    for(i=0;i<n;i++)scanf("%d",arr+i);
    printf(arr+i);
    qsort(arr,n,4,desc);
    before=arr[0];
    for(i=1;i<n;i++){
        if(before!=arr[i]){
            before=arr[i];
            r++;
        }
    }
    printf("%d\n",r);
    return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    int i;
    int d[102];
    for (i = 0; i < n; i++)
        scanf("%d", &d[i]);
    int k;
    for(i=0;i<n-1;i++)
        if (d[i] < d[i + 1])
        {
            k = d[i];
            d[i] = d[i + 1];
            d[i + 1] = k;
            if (i > 0)
                i -= 2;
        }
    int ans = n;
    for (i = 1; i < n; i++)
        if (d[i] == d[i - 1])
            ans--;
    printf("%d\n", ans);
    return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define N 100

int compare(const void *a, const void *b)
{
    return *(int *)a - *(int *)b;
}

int main()
{
    int i, n, last, r = 0;
    int a[N];
    scanf("%d", &n);
    for (i = 0; i < n; ++i)
        scanf("%d", &a[i]);
    qsort(a, n, sizeof(int), compare);

    for (i = 0; i < n; i++)
    {
        if (i == 0)
            r++;
        else if (a[last] < a[i])
            r++;
        last = i;
    }
    printf("%d\n", r);
}
//  [c]
#include <stdio.h>

int main()
{
	int i, N, d, flag[100] = {}, sum = 0;
	scanf("%d", &N);
	for (i = 1; i <= N; i++) {
		scanf("%d", &d);
		if (flag[d] == 0) {
			sum++;
			flag[d] = 1;
		}
	}
	printf("%d\n", sum);
	fflush(stdout);
	return 0;
}
//  [c]
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
#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++)
#define _GLIBCXX_DEBUG

int main(){
    int N;
    cin>>N;
    vector<int> vec(N);
    rep(i,N){
        cin>>vec[i];
    }
    sort(vec.begin(),vec.end());
    reverse(vec.begin(),vec.end());

    int count=1;
    if(N==1) cout<<count<<endl;
    else
    {
        rep(i,N-1){
            if(vec[i+1]-vec[i]!=0) count++;
            else continue;
        }
        cout<<count<<endl;
    }
    

}
//  [c]
#include<stdio.h>
int main(void)
{
    int N;
    int d[100];
    int c = 0;
    scanf("%d", &N);
    for (int i = 0; i < N; i++)
    {
        scanf("%d", &d[i]);
        for (int j = 0; j < i; j++)
        {
            if(d[i] == d[j])
            {
                c++;
            }
        }
        
    }
    printf("%d\n", N - c);
    return 0;
}
//  [javascript]
function main(input){
  const args = input.split('\n');
  const N = args[0],
        nums = args.slice(1, args.length - 1);
  //filterによるindex番号と元の配列のindex番号が一致している場合のみを返す
  //そうすることで、重複している値を削除することができる
  var count = nums.filter(function(n,i,j){
    return j.indexOf(n) === i;
  }).length;
  console.log(count);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
    const args = input.split(/\n/);
    const N = args[0],
          nums = args.slice(1, args.length - 1);
    
    console.log(nums.filter((n, i) => nums.indexOf(n) === i).length);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
    const args = input.split('\n');
    const N = args[0],
	  nums = args.slice(1,args.length - 1);

    console.log(nums.filter((n,i) => nums.indexOf(n) === i).length);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
  //   const input = "4,10,8,8,6";
  const args = input.split("\n");
  console.log(args);
  const N = args[0],
    nums = args.slice(1, args.length - 1);

  console.log(Array.from(new Set(nums)).length);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
  //   const input = "4,10,8,8,6";
  const args = input.split("/n");
  console.log(args);
  const N = args[0],
    nums = args.slice(1, args.length - 1);

  console.log(Array.from(new Set(nums)).length);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
	const args = input.split('\n');
  	const N = parseInt(args[0], 10);
  	let arr = args.slice(1, args.length).map((n) => parseInt(n, 10));
  	
  	const another_arr = [...new Set(arr)];
  
  	console.log(another_arr.length);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

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

var (
	reader io.Reader = os.Stdin
	writer io.Writer = os.Stdout
)

func main() {
	run()
}

func run() {
	scanner := bufio.NewScanner(reader)
	scanner.Scan()
	N, _ := strconv.Atoi(scanner.Text())

	nums := make([]int, 0, N)

	for scanner.Scan() {
		num, _ := strconv.Atoi(scanner.Text())
		nums = append(nums, num)
	}

	sort.Ints(nums)
	count := 1

	for i := 1; i < N; i++ {
		if nums[i] > nums[i-1] {
			count++
		}
	}

	fmt.Fprintln(writer, count)
}
//  [go]
package main

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

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

func main() {
	/*/TODO:!!!!!!!テスト用!!!!!!!!!
	sc = bufio.NewScanner(strings.NewReader(`

				`))
	//TODO:!!!!!!!テスト用!!!!!!!!!*/

	buf := make([]byte, 1024*1024)
	sc.Buffer(buf, bufio.MaxScanTokenSize)
	sc.Split(bufio.ScanWords)
	defer out.Flush() // !!!!caution!!!! you must use Fprint(out, ) not Print()
	/* --- code --- */
	//fmt.Fprintln(out, "[DEBUG]", time.Now())
	//https://atcoder.jp/contests/abc165/tasks/abc165_f
	//https://www.dropbox.com/sh/nx3tnilzqz7df8a/AAA0887IQFx5BcrZcrpRD7uga/ABC165/F?dl=0&subfolder_nav_tracking=1

	n := nextInt()
	d := nextInts(n)

	m := map[int]int{}

	for i := 0; i < n; i++ {
		m[d[i]] = 1
	}

	ans := len(m)

	//	fmt.Fprintln(out, "[DEBUG]]", a)
	fmt.Fprintln(out, ans)
}

//------------------------------------------------------------------------------

// -*-*-*-*-*-*-*-*-
// * I/O utilities *
// -*-*-*-*-*-*-*-*-

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

func nextInt() int {
	a, _ := strconv.Atoi(next())
	return a
}

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

func nextInts(n int) []int {
	ret := make([]int, n)
	for i := 0; i < n; i++ {
		ret[i] = nextInt()
	}
	return ret
}
func nextFloats(n int) []float64 {
	ret := make([]float64, n)
	for i := 0; i < n; i++ {
		ret[i] = nextFloat64()
	}
	return ret
}
func nextStrings(n int) []string {
	ret := make([]string, n)
	for i := 0; i < n; i++ {
		ret[i] = next()
	}
	return ret
}

func chars(s string) []string {
	ret := make([]string, len([]rune(s)))
	for i, v := range []rune(s) {
		ret[i] = string(v)
	}
	return ret
}
//  [go]
package main

import (
	"fmt"
	"sort"
)

func main() {
	var N int
	var a, b []int

	fmt.Scan(&N)
	for i:=0;i<N;i++ {
		var x int
		fmt.Scan(&x)
		a = append(a, x)
	}

	sort.Sort(sort.IntSlice(a))
	b = append(b, a[0])
	for _, v := range a {
		if b[len(b) - 1] < v {
			b = append(b, v)
		}
	}

	fmt.Print(len(b))
}
//  [go]
package main

import (
	"fmt"
)

func removeDuplicated(args []int) []int {
	results := make([]int. 0, len(args))
	encountered := map[int]bool{}
	for i:=0; i<len(args); i++ {
		if !encountered[args[i]] {
			encountered[args[i]] = true
			results = append(results, args[i])
		}
	}
	return results
}

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

	b := removeDuplicated(d)
	fmt.Println(len(b))
}
//  [go]
package main

import (
    "fmt"
    "sort"
)

func main() {
	var n int
	fmt.Scan(&n)
	mochi := make([]int, n)

	for i := 0; i < n; i++ {
		fmt.Scan(&mochi[i])
	}

	sort.Sort(sort.Reverse(sort.IntSlice(mochi)))

	count := 1
	for i := 1; i<n; i++ {
		if mochi[i] == mochi[i-1]
			continue
		}
		count++
	}
	fmt.Println(count)
}
//  [ruby]
n=gets.chomp.to_i
d=Array.new
for i in 0..n-1
  d[i]=gets.chomp.to_i
end

puts d.uniq.size
//  [ruby]
puts (gets.to_i).times.map{gets.to_i}.uniq.size
//  [ruby]
n = gets.to_i
d = []
n.times do |_i|
  d.push(gets.to_i)
end
puts d.uniq.size
//  [ruby]
lines = readlines.map(&:chomp).uniq!
p lines.size
//  [ruby]
arr = gets.chomp.map(&:to_i)
arr.delete(1)
answer = arr.unique.count
puts answer
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

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

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

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

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

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

use std::collections::HashSet;
fn main() {
    input! {
        n: u32,
        d: [u32; n],
    };
    println!("{}", d.iter().collect::<HashSet<_>>().len());
}
//  [rust]
use std::io::stdin;
use std::vec::Vec;

mod utils {
    use std::io::BufRead;
    use std::str::{self, FromStr};

    pub struct StdinReader<R: BufRead> {
        reader: R,
        buf: Vec<u8>,
    }

    impl<R: BufRead> StdinReader<R> {
        pub fn new(reader: R) -> StdinReader<R> {
            StdinReader {
                reader: reader,
                buf: Vec::new(),
            }
        }

        #[allow(unused)]
        #[inline]
        pub fn reads<T: FromStr>(&mut self) -> T {
            self.read_until(b' ')
        }

        #[allow(unused)]
        #[inline]
        pub fn readl<T: FromStr>(&mut self) -> T {
            self.read_until(b'\n')
        }

        #[allow(unused)]
        #[inline]
        pub fn read_vec<T: FromStr>(&mut self) -> Vec<T> {
            return self.read_until::<String>(b'\n').trim().split_whitespace().map(|c| c.parse().ok().unwrap()).collect();
        }

        #[inline]
        pub fn read_until<T: FromStr>(&mut self, delim: u8) -> T {
            loop {
                self.buf.clear();
                let len = self.reader
                    .read_until(delim, &mut self.buf)
                    .expect("failed reading bytes");
                match len {
                    0 => panic!("early eof"),
                    1 if self.buf[0] == delim => (),
                    _ => {
                        if self.buf[len - 1] == delim {
                            self.buf.truncate(len - 1);
                        }
                        break;
                    }
                }
            }

            let elem = unsafe { str::from_utf8_unchecked(&self.buf) };
            elem.parse().unwrap_or_else(|_| panic!(format!("failed parsing: {}", elem)))
         }
    }
}


fn main(){
    let stdin = stdin();
    let mut r = utils::StdinReader::new(stdin.lock());
    let n:usize = r.readl();
    let mut ds = vec![];
    for i in 0..n {
        let tar:i16 = r.readl();
        ds.push(tar);
    }

    ds.sort();

    let mut pre_d = 0;

    let mut res = 0;

    for d in ds {
        if(pre_d == d) {

        }else{
            res += 1;
        }
        pre_d = d;
    }
    println!("{}",res);
}
//  [rust]
use std::collections::HashSet;
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

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

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

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

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

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

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

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

fn main() {
    input!(
    n: usize,
    a: [i32; n],
    );
    let mut a = a;
    a.sort();
    let uniq: HashSet<i32> = a.into_iter().collect();
    println!("{:?}", uniq.len());
}
//  [rust]
use proconio::{fastout, input};

#[fastout]

fn main() {
    input! {
        n : i32,
        mut v : [[i32]; n],
    }
    v.sort();
    v.dedup();
    println!("{}", v.len())
}
//  [rust]
use proconio::{input, fastout};

#[fastout]
fn main() {
    input! {
        n: u8,
        d: [u8; n],
    }
    println!("{}", d.iter().collect::<HashSet<_>>().len());
}
//  [rust]
use proconio::{input, fastout};

#[fastout]
fn main() {
    input! {
        n: u8,
        d: [u8; n],
    }
    d.sort();
    d.dedup();
    println!("{}", d.len());
}
//  [swift]
let n=Int(readLine()!)!
var arr:[Int]=[]
for _ in 0..<n {
	arr.append(Int(readLine()!)!)
}
#if swift(>=3.0)
arr=arr.sorted()
#else
arr=arr.sort()
#endif
var r=1
var t=arr[0]
for i in 1..<n {
	if t != arr[i] {
		t=arr[i]
		r+=1
	}
}
print(r)
//  [swift]
import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
func exponentiate(_ lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension Array where Element == String {
//    func joined(separator separator: String) -> String {
//        return self.joinWithSeparator(separator)
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element {
        return self.maxElement()!
    }
    func min() -> Element {
        return self.minElement()!
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
func exponentiate(lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/

//var min, min2, count: Int!
//for i in 1...10 {
//    let x = Int(readLine()!)!
//    if i == 1 {
//        min = x
//        count = 1
//    } else if x < min {
//        min2 = min
//        min = x
//        count = 1
//    } else if x == min && count == 1 {
//        min2 = x
//        count = 2
//    }
//}
//print(min2)

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

let N = readInt()!
var mochi = [Int]()
for _ in 0..<N {
    let d = readInt()!
    if !mochi.contains(d) {
        mochi += [d]
    }
}
print(mochi.count)
//  [swift]
var n = Int(readLine()!)!
var dn: Set<Int> = []
while n > 0 {
  n -= 1
  dn.insert(Int(readLine()!)!)
}
print(dn.count)
//  [swift]
//
//  main.swift
//  AtCoderSwift
//
//  Created by burita083 on 2020/08/25.
//  Copyright © 2020 burita083. All rights reserved.
//

import Foundation
func readInt() -> Int {
    return Int(readLine()!)!
}
 
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
 
func readTwoInts() -> (a: Int, b: Int) {
    let ints = readLine()!.split(separator: " ").map { Int($0)! }
    return (a: ints[0], b: ints[1])
}

func abc080_b() {
    let N = readLine()!
    let sum = N.map { Int(String($0))! }.reduce(0, +)
    print(Int(N)! % sum == 0 ? "Yes" : "No")
}

//abc080_b()

func abc078_b() {
    let input = readInts()
    var X = input[0]
    let Y = input[1]
    let Z = input[2]
    var ans = 0
    X -= Y+Z*2
    ans += 1
    ans += X/(Y+Z)
    
    print(ans)
}

func abc085_b() {
    let N = readInt()
    var l: [Int] = []
    for _ in 0..<N {
        let d = readInt()
        l.append(d)
    }
    l.sort {$0 > $1 }
    var ans = 0
    for i in 0..<l.count-1 {
        if l[i] < l[i+1] {
            ans += 0
        } else {
            break
        }
    }
    print(ans)
}

abc085_b()
//  [swift]
var n = Int(readLine())!
var dn: Set<Int> = []
while n == 0 {
  n -= 1
    dn.insert(Int(readLine())!)
}
print(dn.count)
//  [swift]
7
50
30
50
100
50
80
30
//  [typescript]
s=require('fs').readFileSync('/dev/stdin','utf8').split('\n')
s.shift()
console.log(s.filter((n,i,e)=>e.indexOf(n)==i).length-1)
//  [typescript]
const main = (input) => {
    const args = input.split('\n');
    const N = args[0],
          nums = args.slice(1, args.length - 1);

    console.log(nums.filter((n, i) => nums.indexOf(n) === i).length);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
s=require('fs').readFileSync('/dev/stdin','utf8').split('\n')
N = s[0]
nums = s.slice(1, s.length - 1);
console.log(nums.filter((n, i) => nums.indexOf(n) === i).length);
//  [typescript]
function main(input) {
  //   const input = "4,10,8,8,6";
  const args = input.split("/n");
  console.log(args);
  const N = args[0],
    nums = args.slice(1, args.length - 1);

  console.log(Array.from(new Set(nums)).length);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
s=require('fs').readFileSync('/dev/stdin','utf8').split('\n').map(n=>n|0)
s.shift()
console.log(s.filter((n,i,e)=>e.indexOf(n)==i).length)
//  [typescript]
s=require('fs').readFileSync('/dev/stdin','utf8').split('\n')
s.shift()
console.log(s.sort((a,b)=>a-b).filter((n,i,e)=>e.indexOf(n)==i).length)
//  [python]
a,b,c=map(int,input().split())
k=int(input())
num=0
while a>=b:
    b*=2
    num+=1
    if b>a:
        break
while b>=c:
    c*=2
    num+=1
    if c>b:
        break
if num<=k:
    print("Yes")
else:
    print("No")
//  [python]
a,b,c=map(int,input('').split())
k=int(input())
for i in range(k):
    if a<b and b<c:
        print("Yes")
        exit()
    if b<=a:
        b*=2
        continue
    if c<=b:
        c*=2
        continue
if a<b and b<c:
    print("Yes")
else:
    print('No')
//  [python]
a, b, c = map(int, input().split())
k = int(input())
cnt = 0
while a >= b:
    b = b * 2
    cnt += 1
while b >= c:
    c = c * 2
    cnt += 1
if k >= cnt:
    print("Yes")
else:
    print("No")
//  [python]
A,B,C=map(int,input().split())
K=int(input())

for i in range(K):
    if A>B:
        B=2*B
    elif B>C:
        C=2*C
    if A<B and B<C:
        print('Yes')
        break
else:
    print('No')
//  [python]
A,B,C = map(int,input().split())
x = [0,0,0]
K = int(input())
flag = 0
for i in range(K+1):
    for j in range(K+1-i):
        a = A*(2**i)
        b = B*(2**j)
        c = C*(2**(K-i-j))
        if c>b>a:
            print("Yes")
            flag = 1
            break
if flag == 0:
    print("No")
//  [python]
a,b,c = map(int,input().split())
k = int(input())
d = 0
for i in range(k+1):
    if b < a:
        b *= 2
    elif c < b:
        c *= 2
    else:
        d = 1
if d == 0:
    print("No")
else:
    print("Yes")
//  [java]
import java.util.*;
import java.io.*;
 
public class Main {
    public static void main(String[] args) throws Exception {
        FastScanner sc = new FastScanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
        int cnt = sc.nextInt();
        while(cnt > 0 && a >= b){
            b *= 2;
            cnt--;
        }
        while(cnt > 0 && b >= c){
            c *= 2;
            cnt--;
        }
        pw.println(a < b && b < c ? "Yes" : "No");
        pw.flush();
    }
}

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

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

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

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

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

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

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

    public long[] nextLongArray(int n) {
        long[] a = new long[n];
        for (int i = 0; i < n; i++)
            a[i] = nextLong();
        return a;
    } 
}
//  [java]
import java.util.*;
import java.io.*;
import static java.lang.Math.*;

public class Main {
    public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		
		// 入力
		int a = sc.nextInt();
		int b = sc.nextInt();
		int c = sc.nextInt();
		int k = sc.nextInt();
		
		// 計算
		String result = "No";
		for(int i = 0; i < k; i++){
		    if(a >= b){
		        b *= 2;
		    }else if(b >= c){
		        c *= 2;
		    }
		}
		if(a < b && b < c) result = "Yes";
		
		
		// 出力
		System.out.println(result);
	}
	
	public static class Scanner {
		private BufferedReader br; private StringTokenizer tok;
		public Scanner(InputStream is) throws IOException { br = new BufferedReader(new InputStreamReader(is));}
		private void getLine() throws IOException { while(!hasNext()) tok = new StringTokenizer(br.readLine());}
		private boolean hasNext() { return tok != null && tok.hasMoreTokens();}
		public String next() throws IOException { getLine(); return tok.nextToken();}
		public int nextInt() throws IOException { return Integer.parseInt(next());}
		public long nextLong() throws IOException { return Long.parseLong(next());}
		public double nextDouble() throws IOException { return Double.parseDouble(next());}
	}
}
//  [java]
import java.util.*;
import java.io.*;

public class Main {
	private static void solve(){
		//Implement solution here.
		int A = ni();
		int B = ni();
		int C = ni();
		int K = ni();
		
		int cnt = 0;
		while(A >= B) {
			B *= 2;
			cnt ++;
		}
		while(B >= C) {
			C *= 2;
			cnt ++;
		}
		
		if(cnt > K) {
			System.out.println("No");
		} else {
			System.out.println("Yes");
		}
	}


	//Switch input source (stdin/file)
	private static BufferedReader br;
	public static void main(String[] args){
		br = new BufferedReader(new InputStreamReader(System.in));
		String debugDataPath = System.getenv("DD_PATH");        
		if(debugDataPath != null){
			try{
				br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(debugDataPath))));
			}catch(Exception e){
				throw new RuntimeException(e);
			}
		}
		boolean hasNext = true;
		while(hasNext){
			solve();	
			try{
				br.mark(1);
				if(br.read() > 0){
					br.reset();			
					System.out.println("---");
				} else {
					hasNext = false;
				}
			}catch(Exception e){
				throw new RuntimeException(e);
			} 
		}
	}

	//Input read utility
	private static StringTokenizer tokenizer = null;
	public static String next() {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(br.readLine());
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}
	//Get next single int
	private static int ni() {
		return Integer.parseInt(next());
	}
	//Get next single long
	private static long nl() {
		return Long.parseLong(next());
	}
	//Get next single double
	private static double nd() {
		return Double.parseDouble(next());
	}
	//Get next int array from one line
	private static int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}
	//Get next char array from one line
	private static char[] ns() {
		return next().toCharArray();
	}
	//Get next long array from one line
	private static long[] nal(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nl();
		return a;
	}
}
//  [java]
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		int c = sc.nextInt();
		sc.nextLine();
		int k = sc.nextInt();
		
		boolean canDo = false;
		for (int i = 0; i < k; i++) {
			if (a >= b) {
				b = b*2;
				if (a < b && b < c) {
					canDo = true;
					break;
				}
			} else if (b >= c) {
				c = c*2;
				if (a < b && b < c) {
					canDo = true;
					break;
				}
			}
		}
		String ans = canDo ? "Yes" : "No";
		System.out.println(ans);
	}
}
//  [java]
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		int c = sc.nextInt();
		sc.nextLine();
		int k = sc.nextInt();
		
		boolean canDo = false;
		for (int i = 0; i < k; i++) {
			if (a >= b) {
				b = b*2;
			} else if (b >= c) {
				c = c*2;
			} else {
				canDo = true;
				break;
			}
		}
		String ans = canDo ? "Yes" : "No";
		System.out.println(ans);
	}
}
//  [java]
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		int c = sc.nextInt();
		int k = sc.nextInt();
		
		for(int i=1;i<=k;i++) {
			if(a>b) {
				b*=2;
			}
			else {
				c*=2;
			}
		}
		if(c>b && b>a) {
			System.out.println("Yes");
		}
		else {
			System.out.println("No");
		}
	}

}
//  [cpp]
#include<bits/stdc++.h>

int main(){
    using namespace std;
    unsigned long A, B, C, K;
    cin >> A >> B >> C >> K;
    while(A >= B){
        --K;
        B <<= 1;
    }
    while(B >= C){
        --K;
        C <<= 1;
    }
    puts(K > 10 ? "No" : "Yes");
    return 0;
}
//  [cpp]
#include<cstdio>

int main(){
    int a,b,c,k;
    scanf("%d %d %d %d", &a,&b,&c,&k);
    int i=0;
    while(i<=k+1){
        if(a>=b){
            b *= 2;
            i++;
        }
        else if(b>=c){
            c *= 2;
            i++;
        }
        else break;
    }
    if(i<=k) printf("Yes");
    else printf("No");
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
#define rep(i, ss, ee) for (int i = (ss); i <= (ee); ++i)

void solve() {
  int A, B, C, K;
  cin >> A >> B >> C >> K;
  rep(a, 0, K) {
    rep(b, 0, K) {
      rep(c, 0, K) {
        if (a + b + c != K) continue;
        int x, y, z;
        x = A * ((a != 0) ? a * 2 : 1);
        y = B * ((b != 0) ? b * 2 : 1);
        z = C * ((c != 0) ? c * 2 : 1);
        if (x < y && y < z) {
          cout << "Yes" << endl;
          // cout << x << y << z << endl;
          return;
        }
      }
    }
  }
  cout << "No" << endl;
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  solve();
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
#define rep(i, ss, ee) for (int i = (ss); i <= (ee); ++i)

void solve() {
  int A, B, C, K;
  cin >> A >> B >> C >> K;
  rep(a, 0, K) {
    rep(b, 0, K) {
      rep(c, 0, K) {
        if (a + b + c != K) continue;
        int x, y, z;
        x = A * ((a) ? a * 2 : 1);
        y = B * ((b) ? b * 2 : 1);
        z = C * ((c) ? c * 2 : 1);
        if (x < y && y < z) {
          cout << "Yes" << endl;
          return;
        }
      }
    }
  }
  cout << "No" << endl;
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  solve();
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
#define rep(i, ss, ee) for (int i = (ss); i < (ee); ++i)

void solve() {
  int A, B, C, K;
  cin >> A >> B >> C >> K;
  rep(a, 0, K) {
    rep(b, 0, K) {
      rep(c, 0, K) {
        int x, y, z;
        x = A * ((a) ? a * 2 : 1);
        y = B * ((b) ? b * 2 : 1);
        z = C * ((c) ? c * 2 : 1);
        if ((a + b + c == K) && x < y && y < z) {
          cout << "Yes" << endl;;
          return;
        }
      }
    }
  }
  cout << "No" << endl;
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  solve();
}
//  [c]
#include <stdio.h>
#include <stdlib.h>

typedef long long ll;

int main(void){
    ll A,B,C,K;
    scanf("%lld %lld %lld",&A,&B,&C);
    scanf("%lld",&K);
    while(A>=B&&K>0){
        B*=2;
        K--;
    }
    while(B>=C&&K>0){
        C*=2;
        K--;
    }
    if(A<B&&B<C)printf("Yes\n");
    else printf("No\n");
    return 0;
}
//  [c]
#include <stdio.h>

int main(void) {

  long a,b,c,k,count = 0;
  scanf("%ld %ld %ld %ld", &a, &b, &c, &k);
  while (b <= a) {
    count++;
    b *= 2;
  }
  while (c <= b) {
    count++;
    c *= 2;
  }
  if (count <= k) {
    printf("Yes\n");
  } else {
    printf("No\n");
  }

  return 0;
}
//  [c]
#include<stdio.h>
int main(){
  float a,b,c,m1,m2;
  int k,n1=0,n2=0,i;
  scanf("%f %f %f ",&a,&b,&c);
  scanf("%d",&k);
  m1=a/b;m2=1;
  for(i=1;i<=k;i++){
    if(m1<m2){
    }else{
      m2=m2*2;
      n1++;
    }
  }
  //printf("%d %d %f %f\n",n1,n2,m1,m2);
  m1=(b*m2)/c;m2=1;
  for(i=1;i<=k;i++){
    if(m1<m2){
    }else{
      m2=m2*2;
      n2++;
    }
  }
  //printf("%d %d %f %f\n",n1,n2,m1,m2);
  //printf("%d",n1+n2);
  if(n1+n2<=k){printf("Yes");}
  else{printf("No");}
}
//  [c]
#include<stdio.h>
int main(){
  float a,b,c,m1,m2;
  int k,n1=0,n2=0,i;
  scanf("%f %f %f ",&a,&b,&c);
  scanf("%d",&k);
  m1=a/b;m2=1;
  for(i=1;i<=k;i++){
    if(m1>m2){
      m2=m2*2;
      n1++;
    }
  }
  //printf("%d %d %f %f\n",n1,n2,m1,m2);
  m1=(b*m2)/c;m2=1;
  for(i=1;i<=k;i++){
    if(m1<m2){
    }else{
      m2=m2*2;
      n2++;
    }
  }
  //printf("%d %d %f %f\n",n1,n2,m1,m2);
  //printf("%d",n1+n2);
  if(n1+n2<=k){printf("Yes");}
  else{printf("No");}
}
//  [c]
#include<stdio.h>
int main(){
  float a,b,c,m1,m2;
  int k,n1=0,n2=0,i;
  scanf("%f %f %f ",&a,&b,&c);
  scanf("%d",&k);
  m1=a/b;m2=1;
  for(i=1;i<=k;i++){
    if(m1>m2){
      m2=m2*2;
      n1++;
    }
  }
  //printf("%d %d %f %f\n",n1,n2,m1,m2);
  m1=(b*m2)/c;m2=1;
  for(i=1;i<=k;i++){
    if(m1>m2){
      m2=m2*2;
      n2++;
    }
  }
  //printf("%d %d %f %f\n",n1,n2,m1,m2);
  //printf("%d",n1+n2);
  if(n1+n2<=k){printf("Yes");}
  else{printf("No");}
}
//  [javascript]
function Main(input) {
  input = input.replace(/\n/g, ' ');
  input = input.split(" ");
  var A = Number(input[0]);
  var B = Number(input[1]);
  var C = Number(input[2]);
  var D = Number(input[3]);
  var ans = 0;
  var i=0;
  var l=0;
  while(true){
    if(A<B){
      ans+=i;
      break;
    }
    B*=2;
    i++;
  }
  while(true){
    if(B<C){
      ans+=l;
      break;
    }
    C*=2;
    l++;
  }
  if(D>=ans){
    console.log("Yes");
  }else{
    console.log("No");
  }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(arg) {
    let [a,b,c] = arg.split("\n")[0].split(" ").map(Number)
    let k = Number(arg.split("\n")[1])
    
    
    b_ = b
    c_ = c
    for(let i=0; i<k; i++) {
        if(b <= a){
            b=b*2;
        } else {
            c=c*2;
        }
    }
    console.log((b>a && c>b) ? 'Yes' : 'No')
    
}

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