CodeEff/ECCO huggingface dataset:
# Original solution
from math import gcd

def solve(a,b,c,d):
  
    if a < b:
        return False
    if d < b:
        return False

    g = gcd(b,d)
    c += 1
    m = c + (a-c)%g
    return b <= m

T = int(eval(input()))
for _ in range(T):
    print(('Yes' if solve(*list(map(int,input().split()))) else 'No'))

# Optimized solution
import math
for _ in range(int(eval(input()))):
    a,b,c,d = list(map(int,input().split()))
    print(('Yes' if b <= min(a, d, c+1+(a-c-1)%math.gcd(b,d)) else 'No'))
# Original solution
import math
for _ in range(int(eval(input()))):
    a,b,c,d = list(map(int,input().split()))
    print(('Yes' if b <= min(a, d, c+1+(a-c-1)%math.gcd(b,d)) else 'No'))

# Optimized solution
from math import gcd

def solve(a,b,c,d):
  
    if a < b:
        return False
    if d < b:
        return False

    g = gcd(b,d)
    m = b - (b-a-1)%g - 1
    return m <= c

T = int(eval(input()))
for _ in range(T):
    print(('Yes' if solve(*list(map(int,input().split()))) else 'No'))
# Original solution
def solve(P):
    A, B, C, D = P
    if A<B or D<B:
        return False
    if C >= B-1:
        return True
    g = gcd(B,D)
    return B + A%g - g <= C

from math import gcd

T = int(eval(input()))
for _ in range(T):
    P = list(map(int, input().split()))
    print(("Yes" if solve(P) else "No"))

