Problem:
 Score : 200 points    Problem Statement There are some animals in a garden. Each of them is a crane with two legs or a turtle with four legs.  Takahashi says: "there are X animals in total in the garden, and they have Y legs in total." Determine whether there is a combination of numbers of cranes and turtles in which this statement is correct.      Constraints  1 \leq X \leq 100  1 \leq Y \leq 100  All values in input are integers.         Input Input is given from Standard Input in the following format:  X  Y       Output If there is a combination of numbers of cranes and turtles in which the statement is correct, print Yes ; otherwise, print No .        Sample Input 1 3 8      Sample Output 1 Yes  The statement "there are 3 animals in total in the garden, and they have 8 legs in total" is correct if there are two cranes and one turtle. Thus, there is a combination of numbers of cranes and turtles in which the statement is correct.       Sample Input 2 2 100      Sample Output 2 No  There is no combination of numbers of cranes and turtles in which this statement is correct.       Sample Input 3 1 2      Sample Output 3 Yes  We also consider the case in which there are only cranes or only turtles.

Solution (Python):


import re
import math
from collections import defaultdict
from collections import deque
import collections
from fractions import Fraction
import bisect
from queue import PriorityQueue
import itertools
from itertools import accumulate
from copy import deepcopy
import random
import time
import os
import sys
import datetime
from functools import lru_cache
from functools import reduce
readline=sys.stdin.readline
sys.setrecursionlimit(2000000)
alphabet="abcdefghijklmnopqrstuvwxyz"
numbers="0123456789"
mod=int(10**9+7)
inf=int(10**19)
class Edge():
    def __init__(self,x,y,val=1):
        self.x=x
        self.y=y
        self.val=val
class unionfind():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(n)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):
            self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def yn(b):
    if b:print("yes")
    else:print("no")
def Yn(b):
    if b:print("Yes")
    else:print("No")
def YN(b):
    if b:print("YES")
    else:print("NO")
def ispow(a,b):
    now=b
    while now<a:
        now*=b
    return now==a
