Problem:
 Score : 300 points    Problem Statement Find the price of a product before tax such that, when the consumption tax rate is 8 percent and 10 percent, the amount of consumption tax levied on it is A yen and B yen, respectively. (Yen is the currency of Japan.)  Here, the price before tax must be a positive integer, and the amount of consumption tax is rounded down to the nearest integer.  If multiple prices satisfy the condition, print the lowest such price; if no price satisfies the condition, print -1 .      Constraints  1 \leq A \leq B \leq 100  A and B are integers.         Input Input is given from Standard Input in the following format:  A  B       Output If there is a price that satisfies the condition, print an integer representing the lowest such price; otherwise, print -1 .        Sample Input 1 2 2      Sample Output 1 25  If the price of a product before tax is 25 yen, the amount of consumption tax levied on it is:   When the consumption tax rate is 8 percent: \lfloor 25 \times 0.08 \rfloor = \lfloor 2 \rfloor = 2 yen.  When the consumption tax rate is 10 percent: \lfloor 25 \times 0.1 \rfloor = \lfloor 2.5 \rfloor = 2 yen.   Thus, the price of 25 yen satisfies the condition. There are other possible prices, such as 26 yen, but print the minimum such price, 25 .       Sample Input 2 8 10      Sample Output 2 100  If the price of a product before tax is 100 yen, the amount of consumption tax levied on it is:   When the consumption tax rate is 8 percent: \lfloor 100 \times 0.08 \rfloor = 8 yen.  When the consumption tax rate is 10 percent: \lfloor 100 \times 0.1 \rfloor = 10 yen.        Sample Input 3 19 99      Sample Output 3 -1  There is no price before tax satisfying this condition, so print -1 .

Solution (Python):
import math
taxA, taxB= map(int,input().split())

minPriceA = math.ceil(taxA / 0.08)
maxPriceA = math.ceil((taxA + 1) / 0.08) 

minPriceB = math.ceil(taxB / 0.1)
maxPriceB = math.ceil((taxB + 1) / 0.1) 

minPrice = None
finish = False
for a in range(minPriceA, maxPriceA):
	for b in range(minPriceB, maxPriceB):
		if (a == b):
			minPrice = a
			finish = True
			break
	if (finish):
		break
if minPrice == None:
	print(-1)
else:
	print(minPrice)

Solution (Python):

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

import math

ans = -1

for n in range(1001):
        if math.floor(n*0.08) == A and math.floor(n*0.1) == B:
            ans = int(n)
            break

print(ans)

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

for i in range(10, 1251):
    if int(i*0.08) == a and int(i*0.1) == b:
        print(i)
        exit()
print('-1')

Solution (Python):


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

for n in range(10 * B, 10 * (B + 1)):
    if 25 * A <= 2 * n < 25 * (A + 1):
        print(n)
        break
else:
    print(-1)

Solution (Python):
a,b=map(int,input().split())
r=-1
for i in range(1001):
    if i*8//100==a and i*10//100==b:
        r=i
        break
print(r)

Solution (Python):
import math
A, B = map(int, input().split())
lst = []
for i in range(1, 1010):
    if int(i*0.08) == A and int(i*0.1) == B:
        lst.append(i)

if len(lst) > 0:
    print(lst[0])
else:
    print(-1)

Solution (Python):
a, b = map(int, input().split())
y=b*10
f=False
for i in range(y, y+10):
  if i*8//100 == a:
    print(i)
    f=True
    break
if not f:
  print(-1)

Solution (Python):
A,B = map(int,input().split())

for i in range(1001):
    a = int(i * 0.08)
    b = int(i* 0.10)
    if a == A and b == B:
        print(i)
        quit()
        
print(-1)

Solution (Python):
a,b=map(int,input().split())
ans=-1
for i in range(10000,-1,-1):
  tax1=int(i*0.08)
  tax2=int(i*0.1)
  if tax1==a and tax2==b:
    ans=i
print(ans)

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

for i in range(1010):
    if int(i * 0.08) == a and int(i * 0.1) == b:
        print(i)
        exit(0)
else:
    print(-1)

Solution (Python):
A,B=map(int,input().split())
ans=-1
for i in range(4950):
  a=int(i*0.08)
  b=int(i*0.10)
  if a==A and b==B:
    ans=i
    break
print(ans)

Solution (Python):
'''input
8 10
'''
import math