# Optimized solution
def solve(P):
    A, B, C, D = P
    if A<B or D<B:
        return False
    if C >= B-1:
        return True
    g = gcd(B,D)
    return A%g + ((B-A%g-1)//g)*g <= C

from math import gcd

T = int(eval(input()))
for _ in range(T):
    P = list(map(int, input().split()))
    print(("Yes" if solve(P) else "No"))
# Original solution
t = int(eval(input()))
abcd_list = [[int(i) for i in input().split()] for _ in range(t)]

for i in range(len(abcd_list)):
    a, b, c, d = abcd_list[i]
    _a = a
    is_ok = True
    for j in range(100000):
        if d < b:
            is_ok = False
            break
            
        if _a - b > c:
            _a -= (((_a - c) // b) - 1) * b
        _a -= b
        if _a < 0:
            is_ok = False
            break
        if _a <= c:
            _a += d
    if is_ok:
        print("Yes")
    else:
        print("No")


# Optimized solution
def gcd(a, b):
	while b:
		a, b = b, a % b
	return a
t = int(eval(input()))
abcd_list = [[int(i) for i in input().split()] for _ in range(t)]

for i in range(len(abcd_list)):
    a, b, c, d = abcd_list[i]
    if b > a:
        print("No")
        continue
    if b > d:
        print("No")
        continue
    if c > b:
        print('Yes')
        continue
    g = gcd(b, d)
    max_mod_b = b - g + a % g
    if max_mod_b > c:
        print('No')
    else:
        print("Yes")
# Original solution
def gcd(a, b):
    return a if b == 0 else gcd(b, a % b)

T = int(eval(input()))

for _ in range(T):
    a, b, c, d = list(map(int, input().split()))

    if a < b or d < b:
        flag = False
    elif c >= b - 1:
        flag = True
    else:
        g = gcd(b, d)
        flag = (b + a % g - g) <= c

    if flag:
        print("Yes")
    else:
        print("No")


# Optimized solution
def gcd(a, b):
    return a if b == 0 else gcd(b, a % b)

T, *L = list(map(int, open(0).read().split()))

for a, b, c, d in zip(*[iter(L)] * 4):

    if a < b or d < b:
        flag = False
    elif c >= b - 1:
        flag = True
    else:
        g = gcd(b, d)
        flag = (b + a % g - g) <= c

    if flag:
        print("Yes")
    else:
        print("No")
# Original solution
def judge(a,b,c,d):
    #calc border
    if a-c<0:
        border = 0
    else:
        if (a-c)%b == 0:
            border = int((a-c)/b)
        else:           
            border = int((a-c)/b)+1

    start = a-border*b

    return start
    
def check(a,b,c,d):
    if a-b<0:
        return False
    if d<b:
        return False
    if c>=b and d>=b:
        return True
#    if b%2==0 and d%2==0:
#        if (c-b+2)<0:
#            return False
#    elif (c-b+1)<0:
#        return False
    
    ans = judge(a,b,c,d)
    b_list = []
    while not ans in b_list:
        b_list.append(ans)
        if ans <= c:
            a = ans+d
        else:
            a = ans
        if a-b<0:
            return False

        ans = judge(a,b,c,d)
        if ans < 0:
            return False
    
    return True
  
N = int(eval(input()))
ABCD = []
for i in range(N):
    ABCD.append(list(map(int, input().split())))


for a,b,c,d in ABCD:
    if check(a,b,c,d):
        print("Yes")
    else:
        print("No")

# Optimized solution

def findGCD(a,b):
    if a%b == 0:
        return b
    else:
        return findGCD(b,a%b)


def judge(a,b,c,d):
    if a<b or d<b:
        return False
    elif c >= b:
        return True
    else:
        g = findGCD(b,d)
        thr = b-g+a%g
        if thr > c:
            return False
        else:
            return True
        
T = int(eval(input()))
ABCD = []
for i in range(T):
    ABCD.append(list(map(int, input().split())))
        
for a,b,c,d in ABCD:
    if judge(a,b,c,d):
        print("Yes")
    else:
        print("No")
# Original solution
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# 解説pdf https://img.atcoder.jp/agc026/editorial.pdf を見た



import array
from bisect import *
from collections import *
import fractions
import heapq 
from itertools import *
import math
import random
import re
import string
import sys


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a



def solve(A, B, C, D):
    if B > A:
        return "No"
    if B > D:
        return "No"
    if B <= C:
        return "Yes"

    g = gcd(B, D)
    if B - g + (A % g) > C:
        return "No"
    else:
        return "Yes"


T = int(eval(input()))
for t in range(T):
    A, B, C, D = list(map(int, input().split()))
    print((solve(A, B, C, D)))
    



# Optimized solution
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# 本番中には解けなかった。解説pdfにある3つの場合分けはできた。
# B個の購入を可能なかぎりしたあとの個数が、「Cより大きくBより小さい」値に
# なることがあるとNoになる、ということには気づいたのだが、
# どう解いてよいか混乱して手がつけられなかった
#
#
# 解説pdf https://img.atcoder.jp/agc026/editorial.pdf を見た
#
# B個の購入を行った直後の個数の遷移を、mod Bの世界で考える。
#   最初は A mod B個。
#   B個の購入を可能な限り行った後も A mod B個で変わらず。
#   D個入荷すると    (A + D) mod B個。
# つまり、入荷するたびに、
# A からスタートして (A + D) mod B, (A + 2D) mod B, ... と遷移していく。
# 
# 遷移を無限に繰り返すと、mod Bの世界でのとりうる値は、g = gcd(B, D)として
#   (A % g), g + (A % g), 2g + (A % g), ..., kg + (A % g) (kは、kg + (A % g)がB未満となる最大の整数) のどれかとなる。
# ここでkを直接求めるのは難しい。
# かわりに、mを整数として、mg + (A % g)が最初にB以上となるのを求めるのは簡単で、それは B + (A % g)。
# これよりひとつ分小さいのは、B + (A % g) - gで、これが kg + (A % g)に等しい。
# 
# (A % g) + B - g が、C を超える場合、次に入荷が行われない。次もBを引くと個数が負になってしまうので No。
# (A % g) + B - g が、C 以下の場合、次に入荷が行われる。Yes。
#
#
# 解説PDFの、「また，(B/g − 1) × inv(D/g, B/g) 回 D を足したときにこの上界が達成できます」
# については理解できていない。
#



import array
from bisect import *
from collections import *
import fractions
import heapq 
from itertools import *
import math
import random
import re
import string
import sys


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a


def solve(A, B, C, D):
    if B > A:
        return "No"
    if B > D:
        return "No"
    if B <= C:
        return "Yes"

    g = gcd(B, D)
    if B - g + (A % g) > C:
        return "No"
    else:
        return "Yes"


T = int(eval(input()))
for t in range(T):
    A, B, C, D = list(map(int, input().split()))
    print((solve(A, B, C, D)))
# Original solution
import sys

iT = int(eval(input()))
aR = [[int(x) for x in sLine.split()] for sLine in sys.stdin.readlines()]
#わからんから解説見た。解説見たけどgcdの下りが自分で導出できんかったのでとりあえずバカループでなんとかしてみた。これで通るかな。
def f調1(iA,iB,iC,iD):
    if iA < iB or iD < iB:
        return False
    if iC >= iB :
        return True
    iJ = iA % iB
    iK = iD % iB
    i = 1
    while True:
        j = iJ + i * iK
        if iB <= j:
            return True
        else:
            if iC < j:
                return False
        if iK == 0:
            return True
        i += 1
    return True

for eR in aR:
    if f調1(*eR) :
        print("Yes")
    else:
        print("No")


# Optimized solution
import sys

iT = int(eval(input()))
aR = [[int(x) for x in sLine.split()] for sLine in sys.stdin.readlines()]

def fGcd(iX,iY):
    while iY:
        iX,iY= iY,iX%iY
    return iX

#これものすごくわりきってるけど通るのか？

def fFunc(iA,iB,iC,iD):
    if iA < iB or iD < iB:
        return False
    elif iC >= iB :
        return True
    elif iC < iA % iB :
        return False
    elif iB -iC - 1 < fGcd(iB,iD) :
        return True
    else:
        return False

for eR in aR:
    if fFunc(*eR) :
        print("Yes")
    else:
        print("No")
# Original solution
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a % b)

import math

for i in range(int(eval(input()))):
    a, b, c, d = list(map(int, input().split()))

    if a < b:
        print('No')
        continue

    if b > d:
        print('No')
        continue

    if c >= b:
        print('Yes')
        continue

    g = gcd(b, d)
    r = a % g
    #_max = (math.ceil((b - r) / g) - 1) * g + r
    _max = ((b - r + g - 1)//g) * g + r - g
    if c < _max:
        print('No')
    else:
        print('Yes')


# Optimized solution
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a % b)

import math

for i in range(int(eval(input()))):
    a, b, c, d = list(map(int, input().split()))

    if a < b:
        print('No')
        continue

    if b > d:
        print('No')
        continue

    if c >= b:
        print('Yes')
        continue

    g = gcd(b, d)
    r = a % g
    #_max = int(math.ceil((b - r) / g) - 1) * g + r
    _max = b + r - g
    #_max = ((math.ceil((b - r) / g)) * g) + r - g
    #_max = ((b - r + g - 1)//g) * g + r - g
    if c < _max:
        print('No')
    else:
        print('Yes')
# Original solution
T = int(eval(input()))
a = []
for i in range(T):
    a.append(list(map(int, input().split())))
for r in a:
    s, b, c, d = r[0], r[1], r[2], r[3]
    mod_list = []
    if (s < b) or (b>d):
        print('No')
        continue
    if (c>b):
        print('Yes')
        continue
    while True:
        s = s%b
        if s > c:
            print('No')
            break
        s += d
        if s in mod_list:
            print('Yes')
            break
        mod_list.append(s)

# Optimized solution
def gcd(a, b):
	while b:
		a, b = b, a % b
	return a


T = int(eval(input()))
a = []
for i in range(T):
    a.append(list(map(int, input().split())))
for r in a:
    s, b, c, d = r[0], r[1], r[2], r[3]
    mod_list = []
    if (s < b) or (b>d):
        print('No')
        continue
    if (c>b):
        print('Yes')
        continue

    g = gcd(b,d)

    if b- g + s%g > c:
        print('No')
    else:
        print('Yes')
# Original solution
def gcd(X,Y):
  if X < Y:
    tmp = X
    X = Y
    Y = tmp
  if Y == 0:
    return 0
  while X % Y != 0:
    r = X % Y
    X = Y
    Y = r
  return Y
T = int(input())
Q = [list(map(int, input().split())) for _ in range(T)]
for q in Q:
  A,B,C,D = q
  if B > A:
    print('No')
  elif B > D:
    print('No')
  elif B <= C:
    print('Yes')
  else:
    A = A%B
    D = D%B
    g = gcd(B,D)
    maximum = A
    if g != 0:
      while maximum < B:
        maximum += g
      maximum -= g
    if maximum > C:
      print('No')
    else:
      print('Yes')
     


# Optimized solution
def gcd(X,Y):
  if X < Y:
    tmp = X
    X = Y
    Y = tmp
  if Y == 0:
    return 0
  while X % Y != 0:
    r = X % Y
    X = Y
    Y = r
  return Y
T = int(input())
Q = [list(map(int, input().split())) for _ in range(T)]
for q in Q:
  A,B,C,D = q
  if B > A:
    print('No')
  elif B > D:
    print('No')
  elif B <= C:
    print('Yes')
  else:
    A = A%B
    D = D%B
    g = gcd(B,D)
    maximum = A if g == 0 else B-g+A%g
    if maximum > C:
      print('No')
    else:
      print('Yes')
# Original solution
def main():
    A, B, C = list(map(int, input().split()))
    K = int(eval(input()))
    n = 0
    while n < K:
        if C < B or C < A:
            C = C * 2
            n += 1
            if C > B > A:
                print('Yes')
                return
        elif B < A:
            B = B * 2
            n += 1
            if C > B > A:
                print('Yes')
                return
    print('No')
            
main()  



# Optimized solution
def main():
    A, B, C = list(map(int, input().split()))
    K = int(eval(input()))

    cnt = 0
    while A >= B:
        B = B * 2
        cnt += 1
    
    while B >= C:
        C = C * 2
        cnt += 1
    
    if cnt <= K:
        print('Yes')
    else:
        print('No')
main()
# Original solution
a, b, c = list(map(int, input().split()))
k = int(eval(input()))

while k != 0:
    if a > b:
        b *= 2
        k -= 1
    if b > c:
        c *= 2
        k -= 1
if a < b and b < c:
    print('Yes')
else:
    print('No')

# Optimized solution
a, b, c = list(map(int, input().split()))
k = int(eval(input()))
ans = 'Yes'

while a >= b:
    b *= 2
    k -= 1

while b >= c:
    c *= 2
    k -= 1

if k < 0:
    ans = 'No'

print(ans)
# Original solution
A, B, C=list(map(int, input().split()))
K=int(eval(input()))
i=0
while i<K:
  if B<A:
    B*=2
    i+=1
  elif C<B:
    C*=2
    i+=1
    
if A<B<C:
  print('Yes')
else:
  print('No')

# Optimized solution
A, B, C=list(map(int, input().split()))
K=int(eval(input()))
i=0
while i<K:
  if B<=A:
    B*=2
  elif C<=B:
    C*=2
  i+=1
    
if A<B<C:
  print('Yes')
else:
  print('No')
# Original solution
#!/usr/bin python3
# -*- coding: utf-8 -*-

RGB_ = list(map(int, input().split()))
K = int(eval(input()))

from itertools import product
L = list(product(list(range(3)), repeat=K))
for l in L:
    RGB=RGB_[:]
    for i in l:
        RGB[i] = RGB[i]*2
        if RGB[2]>RGB[1]>RGB[0]:
            print('Yes')
            exit()
print('No')


# Optimized solution
#!/usr/bin python3
# -*- coding: utf-8 -*-

A, B, C = list(map(int, input().split()))
K = int(eval(input()))
ret = 0
while B<=A:
    B *= 2
    ret += 1
while C<=B:
    C *= 2
    ret += 1
if ret <=K:
    print('Yes')
else:
    print('No')
# Original solution
import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  #空白あり
def LS2(): return list(sys.stdin.readline().rstrip())  #空白なし

A,B,C = MI()
K = I()

a = 0
while B <= A:
    B *= 2
    a += 1
while C <= B:
    C *= 2
    a += 1

if a <= K:
    print('Yes')
else:
    print('No')


# Optimized solution
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))