def getbin(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def getfacs(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod_>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def nextcomb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:return num
def getprimes(n):
    if n==0:return []
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    ret=[]
    for a in range(n+1):
        if(A[a]):ret.append(a)
    return ret
def isprime(num):
    if(num<=1):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def ifelse(bbool,ret1,ret2):
    if bbool:return ret1
    else:return  ret2
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    return c.join(A)
def factorize(n):
    b = 2
    ret=defaultdict(int)
    while b * b <= n:
        while n % b == 0:
            n //= b
            ret[b]+=1
        b+=1
    if n > 1:ret[n]+=1
    return ret
def pm(x):
    return x//abs(x)
def inputintlist(): 
    return list(map(int,input().split()))
def inputfloatlist(): 
    return list(map(float,input().split()))
def tozero(A):
    ret=[None]*len(A)
    for a in range(len(A)):
        ret[a]=A[a]-1
    return ret
def istanchouzouka(A):
    f=True
    prev=min(A)-1
    for a in A:
        if prev>=a:
            f=False
        prev=a
    return f
def istanchouhigensyou(A):
    f=True
    prev=min(A)-1
    for a in A:
        if prev>a:
            f=False
        prev=a
    return f
def getallsum(A):
    s=sum(A)
    dp=defaultdict(int)
    dp[0]=1
    for a in range(0,len(A)):
        for b in range(s,-1,-1):
            if b-A[a]>=0:
                dp[b]+=dp[b-A[a]]
    return dp
def yuukoutomukou(edges):
    ret=deepcopy(edges)
    for edge in edges:
        if not edge.x==edge.y:
            ret.append(Edge(edge.y,edge.x,edge.val))
    return ret
def dijkstra(edges,V,start):
    mincost=[inf]*V
    G=[[] for a in range(V)]
    for edge in edges:
        G[edge.x].append([edge.val,edge.y])
    Q=PriorityQueue()
    Q.put([0,start])
    while not Q.empty():
        nowcost,nowx=Q.get()
        if mincost[nowx]==inf:
            mincost[nowx]=nowcost
            for cost,y in G[nowx]:
                newcost=nowcost+cost
                Q.put([newcost,y])
    return mincost
def warshallfloyd(edges,V):
    mincost=[[inf for b in range(V)] for a in range(V)]
    for a in range(V):mincost[a][a]=0
    for edge in edges:
        mincost[edge.x][edge.y]=min(mincost[edge.x][edge.y],edge.val)
    for k in range(V):
        for s in range(V):
            for t in range(V):
                if mincost[s][k]==inf or mincost[k][t]==inf:continue
                mincost[s][t]=min(mincost[s][t],mincost[s][k]+mincost[k][t])
    return mincost
def bellemanford(edges,V,start):
    mincost=[inf]*V
    mincost[start]=0
    for _ in range(V):
        for edge in edges:
            if mincost[edge.x]==inf:continue
            mincost[edge.y]=min(mincost[edge.y],mincost[edge.x]+edge.val)
    return mincost
def getmd(x1,y1,x2,y2):
    return abs(x1-x2)+abs(y1-y2)
def geted(x1,y1,x2,y2):
    return math.sqrt((x1-x2)**2+(y1-y2)**2)
class fordfulkerson():
    def __init__(self,edges,V,s,t):
        self.V=V
        self.used=[False]*V
        self.G=[[] for a in range(V)]
        self.s=s
        self.t=t
        for edge in edges:
            self.G[edge.x].append({"x":edge.x,"y":edge.y,"cap":edge.val,"rev":len(self.G[edge.y])})
            self.G[edge.y].append({"x":edge.y,"y":edge.x,"cap":0,"rev":len(self.G[edge.x])-1})
    def dfs(self,v,t,f=inf):
        if v==t:return f
        self.used[v]=True
        for a in range(len(self.G[v])):
            x=self.G[v][a]["x"]
            y=self.G[v][a]["y"]
            cap=self.G[v][a]["cap"]
            rev=self.G[y][self.G[x][a]["rev"]]
            if self.used[y] or cap==0:continue
            f2=self.dfs(y,t,min(f,cap))
            if f2>0:
                self.G[v][a]["cap"]-=f2
                rev["cap"]+=f2
                return f2
        return 0
    def maxflow(self):
        flow=0
        while True:
            self.used=[False]*V
            zouka=self.dfs(self.s,self.t)
            if zouka==0:break
            flow+=zouka
        return flow
def heron(a,b,c):
    s=(a+b+c)/2
    S=s(s-a)(s-b)(a-c)
    S=math.sqrt(S)
    return S
def getAreaOfTriangle(x1,y1,x2,y2,x3,y3):
    a=geted(x1,y1,x2,y2)
    b=geted(x2,y2,x3,y3)
    c=geted(x3,y3,x1,y1)
    return heron(a,b,c)








X,Y=inputintlist()
f=False
for a in range(0,200):
    for b in range(0,200):
        if a+b==X:
            if a*2+b*4==Y:
                f=True
Yn(f)

Solution (Python):
x,y = map(int,input().split())
if y%2 == 0 and 2*x <= y and y <= 4*x:
    print('Yes')
else:
    print('No')

Solution (Python):
def main():
    X, Y = map(int, input().split())
    ans = 'No'
    
    for i in range(X+1):
        if 2 * i + 4 * (X - i) == Y:
            ans = 'Yes'
            break

    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
X, Y = map(int, input().split())

ans = "No"
for i in range(101):
    for j in range(101):
        if(i+j == X and i*2+j*4==Y):
            ans = "Yes"
            break
print(ans)

Solution (Python):
def main():
    x, y= map(int,input().split())
    for i in range(x+1):
        j = x - i
        if j >= 0:
            if y == 2*i + 4*j:
                print("Yes")
                exit()

    print("No")

    
    
    




    
if __name__ == "__main__":
    main()

Solution (Python):
import sys, math




from collections import defaultdict as dd, deque, Counter

def data(): return sys.stdin.buffer.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')

INF = float('inf')
mod = 998244353


x,y=mdata()
if 4*x<y or y<2*x or y%2!=0:
    out("No")
else:
    out("Yes")

Solution (Python):
x, y = map(int, input().split())

for a in range(x + 1):
    b = x - a
    temp = a * 2 + b * 4
    if temp == y:
        print('Yes')
        exit()
print('No')

Solution (Python):
X,Y = map(int,input().split())

for i in range(0,X+1,1):
    if i*2 + (X-i)*4 == Y:
        print("Yes")
        exit()
print("No")

Solution (Python):
x, y = map(int, input().split())

for i in range(101):
    for j in range(101):
        if i + j == x and i * 2 + j * 4 == y:
            print("Yes")
            exit()

print("No")

Solution (Python):
X, Y = map(int, input().split())

flag = False

for x in range(X+1):
  y = X - x
  ashi = 2*x + 4*y
  if ashi == Y:
    flag = True

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

Solution (Python):
check = "No"
x,y = map(int,input().split())
for i in range(x+1):
  if 2 * i + 4 * (x -i) == y:
    check = "Yes"
    
print(check)

Solution (Python):
import sys



X, Y = map(int, input().split())






for i in range(0,X+1):
    if i * 2 + (X-i) * 4 == Y:
        print("Yes")
        sys.exit()







print('No')

Solution (Python):
X,Y = map(int,input().split())
if (2*X > Y) or (Y > 4*X) or (Y%2 == 1):
  print("No")
else:
  print("Yes")

Solution (Python):
def main():
    X, Y = map(int, input().split())

    for i in range(0, 101):
        for j in range(0, 101):
            if i + j == X and 2*i + 4*j == Y:
                print('Yes')
                exit()

    print('No')


if __name__ == "__main__":
    main()

Solution (Python):
X, Y = map(int, input().split())
if Y - 2 * X >= 0 and (Y - 2 * X) % 2 == 0 and 4 * X - Y >= 0 and (4 * X - Y) % 2 == 0:
    print("Yes")
else:
    print("No")

Solution (Python):
x,y=map(int,input().split())
for i in range(x+1):
    if i*2+(x-i)*4==y:
        print('Yes')
        exit()
print('No')

Solution (Python):
X, Y = map(int, input().split())

a = 1/2 * (4 * X - Y)
b = 1/2 * (-2 * X + Y)

if a >= 0 and b >= 0 and (a - int(a)) == 0 and (b - int(b)) == 0:
    print("Yes")
else:
    print("No")

Solution (Python):
def LI(): return list(map(int, input().split()))
def I(): return map(int, input().split())
mod = 10**9 + 7

def main():
  x , y = I()
  for i in range(x+1):
    if 2 * i + 4 * (x-i) == y:
      print('Yes')
      exit()
    
  print('No')
  
if __name__ == '__main__':
  main()

Solution (Python):
x, y = map(int, input().split())

if x*2<=y and y<=x*4 and y%2==0:
  print('Yes')
else:
  print('No')

Solution (Python):
x , y = map(int, input().split())

if x*2<=y and y<=x*4 and y%2==0:
    print('Yes')
else:
    print('No')

Solution (Python):
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


x, y = map(int, input().split())
if 4*x-y>=0 and y>=2*x and (4*x-y)%2==0:
    print("Yes")
else:
    print("No")

Solution (Python):
X,Y=map(int,input().split())

if Y%2==1:
  print("No")
  exit()
  
if Y < 2*X or Y > 4*X:
  print("No")
  exit()
  
print("Yes")

Solution (Python):
import sys
input = sys.stdin.readline

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    mod=10**9+7
    X,Y=MI()
    flag=0
    for i in range(X+1):
        temp=2*i+(X-i)*4
        if temp==Y:
            flag=1
            break
        
    if flag==1:
        print("Yes")
    else:
        print("No")

main()

Solution (Python):
X,Y = map(int,input().split())
if Y%2:
    print('No')
    exit()
print('Yes' if 2*X <= Y <= 4*X else 'No')

Solution (Python):
x,y = map(int,input().split())
for i in range(0,x+1):
    j = x-i
    if 4*i+2*j==y:
        print('Yes')
        exit()
print('No')

Solution (Python):
def main():
    x, y = map(int, input().split())
    if y%2:
        print("No")
    elif y > x*4 or y < x*2:
        print("No")
    else:
        print("Yes")

if __name__ == "__main__":
    main()

Solution (Python):

X, Y = map(int, input().split(' '))

for a in range(X+1):
    y = a*2 + (X-a)*4
    if y == Y:
        print('Yes')
        exit()


print('No')

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline

x, y = map(int, input().split())


for turu in range(x+1):
    if turu*2 + (x-turu)*4 == y:
        print('Yes')
        exit()


print('No')

Solution (Python):
X, Y = map(int, input().split())

f = 0

for a in range(100):
    for b in range(100):
        x = a + b
        y = 2 * a + 4 * b
        if x == X and y == Y:
            f = 1
            break

    if f == 1:
        break

print(['No', 'Yes'][f])

Solution (Python):
x, y = map(int, input().split())
if y >= x * 2 and y <= x * 4 and y % 2 == 0:
  print("Yes")
else:
  print("No")

Solution (Python):
x,y=map(int,input().split())

ans='No'

if y%2==0:
  if x*2<=y and y<=x*4:
    ans='Yes'
print(ans)

Solution (Python):
x, y = map(int,input().split())

for i in range(101):
    for j in range(101):
        if i + j == x:
            if 2 * i + 4 * j == y:
                print('Yes')
                quit()
print('No')

Solution (Python):
x, y = map(int, input().split())
for t in range(101):
    for k in range(101):
        if t + k != x:
            continue
        if y == t * 2 + k * 4:
            print('Yes')
            exit()

print("No")

Solution (Python):
X, Y = map(int, input().split())

for a in range(X + 1):
    b = X - a
    if b >= 0 and 2 * a + 4 * b == Y:
        ans = 'Yes'
        break
else:
    ans = 'No'
print(ans)

Solution (Python):
x, y = map(int, input().split())
if 2 * x <= y <= 4 * x and y % 2 == 0:
    print("Yes")
else:
    print("No")

Solution (Python):

x,y = map(int,input().split())

if(y%2 == 1):
    print('No')
else:
    if(y >= x*2 and y <= x*4):
        print('Yes')
    else:
        print('No')

Solution (Python):
def main():
    bodies, legs = [int(x) for x in input().split()]

    for crane in range(bodies + 1):
        turtle = bodies - crane
        if 2 * crane + 4 * turtle == legs:
            print('Yes')
            return
    print('No')


if __name__ == '__main__':
    main()

Solution (Python):

import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left 
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep='\n')

X, Y = map(int, input().split())

for x in range(0, X+1):
    leg = 2*x + 4*(X-x)
    if Y == leg:
        print('Yes')
        exit()
else:
    print('No')

Solution (Python):
x,y = map(int, input().split())
for i in range(x + 1):
    if i * 2 + (x-i) * 4 == y:
        print('Yes')
        break
else:
    print('No')

Solution (Python):
X, Y = map(int, input().split())
for c in range(101):
  for t in range(101):
    if c+t==X and c*2+t*4==Y:
      print("Yes")
      exit(0)
print("No")

Solution (Python):
x,y = map(int,input().split())
f = 0
for i in range(100):
    for j in range(100):
        if i+j==x and i*2+j*4==y:
            print("Yes")
            f = 1
            break
    if f==1: break
else:
    print("No")

Solution (Python):
x, y = map(int, input().split())
print("Yes" if x * 2 <= y <= x * 4 and y % 2 == 0 else "No")

Solution (Python):
X,Y = map(int,input().split())
for turu in range(0,X+1):
    if 2*turu+4*(X-turu) == Y:
        print('Yes')
        break
else:
    print('No')

Solution (Python):
X, Y = list(map(int, input().split()))

for t in range(51):
    for k in range(26):
        if t * 2 + k * 4 == Y and t + k == X:
            print("Yes")
            exit(0)

print("No")

Solution (Python):
X,Y = map(int,input().split())

j = 0
for a in range(100):
  for b in range(100):
    if((a+b == X)and(a*2+b*4 == Y)):
      j = 1
      break
     
if(j == 0):
  print('No')
else:
  print('Yes')

Solution (Python):

x,y = list(map(int,input().split()))
ret = "No"
for i in range(1,x+1):
    for j in range(i+1):
        if j * 2 + (x-j) * 4 == y:
            ret = "Yes"
            break

print(ret)

Solution (Python):
x,y = map(int,input().split())
if 2*x <= y <= 4*x and y % 2 == 0:
    print('Yes')
else:
    print('No')

Solution (Python):
def resolve():
    X, Y = map(int, input().split())
    if Y%2 == 1:
        print("No")
    elif X*2 > Y:
        print("No")
    elif X*4 < Y:
        print("No")
    else:
        print("Yes")
resolve()

Solution (Python):
import sys
import math
import itertools
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7

X,Y = I()
for i in range(X+1):
    if i*2+(X-i)*4 == Y:
        print('Yes')
        exit()
print('No')

Solution (Python):

X, Y = map(int,input().split())
for i in range(1000):
    for j in range(1000):
        if i+j==X and i*2 + j * 4==Y:
            print('Yes')
            exit()
print('No')

Solution (Python):
a,b=map(int,input().split())

if 2*a<=b and 4*a>=b and b%2==0:
  print("Yes")
else:
  print("No")

Solution (Python):
X, Y = map(int, input().split())
if Y%2 == 0 and 2*X <= Y <= 4*X:
  print("Yes")
else:
  print("No")

Solution (Python):
import sys
input = sys.stdin.readline



def main():
    X, Y = [int(i) for i in input().strip().split()]
    for i in range(X + 1):
        if i * 2 + (X - i) * 4 == Y:
            return "Yes"
    return "No"


if __name__ == "__main__":
    print(main())

Solution (Python):

import collections
import itertools as it
import math

 


x, y  = map(int, input().split())





for n in range(x + 1):
    t = x - n
    k = n

    if 2 * t + 4 * k == y:
        print('Yes')
        break
else:
    print('No')

Solution (Python):
x, y = map(int, input().split())

def check(x, y):
	for c in range(x + 1):
		t = x - c
		if c * 2 + t * 4 == y:
			return True
	return False

if check(x, y):
	print("Yes")
else:
	print("No")

Solution (Python):


X,Y = map(int, input().split())

t = 0
while t<=X:
  k = X-t
  if 2*t+4*k == Y:
    print('Yes')
    break
  if t==X:
    print('No')
    break
  t += 1

Solution (Python):
X,Y = map(int,input().split())
if Y%2 == 1:
  print('No')
elif 2*X <= Y and Y <= 4*X:
  print('Yes')
else:
  print('No')

Solution (Python):
from sys import stdin
from collections import defaultdict as dd
from collections import deque as dq
import itertools as it
from math import sqrt, log, log2
from fractions import Fraction

x, y = map(int, input().split())

if y%2==1:
    print('No')
    exit()

if y > 4*x or y < 2*x:
    print('No')
    exit()

print('Yes')

Solution (Python):
X,Y = [int(i) for i in input().split()]
if Y > 4*X:
    print("No")
elif Y < 2*X:
    print("No")
elif Y%2 == 1:
    print("No")
else:
    print("Yes")

Solution (Python):
x,y=map(int, input().split())
mi=2*x
ma=4*x
ans='No'
if y%2==0 and y>=mi and y<=ma:
    ans='Yes'
print(ans)

Solution (Python):
X, Y = map(int, input().split())

for i in range(X + 1):
    if (4 * X - 2 * i) == Y:
        print("Yes")
        exit()
print("No")

Solution (Python):
x,y = map(int,input().split())
if y % 2 == 0 and x * 2 <= y and y <= x * 4:
  print("Yes")
else:
  print("No")

Solution (Python):
X,Y=map(int,input().split())
if Y%2==1:
    print("No")
else:
    if 2*X<=Y<=4*X:
        print("Yes")
    else:
        print("No")

Solution (Python):
import sys

sys.setrecursionlimit(10**6)
readline = sys.stdin.readline

def main():
    X, Y = map(int, readline().split())
    for x in range(X+1):
        for y in range(Y+1):
            if x*2 + y*4 == Y and x + y ==X:
                print('Yes')
                return
    print('No')

if __name__ == "__main__":
    main()

Solution (Python):
x, y = map(int, input().split())

if y%2 == 1:
    print("No")
    exit()

if x*2 <= y <= x*4:
    print("Yes")
else:
    print("No")

Solution (Python):
X, Y = map(int, input().split())

for i in range(X+1):
  if 2*i + 4*(X-i) == Y:
    print("Yes")
    break
else:
  print("No")

Solution (Python):
x,y=list(map(int, input().split()))
if y%2==1:
    print('No')
elif y>4*x:
    print('No')
elif y<2*x:
    print('No')
else:
    print('Yes')

Solution (Python):

x,y = map(int,input().split())


for a in range(x+1): 
    b = x - a 
    asi = 2*a + 4*b
    if y == asi:
        print("Yes")
        exit()

print("No")

Solution (Python):
X, Y = map(int, input().split())

if Y%2 == 0 and 2*X <= Y <= 4*X:
    print("Yes")
else:
    print("No")

Solution (Python):
x,y=map(int,input().split())
if y%2==1:
  print("No")
elif y>4*x:
  print("No")
elif y<2*x:
  print("No")
else:
  print("Yes")

Solution (Python):
X,Y = map(int,input().split())

for kame in range(X+1):
    hiki = X-kame
    asi = Y-2*kame
    if hiki*4==asi:
        print("Yes")
        exit()
print("No")

Solution (Python):
from math import ceil,sqrt,log,gcd
def ii():return int(input())
def si():return input()
def mi():return map(int,input().split())
def li():return list(mi())



    
x,y=mi()
f=0
if(2*x<=y<=4*x):
    if(y%2==0):
        f=1
if(f):
    print("Yes")
else:
    print("No")

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    x,y=map(int,input().split())
    for n in range(x+1):
        m=x-n
        if 2*n+4*m==y:
            print("Yes")
            sys.exit()
    print("No")

if __name__=='__main__':
    main()

Solution (Python):
X, Y = map(int, input().split())
for nc in range(X+1):
    nt = X-nc
    if Y==nc*2+nt*4:
        print("Yes")
        exit()
print("No")

Solution (Python):
X, Y = map(int, input().split())
if Y%2 == 0:
    if Y >= X*2 and Y <= X*4:
        print('Yes')
    else:
        print('No')
else:
    print('No')

Solution (Python):
X, Y = map(int, input().split())

print('Yes' if Y % 2 == 0 and X * 2 <= Y and X * 4 >= Y else 'No')

Solution (Python):
X,Y = (int(x) for x in input().split())
for a in range(X+1):
    if 2 * a + 4 * (X-a) == Y:
        print('Yes')
        break
else:
    print('No')

Solution (Python):
X,Y=map(int,input().split())
flag=False
for i in range(X+1):
    if 2*i+4*(X-i)==Y:
        flag=True
print("Yes" if flag else "No")

Solution (Python):
X, Y = map(int, input().split())
for i in range(X+1):
    kame = i * 4
    tsuru = (X - i) * 2
    if kame + tsuru == Y:
        print("Yes")
        break
else:
    print("No")

Solution (Python):
x,y=map(int,input().split())
if y%2==0 and y//2-x>=0 and 2*x-y//2>=0:
  print('Yes')
else:
  print('No')

Solution (Python):
x,y = map(int,input().split())
ans = 'No'
for i in range(x+1):    
  if i*2+(x-i)*4 == y:
    ans = 'Yes'
    break
print(ans)

Solution (Python):
x, y = map(int, input().split())
flag = False

for i in range(101):
    for j in range(101):
        if i + j == x and 2*i + 4*j == y:
            flag = True

print('Yes') if flag else print('No')

Solution (Python):



import sys
sys.setrecursionlimit(10**7)
from pprint import pprint as pp
from pprint import pformat as pf



import math

import bisect

def solve(animals, legs):
    if legs % 2 != 0:
        return False
    min_ = animals * 2
    max_ = animals * 4
    if min_ <= legs <= max_:
        return True
    else:
        return False

if __name__ == '__main__':
    animals, legs = list(map(int, input().split()))
    ans = solve(animals, legs)
    if ans:
        print("Yes")
    else:
        print("No")

Solution (Python):
x, y = map(int, input().split())

if y % 2 == 1 or y // 2 - x < 0 or 2 * x - y // 2 < 0:
    print("No")
else:
    print("Yes")

Solution (Python):
x,y=map(int,input().split())
num=y-(x*2)
if num%2==0 and num//2>=0 and num//2<=x:
    print("Yes")
else:
    print("No")

Solution (Python):
x, y = map(int, input().split())
a = 2 * x
b = 4 * x
if y % 2 == 0 and y >= a and y <= b:
    print("Yes")
else:
    print("No")

Solution (Python):
import sys


def _ia(): return map(int, sys.stdin.readline().strip().split())


def main():
    x, y = _ia()
    if y % 2 == 0 and (2*x <= y <= 4*x):
        return "Yes"
    else:
        return "No"


if __name__ == "__main__":
    print(main())

Solution (Python):
x,y=map(int,input().split())
if y%2==1:
  print('No')
else:
  if y-2*x>=0 and 4*x-y>=0:
    print('Yes')
  else:
    print('No')

Solution (Python):
X,Y=map(int, input().split())

if Y%2==0 and 2*X<=Y<=4*X:
    print("Yes")
else:
    print("No")

Solution (Python):
from __future__ import print_function
import sys


if sys.subversion[0] == "PyPy":
    import io, atexit

    sys.stdout = io.BytesIO()
    atexit.register(lambda: sys.__stdout__.write(sys.stdout.getvalue()))

    sys.stdin = io.BytesIO(sys.stdin.read())
    input = lambda: sys.stdin.readline().rstrip()
RS = raw_input
RA = lambda x=int: map(x, RS().split())
RN = lambda x=int: x(RS())


def solve():
    if y % 2 == 0 and 2*x <= y <= 4*x:
        print("Yes")
    else:
        print("No")




x, y = RA()
solve()

Solution (Python):
X, Y = map(int, input().split())

for i in range(X + 1):
    if i * 2 + (X - i) * 4 == Y:
        print('Yes')
        exit()
print('No')

Solution (Python):




X,Y = map(int,input().split())

for x in range(0,X+1):
    if 2*x+4*(X-x) == Y:
        print('Yes')
        exit()

print('No')

Solution (Python):
x, y = map(int, input().split())
for i in range(x + 1):
    s = i
    t = x - i
    if 2 * s + 4 * t == y:
        print("Yes")
        exit()
print("No")

Solution (Python):
from sys import stdin
input = stdin.readline

a, b = map(int, input().split())
flag = "No"

for x in range(a + 1):
    for y in range(a + 1):
        if x + y == a and 2 * x + 4 * y == b:
            flag = "Yes"
            break

print(flag)

Solution (Python):
x, y = map(int, input().split())
if 2*x<=y<=4*x and y%2==0:
    print('Yes')
else:
    print('No')

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
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())  