a, b = input().split()
a = int(a)
b = int(b)

a_low = math.ceil((a + 0.000) / 0.08)
a_hig = math.floor((a + 0.999) / 0.08)

b_low = math.ceil((b + 0.000) / 0.1)
b_hig = math.floor((b + 0.999) / 0.1)

if b_low <= a_low and a_low <= b_hig:
    print(a_low)
    exit()

if a_low <= b_low and b_low <= a_hig:
    print(b_low)
    exit()

print(-1)

Solution (Python):
A, B = map(int, input().split())

for i in range(10000):
    a = int(i * 0.08)
    b = int(i * 0.1)

    if A == a and B == b:
        print(i)
        exit(0)

print(-1)

Solution (Python):
a,b=tuple(map(int,input().split()))
c=25*a
d=10*b
if -(-c // 2) <= d < (c+25)/2 :
    print(d)
elif d <= -(-c // 2) < d+10:
    print(-(-c // 2))
else:
    print(-1)

Solution (Python):
import math
A, B = (int(x) for x in input().split(' '))

for i in range(1001):
  p8 = math.floor(i*0.08)
  p1 = math.floor(i*0.10)
  
  if p8 == A and p1 == B:
    print(i)
    break
  
  if i >= 1000:
    print(-1)

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)


def main():
    a,b = LI()
    for i in range(b*10,(b+1)*10):
        if math.floor(i*0.08) == a:
            return i

    return -1


print(main())

Solution (Python):
A, B= map(int,input().split())
ans = -1
for i in range(1001):
    if int(i*0.08) == A and int(i*0.1) == B:
        ans = i
        break
print(ans)

Solution (Python):
import math 
a, b = map(int,input().split())
result = -1
 
for i in range(1,1001):
    pa = math.floor(i * 0.08)
    pb = math.floor(i * 0.1)
 
    if pa == a and pb == b :
        result = i
        break
print(result)

Solution (Python):
import math

a, b = map(int,input().split())

c = 1
while True:
    if math.floor(c*0.08) == a and math.floor(c*0.1) == b:
        print(c)
        break
    
    if c == 100000:
        break
    
    c += 1

if c == 100000:
    print(-1)

Solution (Python):
import math

A, B = map(int, input().split())
y = 0
while y <= 1000:
	if math.floor(y * 0.08) == A and math.floor(y * 0.1) == B:
		print(y)
		break
	y += 1
else:
	print(-1)

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

for i in range(1,1001):
    if int(i*0.08)==a and int(i*0.1)==b:
        print(i)
        exit()
print(-1)

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

for i  in range(1010):
  if int(i*0.08)==a and int(i*0.1)==b:
    li.append(i)
    ans=li[0]
    break
  else:
    ans=-1
print(ans)

Solution (Python):
A, B = map(int, input().split())

d = {}
for n in range(1250, 0, -1):
    a = int(n * 0.08)
    b = int(n * 0.10)
    if 1 <= a and 1 <= b:
        d[(a, b)] = n

print(d.get((A, B), -1))

Solution (Python):
import math
A,B = map(int,input().split())


low =  math.ceil(A / 0.08)
high = math.floor((A+1) / 0.08)


low_B = math.ceil(B / 0.1)
high_B = math.floor((B+1) / 0.1)

is_found = False
for price in range(low,high) :
    
    if (low_B <= price and price < high_B) :
        is_found = True
        print(price)
        break

if (not is_found) :
    print("-1")

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

for i in range(1, 10001):
    if int(i * 0.08) == a:
        if int(i*0.1) == b:
            print(i)
            exit()

print(-1)

Solution (Python):
import math
A,B = map(int,input().split())
for i in range(1,1250):
	if math.floor(i*0.08) == A and math.floor(i*0.1) == B:
		print(i)
		exit();
print(-1)

Solution (Python):
import math

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

for i in range(1,1250):
  if math.floor(i*0.08) == A and math.floor(i*0.1) == B:
    print(i)
    exit();

print(-1)

Solution (Python):
A, B =map(int, input().split())

r = -1
for i in range(1001):
    if i *8//100==A and i *10//100==B:
        r = i
        break
print(r)

Solution (Python):
import math 
a, b = map(int,input().split())
result = -1

for i in range(1,1001):
    pa = math.floor(i * 0.08)
    pb = math.floor(i * 0.1)

    if pa == a and pb == b :
        result = i
        break
print(result)

Solution (Python):
A, B = map(int, input().split())
for i in range(1,1001):
    if A== int(i*0.08) and B== int(i*0.1):
        print(i)
        break
else:
    print(-1)

Solution (Python):
a=list(map(int,input().split()))
for i in range(2000):
  if int(i*0.08)==a[0] and int(i*0.1)==a[1]:
    print(i)
    break
else:
  print(-1)

Solution (Python):
import sys
import math

sys.setrecursionlimit(1000000)
input = lambda: sys.stdin.readline().rstrip()

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

i = 1
while True:
    if math.floor(i * 0.08) == A and math.floor(i * 0.1) == B:
        print(i)
        exit(0)
    if math.floor(i * 0.1) > B:
        break
    i += 1

print(-1)

Solution (Python):
import math
A,B = map(int,input().split())
ans = []
for i in range(1,1300):
    if math.floor(i * 0.08) == A and math.floor(i * 0.10) == B:
        ans.append(i)
if ans == []:
    print(-1)
else:
    print(min(ans))

Solution (Python):
import math
a,b = map(int,input().split())
ans = 0
a_min = math.ceil(12.5 * a)
a_max = 12.5 * (a + 1)
b_min = math.ceil(10 * b)
b_max = 10 * (b + 1)
min = max(a_min,b_min)
if min < a_max and min < b_max:
    ans = min
else:
    ans = -1
print(int(ans))

Solution (Python):
import math

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

for i in range(1, 1009 + 1):
    if math.floor(i * 0.08) == A and math.floor(i * 0.10) == B:
        answer = i
        break
else:
    answer = -1

print(answer)

Solution (Python):
import math

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

for i in range(1, 1025 + 1):
    if math.floor(i * 0.08) == A and math.floor(i * 0.10) == B:
        answer = i
        break
else:
    answer = -1

print(answer)

Solution (Python):
A,B=map(int,input().split())
for i in range(10000):
  if A==int(i*0.08) and B==int(i*0.1) :
    print(i)
    exit()
print("-1")

Solution (Python):
import math
a=input().split()
A,B=int(a[0]),int(a[1])
flg=0
for i in range(1,1001):
    if(math.floor(i*0.08)==A and math.floor(i*0.10)==B):
        print(i)
        flg=1
        break
if(flg==0):
    print(-1)

Solution (Python):
A,B = map(int, input().split())


for i in range(1,1010,1):
  ans_8 = int(i * 0.08)
  if A == ans_8:
    ans_10 = int(i * 0.10)    
    if B == ans_10:
      print(i)
      exit()
else:
  print('-1')

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

for num in range(12000):
    a_ = int(num * 0.08)
    b_ = int(num * 0.1)
    if a_ == a and b_ == b:
        print(num)
        break
else:
  print(-1)

Solution (Python):
import sys
sys.setrecursionlimit(1000000)
input = sys.stdin.readline
from bisect import *
from collections import *
from heapq import *
INF = 500000
mod = 10**9+7

A, B = map(int, input().split())
s1, s2 = set(), set()
for i in range(10000):
    if int(i*0.08) == A:
        s1.add(i)
    if int(i*0.10) == B:
        s2.add(i)
s = s1 & s2
if len(s) == 0:
    print(-1)
else:
    print(min(s))

Solution (Python):
def main(sample_file = ''):

    """ convenient functions
    
    
    
    
    
    """

    """convenient decorator
    
    
        
        
        
        
        
        
        
        
        
        
    """
    
    
    import sys
    sys.setrecursionlimit(10**7)
    from itertools import accumulate, combinations, permutations, product 
    
    from math import factorial, ceil, floor, sqrt
    def factorize(n):
        """return the factors of the Arg and count of each factor
        
        Args:
            n (long): number to be resolved into factors
        
        Returns:
            list of tuples: factorize(220) returns [(2, 2), (5, 1), (11, 1)]
        """
        fct = []  
        b, e = 2, 0  
        while b * b <= n:
            while n % b == 0:
                n = n // b
                e = e + 1
            if e > 0:
                fct.append((b, e))
            b, e = b + 1, 0
        if n > 1:
            fct.append((n, 1))
        return fct
    def combinations_count(n, r):   
        """Return the number of selecting r pieces of items from n kinds of items.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        
        if n < 0 or r < 0:
            raise Exception('combinations_count(n, r) not defined when n or r is negative')
        if n - r < r: r = n - r
        if r < 0: return 0
        if r == 0: return 1
        if r == 1: return n
        numerator = [n - r + k + 1 for k in range(r)]
        denominator = [k + 1 for k in range(r)]
        for p in range(2,r+1):
            pivot = denominator[p - 1]
            if pivot > 1:
                offset = (n - r) % p
                for k in range(p-1,r,p):
                    numerator[k - offset] /= pivot
                    denominator[k] /= pivot
        result = 1
        for k in range(r):
            if numerator[k] > 1:
                result *= int(numerator[k])
        return result
    def combinations_with_replacement_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items allowing individual elements to be repeated more than once.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        if n < 0 or r < 0:
            raise Exception('combinations_with_replacement_count(n, r) not defined when n or r is negative')
        elif n == 0:
            return 1
        else:
            return combinations_count(n + r - 1, r)
    from bisect import bisect_left, bisect_right
    from collections import deque, Counter, defaultdict 
    from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest 
    from copy import deepcopy, copy 
    import operator
    from operator import itemgetter 
    
    
    from functools import reduce, lru_cache
    def chmin(x, y):
        """change minimum
        if x > y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current minimum value
            y (long): potential minimum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x > y:
            x = y
            return (x, True)
        else:
            return (x, False)
    def chmax(x, y):
        """change maximum
        if x < y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current maximum value
            y (long): potential maximum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x < y:
            x = y
            return (x, True)
        else:
            return (x, False)

    from fractions import gcd 
    def gcds(numbers):
        return reduce(gcd, numbers)
    def lcm(x, y):
        return (x * y) // gcd(x, y)
    def lcms(numbers):
        return reduce(lcm, numbers, 1)
    def make_divisors(n, reversed=False):
        """create list of divisors
        
        Args:
            number (int): number from which list of divisors is created
            reversed (bool, optional): ascending order if False. Defaults to False.
        
        Returns:
            list: list of divisors
        """
        divisors = set()
        for i in range(1, int(n**0.5)+1):
            if n % i == 0:
                divisors.add(i)
                divisors.add(n//i)
        return sorted(list(divisors),reverse=reversed)
    
    
    
    INF = 10 ** 18
    MOD = 10 ** 9 + 7
    modpow = lambda a, n, p = MOD: pow(a, n, p) 
    def modinv(a, p = MOD):
        
        
        return modpow(a, p-2, p)
    def modinv_list(n, p = MOD):
        if n <= 1:
            return [0,1][:n+1]
        else:
            inv_t = [0,1]
            for i in range(2, n+1):
                inv_t += [inv_t[p % i] * (p - int(p / i)) % p]
            return inv_t
    def modfactorial_list(n, p = MOD):
        if n == 0:
            return [1]
        else:
            l = [0] * (n+1)
            tmp = 1
            for i in range(1, n+1):
                tmp = tmp * i % p
                l[i] = tmp
            return l
    def modcomb(n, k, fac_list = [], p = MOD):
        
        
        from math import factorial
        if n < 0 or k < 0 or n < k: return 0
        if n == 0 or k == 0: return 1
        if len(fac_list) <= n:
            a = factorial(n) % p
            b = factorial(k) % p
            c = factorial(n-k) % p
        else:
            a = fac_list[n]
            b = fac_list[k]
            c = fac_list[n-k]
        return (a * modpow(b, p-2, p) * modpow(c, p-2, p)) % p
    def modadd(a, b, p = MOD):
        return (a + b) % MOD
    def modsub(a, b, p = MOD):
        return (a - b) % p
    def modmul(a, b, p = MOD):
        return ((a % p) * (b % p)) % p
    def moddiv(a, b, p = MOD):
        return modmul(a, modpow(b, p-2, p))

    class UnionFindTree:
        """union find tree class
        TODO: fix this description...
        how to use (example):
        >>  uf = UnionFindTree(N) 
        >>  if uf.find_root(a) == uf.find_root(b):
        >>      do something
        >>  else:
        >>      do something
        >>      uf.unite(a, b)
        """
        def __init__(self, N):
            self.root = [-1] * (N+1)
            self.rank   = [0]  * (N+1)
            self.connected_num = [1] * (N+1)
    
        def find_root(self,x):
            root = self.root
            while root[x] != -1:
                x = root[x]
            return x
    
        def unite(self,x,y):
            root = self.root
            rank = self.rank
            connected_num = self.connected_num
            find_root = self.find_root
    
            rx = find_root(x)
            ry = find_root(y)
            if rx != ry:
                if rank[rx] < rank[ry]:
                    root[rx] = ry
                    rx,ry = ry,rx
                else:
                    if rank[rx] == rank[ry]:
                        rank[rx] += 1
                    root[ry] = rx       
                connected_num[rx] += connected_num[ry]

    
    
    
    
    

    def BellmanFord(N, M, ABC, vertex_start, vertex_end, value_if_inf = -1, find_shortest = False):
        """to calculate furthest or shortest length between vertex_start and vertex_end using BellmanFord algorithm
        
        Args:
            N (int): number of vertices
            M (int): number of edges
            ABC (list): [(ai, bi, ci) for _ in range(N)] where i-th edge is directed from vertex ai to vertex bi and the length is ci 
            vertex_start (int): start vertex. usually use 0.
            vertex_end (int): end vertex. usually use N-1.
            value_if_inf (int or string as you like, optional): value you want when the furthest (or shortest) distance is infinite (or -infinite). Defaults to -1.
            find_shortest (bool, optional): choose False to find furthest path. Defaults to False.
        
        Returns:
            int or string: normally int (but can be str if you set value_if_inf to str)
            
        Example:
                N, M, P = R()
                ABC = [R() for _ in range(M)]
                ABC = [(a-1, b-1, c-P) for a, b, c in ABC]
                print(BellmanFord(N, M, ABC, 0, N-1, value_if_inf = 'inf'))

        """

        def make_reachable_list(N, M, ABC, vertex_start, vertex_end):
            reachable_to_direct = defaultdict(list)
            reachable_from_direct = defaultdict(list)
            reachable_from_start = [False] * N
            reachable_to_end = [False] * N
            reachable_from_start[vertex_start] = True
            reachable_to_end[vertex_end] = True
            reachable_from_both_sides = [False] * N
            dfs_from_start = []
            dfs_to_end = []
            for a, b, c in ABC:
                reachable_to_direct[a].append(b)
                reachable_from_direct[b].append(a)
                if a == vertex_start:
                    dfs_from_start.append(b)
                    reachable_from_start[b] = True
                if b == vertex_end:
                    dfs_to_end.append(a)
                    reachable_to_end[a] = True
            while dfs_from_start:
                v = dfs_from_start.pop()
                for i in reachable_to_direct[v]:
                    if not reachable_from_start[i]:
                        reachable_from_start[i] = True
                        dfs_from_start.append(i)
            while dfs_to_end:
                v = dfs_to_end.pop()
                for i in reachable_from_direct[v]:
                    if not reachable_to_end[i]:
                        reachable_to_end[i] = True
                        dfs_to_end.append(i)
            for i in range(N):
                reachable_from_both_sides[i] = reachable_from_start[i] and reachable_to_end[i]
            return reachable_from_both_sides
        
        reachable_from_both_sides = make_reachable_list(N, M, ABC, vertex_start, vertex_end)
        
        if find_shortest:
            dist = [INF for i in range(N)]
        else:
            dist = [-INF for i in range(N)]
        
        dist[vertex_start] = 0
        for i in range(N):
            updated = False
            for a, b, c in ABC:
                if not reachable_from_both_sides[a]:
                    continue
                elif find_shortest:
                    update_condition = dist[a] + c < dist[b]
                else:
                    update_condition = dist[a] + c > dist[b]
                if dist[a] != INF and update_condition:
                    dist[b] = dist[a] + c
                    updated = True
                    if i == N-1:
                        return value_if_inf
            if not updated:
                break
        return dist[vertex_end]

    """ initialize variables and set inputs
    
        
        
            
            
    
        
        
        
        
        
        
        
    
        
        
        
        
    
        
        
    """

    
    r = lambda: sys.stdin.readline().strip()
    r_int = lambda: int(r())
    r_float = lambda: float(r())
    R = lambda: list(map(int, r().split()))
    R_str = lambda: r().split()
    R_map = lambda: map(int, r().split())
    R_float = lambda: list(map(float, r().split()))
    R_tuple = lambda: tuple(map(int, r().split()))

    """ how to treat input
    
    
    
    
    
    
    
    """

    
    if sample_file:
        sys.stdin = open(sample_file)
        
    
    
    
    A, B = R()
    for x in range(2000):
        if int(x * 0.08) == A and int(x * 0.1) == B:
            print(x)
            return
    print(-1)
    
    
    
    

    """memo: how to use defaultdict of list
    
    Dic = defaultdict(list)
    
    Dic[x].append(y)
    
    for k, v in Dic.items():
    """
    
    """memo: how to solve binary problems
    
    >>> a = 5
    >>> bin_str_a = format(a, '
    >>> print(bin_str_a)
    0b0101 
    """
    
    """memo: how to solve the problem
    creating simple test/answer
    greed
    simple dp
    graph
    """

if __name__ == '__main__':
    main()

Solution (Python):


eight, ten = list(map(int, input().split()))
for i in range(1000+5):
    if eight == int(i * 0.08) and ten == int(i * 0.1):
        print(i)
        exit()

print(-1)

Solution (Python):
import math
a,b=map(int,input().split())
f=0
for i in range(1,1001):
    if math.floor(i*0.08)==a and math.floor(i*0.1)==b:
        f=i
        break;
if f==0:
    print(-1)
else:
    print(f)

Solution (Python):
import unittest


class TestC(unittest.TestCase):
    def test_1(self):
        self.assertEqual(think(2, 2), 25)

    def test_2(self):
        self.assertEqual(think(8, 10), 100)

    def test_3(self):
        self.assertEqual(think(19, 99), -1)


def solve():
    a, b = read()
    result = think(a, b)
    write(result)


def read():
    return read_int(2)


def read_int(n):
    return read_type(int, n, sep=' ')


def read_float(n):
    return read_type(float, n, sep=' ')


def read_type(t, n, sep):
    return list(map(lambda x: t(x), read_line().split(sep)))[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(a, b):
    max_a = 100
    min_tax = 0.08
    ceil = int(max_a / min_tax) + 1
    for c in range(1, ceil + 1):
        tax_a = int(c * 0.08)
        tax_b = int(c * 0.10)
        if a == tax_a and b == tax_b:
            return c
    return -1


def write(result):
    print(result)


if __name__ == '__main__':
    
    solve()

Solution (Python):
a,b = map(int,input().split())
import math
import sys
for i in range(1,2000):
    if math.floor(i*0.08) == a and math.floor(i*0.1) == b:
        print(i)
        sys.exit()

print('-1')

Solution (Python):
a,b=map(int,input().split())
c=0
for i in range(1251):
    if int(i*0.08)==a and int(i*0.1)==b:
        print(i)
        exit()
print(-1)

Solution (Python):
a,b=map(int,input().split())
c=0
for i in range(1251):
    if int(i*0.08)==a and int(i*0.1)==b:
        print(i)
        c+=1
        break
if c==0:
    print(-1)

Solution (Python):
"""
    Template written to be used by Python Programmers.
    Use at your own risk!!!!
    Owned by enraged(rating - 5 star at CodeChef and Specialist at Codeforces).
"""
import sys
import bisect
import heapq

from collections import defaultdict as dd  
from collections import deque  
from collections import Counter as c  
from itertools import combinations as comb
from bisect import bisect_left as bl, bisect_right as br, bisect



mod = pow(10, 9) + 7
mod2 = 998244353
def data(): return sys.stdin.readline().strip()


def out(var): sys.stdout.write(var)


def l(): return list(map(int, data().split()))


def sl(): return list(map(str, data().split()))


def sp(): return map(int, data().split())


def ssp(): return map(str, data().split())


def l1d(n, val=0): return [val for i in range(n)]


def l2d(n, m, val=0): return [[val for i in range(n)] for j in range(m)]


a, b = sp()
for i in range(1, 40001):
    t1, t2 = int(0.08 * i), int(0.1 * i)
    if t1 == a and t2 == b:
        out(str(i))
        exit(0)
out("-1")

Solution (Python):
A,B = map(int,input().split())

able = False
for i in range(1,1251):
  if int(i * 0.08) == A and int(i * 0.1) == B:
    able = True
    break
print(i) if able else print(-1)

Solution (Python):
def solve():
    import math
    A, B = map(int, input().split())
    for i in range(1, 10000):
        if math.floor(i * 0.08) == A and math.floor(i * 0.1) == B:
            print(i)
            return
    print(-1)

solve()

Solution (Python):
"""
C
"""
A,B=map(int,input().split())
for i in range(10**5):
    if int(i*0.08)==A and int(i*0.1)==B:
        print(i)
        break
else:
    print(-1)

Solution (Python):
a, b = map(int, input().split())
r = -1
for price in range(1010):
    tax_8 = int(price * 0.08)
    tax_10 = int(price * 0.1)
    if tax_8 == a and tax_10 == b:
        r = price
        break
print(r)

Solution (Python):
import math
a,b=map(int,input().split())
for i in range(1,1009):
	A=math.floor(i*0.08)
	B=math.floor(i*0.1)
	if a==A and b==B:
		print(i)
		exit()
print(-1)

Solution (Python):
def f():
  a = list(map(float,input().split()))

  for i in range(0, 1251):
    if i >= a[0]/0.08 and i < (a[0]+1)/0.08 and i >= a[1]/0.1 and i < (a[1]+1)/0.1:
      print(i)
      return

  print(-1)

f()

Solution (Python):
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from functools import *
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def Golf():
    *a,=map(int,open(0))
def S_():
    return input()
def IS():
    return input().split()
def LS():
    return [i for i in input().split()]
def I():
    return int(input())
def MI():
    return map(int,input().split())
def LI():
    return [int(i) for i in input().split()]
def LI_():
    return [int(i)-1 for i in input().split()]
def NI(n):
    return [int(input()) for i in range(n)]
def NI_(n):
    return [int(input())-1 for i in range(n)]
def StoI():
    return [ord(i)-97 for i in input()]
def ItoS(nn):
    return chr(nn+97)
def LtoS(ls):
    return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
    org_inp=[]
    g=[[] for i in range(n)]
    for i in range(E):
        inp=LI()
        org_inp.append(inp)
        if index==0:
            inp[0]-=1
            inp[1]-=1
        if len(inp)==2:
            a,b=inp
            g[a].append(b)
            if not Directed:
                g[b].append(a)
        elif len(inp)==3:
            a,b,c=inp
            aa=(inp[0],inp[2])
            bb=(inp[1],inp[2])
            g[a].append(bb)
            if not Directed:
                g[b].append(aa)
    return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'

    mp=[1]*(w+2)
    found={}
    for i in range(h):
        s=input()
        for char in search:
            if char in s:
                found[char]=((i+1)*(w+2)+s.index(char)+1)
                mp_def[char]=mp_def[replacement_of_found]
        mp+=[1]+[mp_def[j] for j in s]+[1]
    mp+=[1]*(w+2)
    return h+2,w+2,mp,found
def bit_combination(k,n=2):
    rt=[]
    for tb in range(n**k):
        s=[tb//(n**bt)%n for bt in range(k)]
        rt+=[s]
    return rt
def show(*inp,end='\n'):
    if show_flg:
        print(*inp,end=end)
YN=['YES','NO']
Yn=['Yes','No']
 
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase


input=lambda: sys.stdin.readline().rstrip()
 
def ran_input():
    import random
    n=random.randint(4,16)
    rmin,rmax=1,10
    a=[random.randint(rmin,rmax) for _ in range(n)]
    return n,a

def ran_input():
    import random
    n=random.randint(4,16)
    rmin,rmax=1,10
    a=[random.randint(rmin,rmax) for _ in range(n)]
    return n,a

show_flg=False
show_flg=True

ans=0

a,b=LI()
for i in range(1,10**6):
    if int(i*0.08)==a and int(i*0.1)==b:
        print(i)
        exit()

print(-1)

Solution (Python):
import sys
import itertools

INF = 1001001001

def resolve():
  a, b = map(int, input().split())
  for i in range(10, 10100):
    if int(i * 0.08) == a and int(i * 0.10) == b:
      print(i)
      return
  print('-1')
  return

if __name__ == "__main__":
    resolve()

Solution (Python):
from math import floor
A, B = map(int,input().split())

maxX = 1250
ans = -1
for i in range(maxX):
    if (floor(i * 0.08) == A) and (floor(i * 0.1) == B):
        ans = i
        break

print(str(ans))

Solution (Python):
a, b = map(int, input().split())
for i in range(1, 1001):
    if i * 8 // 100 == a and i * 10 // 100 == b:
        print(i)
        break
else:
    print(-1)