A,B,C = MI()
K = I()

a = 0  # 魔術を行った回数
while B <= A:
    B *= 2
    a += 1
while C <= B:
    C *= 2
    a += 1

print(('Yes' if a <= K else 'No'))
# Original solution
a, b, c = list(map(int, input().split()))
k = int(eval(input()))

while k > 0:
  if b < a:
    b *= 2
    k -= 1
  elif c < b:
    c *= 2
    k -= 1

if a < b and b < c:
  print('Yes')
else:
  print('No')

# Optimized solution
a, b, c = list(map(int, input().split()))
k = int(eval(input()))

if b > a:
  multiplier = 2 ** k
  if c * multiplier > b:
    ans = 'Yes'
  else:
    ans = 'No'
else:
  while b <= a:
    b *= 2
    k -= 1
  multiplier = 2 ** k
  if c * multiplier > b:
    ans = 'Yes'
  else:
    ans = 'No'

print(ans)
# Original solution
def LI():
  return list(map(int,input().split()))
  
red,green,blue=LI()
k=int(eval(input()))

for i in range(0,k+1):
    r=red
    g=green*pow(2,i)
    b=blue*pow(2,k-i)
    
    if r<g<b:
        print("Yes")
        # print(red,green,blue)
        exit()
        
print("No")
        
    