X,Y = map(int,S().split())

if Y % 2 == 1:
    print('No')
    exit()
if 2*X <= Y <= 4*X:
    print('Yes')
else:
    print('No')

Solution (Python):
x,y  = map(int, input().split())

for i in range(101):
    for j in range(101):
        if i+j == x and i*2+j*4==y:
            print("Yes")
            exit()
print("No")

Solution (Python):
import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 19
MOD = 10 ** 9 + 7

x, y = MAP()

for i in range(x+1):
    j = x - i
    if i*2 + j*4 == y:
        Yes()
        exit()
No()

Solution (Python):
X,Y = map(int,input().split())

import sys

for i in range(X+1):
    if i*2 + (X-i)*4 == Y:
        print('Yes')
        sys.exit()
        
print('No')

Solution (Python):
x, y = map(int, input().split())

m = 2*x
M = 4*x

if m <= y <= M and y%2 == 0:
  print("Yes")
else:
  print("No")

Solution (Python):
x,y=list(map(int,input().split()))
if y%2==1:
  print("No")
elif (2*x<=y)and(4*x>=y):
  print("Yes")
else:
  print("No")

Solution (Python):
import sys

def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))

def main():
    x, y = MII()
    for i in range(x+1):
        if 4*i + 2*(x-i) == y:
            print('Yes')
            exit()
    print('No')