# Optimized solution
a,b,c=list(map(int,input().split()))
k=int(eval(input()))
for i in range(0,k+1):
  if a<b*2**i<c*2**(k-i):
    print("Yes")
    exit()
print("No")
# Original solution
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    a, b, c = list(map(int, readline().split()))
    k = int(readline())
    cnt = 0

    while a >= b:
        b *= 2
        cnt += 1

    while b >= c:
        c *= 2
        cnt += 1

    if cnt <= k:
        print("Yes")
    else:
        print("No")


if __name__ == '__main__':
    main()


# Optimized solution
a, b, c = list(map(int, input().split()))
k = int(eval(input()))

cnt = 0

while a >= b:
    b *= 2
    cnt += 1

while b >= c:
    c *= 2
    cnt += 1

if cnt <= k:
    print("Yes")
else:
    print("No")
# Original solution
A, B, C = list(map(int, input().split()))
K = int(eval(input()))

i = 0
while i < K:
    if B <= A:
        B *= 2
        i += 1
    else:
        if C <= B:
            C *= 2
            i += 1

if A < B < C:
    print("Yes")
else:
    print("No")


# Optimized solution
A, B, C = list(map(int, input().split()))
K = int(eval(input()))

for i in range(K):
    if B <= A:
        B *= 2
    else:
        if C <= B:
            C *= 2

if A < B < C:
    print("Yes")
else:
    print("No")
# Original solution
a,b,c=list(map(int,input().split()))
k=int(eval(input()))
if a<b:
    if b<c:
        print('Yes')
    else:
        count=0
        while b>=c:
            b*=2
            count+=1
        if count<=k:
            print('Yes')
        else:
            print('No')
else:
    count=0
    while a>=b:
        b*=2
        count+=1
    while b>=c:
        c*=2
        count+=1
    if count<=k:
        print('Yes')
    else:
        print('No')

# Optimized solution
a,b,c=list(map(int,input().split()))
k=int(eval(input()))
if a<b:
    if b<c:
        print('Yes')
    else:
        count=0
        while b>=c:
            c*=2
            count+=1
        if count<=k:
            print('Yes')
        else:
            print('No')
else:
    count=0
    while a>=b:
        b*=2
        count+=1
    while b>=c:
        c*=2
        count+=1
    if count<=k:
        print('Yes')
    else:
        print('No')
# Original solution
A,B,C=list(map(int,input().split()))
K=int(eval(input()))
while K>0:
  while B<=A:
    B*=2
    K-=1
  while C<=B:
    C*=2
    K-=1
if K>=0:
  print("Yes")
else:
  print("No")

# Optimized solution
A,B,C=list(map(int,input().split()))
K=int(eval(input()))
while B<=A:
  B*=2
  K-=1