if __name__ == '__main__':
    main()

Solution (Python):
import sys
X, Y = map(int, input().split())
for i in range(X+1):
    j = X - i
    if 2*i + 4*j == Y:
        print("Yes")
        sys.exit()
print("No")

Solution (Python):
X,Y = map(int,input().split())
count=-1
for i in range(X+1):
    j=X-i
    if 2*i+4*j==Y:
        count=1
if count==1:
    print("Yes")
else:
    print("No")

Solution (Python):
import math
import sys
from collections import deque
import heapq
import copy
import itertools
from itertools import permutations
def mi() : return map(int,sys.stdin.readline().split())
def ii() : return int(sys.stdin.readline().rstrip())
def i() : return sys.stdin.readline().rstrip()
a,b=mi()
if b%2==1:
  print("No")
  sys.exit()
if 2*a<=b<=4*a:
  print("Yes")
else:
  print("No")

Solution (Python):
X,Y = map(int,input().split())
if Y % 2 == 0 and Y >= 2*X and Y <= 4*X:
    print('Yes')
else:
    print('No')

Solution (Python):
x, y = map(int, input().split())

ok = False
for a in range(0, x + 1):
    b = x - a
    if b < 0:
        continue

    if 2 * a + 4 * b == y:
        ok = True

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

Solution (Python):
x, y = map(int, input().split())
ans = 'No'
for i in range(x+1):
    turu = i
    kame = x - i
    if 2 * turu + 4 * kame == y:
        ans = 'Yes'
        break
print(ans)

Solution (Python):

import sys
sys.setrecursionlimit(10**8)
INF = float("inf")


def main():
    X, Y = map(int, input().split())
    B = (Y - 2*X) // 2
    if 2*B == Y-2*X:
        A = X-B
        if 0 <= A and 0 <= B:
            print("Yes")
        else:
            print("No")
    else:
        print("No")
    return


if __name__ == '__main__':
    main()

Solution (Python):
import sys
x,y = map(int,input().split())

for i in range(x+1):
    if i*2 + (x-i)*4 == y:
        print("Yes")
        sys.exit()
        
print("No")

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys
import collections

mod = 10**9+7
sys.setrecursionlimit(mod) 

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

X, Y = LI()

ans = True
if Y % 2 == 1:
    ans = False

if X * 2 <= Y <= X * 4:
    pass
else:
    ans = False



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

Solution (Python):
import sys
X, Y = map(int, input().split())
for x in range(X+1):
  if Y == 2*x+4*(X-x):
    print("Yes")
    sys.exit()
print("No")

Solution (Python):
X, Y = map(int, input().split())  

for i in range(X+1):  
    if i*2 + (X-i)*4 == Y:
        print("Yes")
        exit()
print("No")