while C<=B:
  C*=2
  K-=1
if K>=0:
  print("Yes")
else:
  print("No")
# Original solution
from sys import stdin
input = stdin.readline

a,b,c = list(map(int, input().split()))
k = int(eval(input()))

cnt = 0

while a >= b:
    b *= 2
    cnt += 1

while b >= c:
    c *= 2
    cnt += 1

if(cnt <= k):
    print("Yes")
else:
    print("No")

# Optimized solution
a, b, c = list(map(int, input().split()))
k = int(eval(input()))

ans = False

for i in range(k + 1):
    for j in range(k-i+1):
        for l in range(k-i-j+1):
            aa = a * pow(2,i)
            bb = b * pow(2,j)
            cc = c * pow(2,l)
            # print("{0} {1} {2}".format(aa,bb,cc))
            if(aa  < bb  and bb < cc):
                ans = True            

if(ans):
    print("Yes")
else:
    print("No")
# Original solution
A, B, C = list(map(int,input().split()))
K = int(eval(input()))

ans = 0
if A < B < C:
    a = "Yes"
else:    
    while True:
        if B < A:
            B *= 2
            ans += 1
        if ans == K:
            break
        if B > C:
            C *= 2
            ans += 1
        if ans == K:
            break
if A < B < C:
    a = "Yes"
else:
    a = "No"
print(a)

# Optimized solution
A, B, C = list(map(int,input().split()))
K = int(eval(input()))

ans = 0
if A < B < C:
    a = "Yes"
else:    
    while True:
        if B <= A:
            B *= 2
            ans += 1
        if ans == K:
            break
        if A < B < C:
            a = "Yes"
            break
        if B >= C:
            C *= 2
            ans += 1
        if ans == K:
            break
        if A < B < C:
            a = "Yes"
            break
if A < B < C:
    a = "Yes"
else:
    a = "No"
print(a)
# Original solution
A,B,C=list(map(int,input().split()))
K=int(eval(input()))

i=0
while i<K:
    if A>=B:
        B*=2
    elif B>=C:
        C*=2
    i+=1

print(('Yes' if A<B<C else 'No'))

# Optimized solution
A,B,C=list(map(int,input().split()))
K=int(eval(input()))
i=0
while i<K:
    if A>=B:
        i+=1
        B*=2
    else:
        break
while i<K:
    if B>=C:
        i+=1
        C*=2
    else:
        break

print(('YNeos'[(A>=B)or(B>=C)::2]))
# Original solution
# -*- coding: utf-8 -*-
# モジュールのインポート
import math

# 標準入力を取得
A, B, C = list(map(int, input().split()))
K = int(eval(input()))

# 求解処理
ans = str()
k_b = 0
if A >= B:
    k_b = int(math.log(A / B) / math.log(2)) + 1
if k_b > K:
    ans = "No"
else:
    if 2**(K - k_b) * C > 2**k_b * B:
        ans = "Yes"
    else:
        ans = "No"

# 結果出力
print(ans)


# Optimized solution
# -*- coding: utf-8 -*-

def get_input() -> tuple:
    """
    標準入力を取得する.

    Returns:\n
        tuple: 標準入力
    """
    A, B, C = list(map(int, input().split()))
    K = int(eval(input()))

    return A, B, C, K

def main(A: int, B: int, C: int, K: int) -> None:
    """
    メイン処理.

    Args:\n
        A (int): 整数（1 <= A <= 7）
        B (int): 整数（1 <= B <= 7）
        C (int): 整数（1 <= C <= 7）
        K (int): 操作回数（1 <= K <= 7）
    """
    # 求解処理
    cnt = 0
    while A >= B:
        cnt += 1
        B *= 2
    while B >= C:
        cnt += 1
        C *= 2

    # 結果出力
    if cnt <= K:
        print("Yes")
    else:
        print("No")

if __name__ == "__main__":
    # 標準入力を取得
    A, B, C, K = get_input()

    # メイン処理
    main(A, B, C, K)
# Original solution
A, B, C = list(map(int, input().split()))
K = int(eval(input()))

while K > 0:
    if A > B:
        B *= 2
        K -= 1
    else:
        if B > C:
            C *= 2
            K -= 1

if A < B and B < C:
    print("Yes")
else:
    print("No")

# Optimized solution
A, B, C = list(map(int, input().split()))
K = int(eval(input()))
n = 0

while A >= B:
    B *= 2
    n += 1

while B >= C:
    C *= 2
    n += 1

if n <= K:
    print("Yes")
else:
    print("No")
# Original solution
import math
a,b,c = list(map(int,input().split()))
k = int(eval(input()))
ans = 0
while(a >= b):
  b = pow(b,2)
  ans += 1
while(b >= c):
  c = pow(c,2)
  ans += 1
if(ans <= k):
  print('Yes')
else:
  print('No')

# Optimized solution
a, b, c = list(map(int, input().split()))
k = int(eval(input()))
ans = 0
while b <= a:
    b *= 2
    ans += 1
while c <= b:
    c *= 2
    ans += 1
print(('Yes' if ans <= k else 'No'))
# Original solution
# -*- coding: utf-8 -*-
"""
@author: H_Hoshigi
"""
def main():
    A, B, C = list(map(int, input().split()))
    K = int(eval(input()))

    answer = "No"
    while K >= 1:
        if A>=B:
            B *= 2
            K -= 1
        elif B>=C:
            C *= 2
            K -= 1
    if A<B and B<C:
        answer = "Yes"
    print(answer)

if __name__ == "__main__":
    main()



# Optimized solution
# -*- coding: utf-8 -*-
"""
@author: H_Hoshigi
"""
def main():
    A, B, C = list(map(int, input().split()))
    K = int(eval(input()))

    answer = "No"
    for i in range(K):
        if A>=B:
            B *= 2
        elif B>=C:
            C *= 2
    if A<B and B<C:
        answer = "Yes"
    print(answer)

if __name__ == "__main__":
    main()
# Original solution
#template
def inputlist(): return [int(j) for j in input().split()]
#template
A,B,C = inputlist()
K = int(eval(input()))
count = 0
while count < K:
    if A > B:
        B = 2*B
        count +=1
        continue
    if B > C:
        C = 2*C
        count +=1
        continue
    if A < B<C:
        print("Yes")
        exit()
if A < B < C:
    print("Yes")
else:
    print("No")

# Optimized solution
a,b,c = list(map(int,input().split()))
k = int(eval(input()))

ans = 'No'
for i in range(k+1):
  if a < b*(2**i) < c*(2**(k-i)):
    ans = 'Yes'
    
print(ans)