Nauuo is a girl who loves writing comments.

One day, she posted a comment on Codeforces, wondering whether she would get upvotes or downvotes.

It's known that there were $x$ persons who would upvote, $y$ persons who would downvote, and there were also another $z$ persons who would vote, but you don't know whether they would upvote or downvote. Note that each of the $x+y+z$ people would vote exactly one time.

There are three different results: if there are more people upvote than downvote, the result will be "+"; if there are more people downvote than upvote, the result will be "-"; otherwise the result will be "0".

Because of the $z$ unknown persons, the result may be uncertain (i.e. there are more than one possible results). More formally, the result is uncertain if and only if there exist two different situations of how the $z$ persons vote, that the results are different in the two situations.

Tell Nauuo the result or report that the result is uncertain.


-----Input-----

The only line contains three integers $x$, $y$, $z$ ($0\le x,y,z\le100$), corresponding to the number of persons who would upvote, downvote or unknown.


-----Output-----

If there is only one possible result, print the result : "+", "-" or "0".

Otherwise, print "?" to report that the result is uncertain.


-----Examples-----
Input
3 7 0

Output
-
Input
2 0 1

Output
+
Input
1 1 0

Output
0
Input
0 0 1

Output
?


-----Note-----

In the first example, Nauuo would definitely get three upvotes and seven downvotes, so the only possible result is "-".

In the second example, no matter the person unknown downvotes or upvotes, Nauuo would get more upvotes than downvotes. So the only possible result is "+".

In the third example, Nauuo would definitely get one upvote and one downvote, so the only possible result is "0".

In the fourth example, if the only one person upvoted, the result would be "+", otherwise, the result would be "-". There are two possible results, so the result is uncertain.

Difficulty: EASY

Solutions:
a = list(map(int, input().split()))
(x, y, z) = (a[0], a[1], a[2])
if x > y + z:
	print('+')
elif y > x + z:
	print('-')
elif x == y and z == 0:
	print('0')
else:
	print('?')


(x, y, z) = map(int, input().split())
tot = x - y
if z == 0 or z < abs(tot):
	if tot > 0:
		print('+')
	elif tot < 0:
		print('-')
	else:
		print('0')
elif z >= tot:
	print('?')


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7

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

def I():
	return int(input())

def LS():
	return input().split()

def S():
	return input()

def main():
	(a, b, c) = LI()
	if a > b + c:
		return '+'
	elif b > a + c:
		return '-'
	elif c == 0 and a == b:
		return '0'
	else:
		return '?'
print(main())


(x, y, z) = map(int, input().split())
if x - y + z < 0:
	print('-')
elif x - y - z > 0:
	print('+')
elif x - y + z == 0 and x - y - z == 0:
	print('0')
else:
	print('?')


import sys
input = sys.stdin.readline
(x, y, z) = map(int, input().split())
d = x - y
if d < 0:
	if z >= abs(d):
		print('?')
	else:
		print('-')
elif d == 0:
	if z > 0:
		print('?')
	else:
		print(0)
elif z >= d:
	print('?')
else:
	print('+')


n = input()
(x, y, z) = n.split()
x = int(x)
y = int(y)
z = int(z)
v = x - y
state1 = v + z
state2 = v - z
if state1 > 0 and state2 > 0:
	print('+')
elif state1 == 0 and state2 == 0:
	print('0')
elif state1 < 0 and state2 < 0:
	print('-')
else:
	print('?')


(upvote, downvote, uncertain) = map(int, input().split())
if upvote > downvote + uncertain:
	print('+')
elif downvote > upvote + uncertain:
	print('-')
elif upvote == downvote and uncertain == 0:
	print(0)
else:
	print('?')


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

def modulo(w):
	if w < 0:
		return -w
	else:
		return w
result = 0
if a > b:
	result = '+'
elif a < b:
	result = '-'
else:
	result = 0
if c == 0:
	print(result)
elif c >= modulo(a - b):
	print('?')
else:
	print(result)


(a, b, c) = map(int, input().split())
if a > sum((b, c)):
	print('+')
elif a - b == 0 and c == 0:
	print(0)
elif b > sum((a, c)):
	print('-')
else:
	print('?')


(x, y, z) = [int(i) for i in input().split()]
diff = abs(x - y)
if z >= diff and z != 0:
	print('?')
elif x > y:
	print('+')
elif x < y:
	print('-')
else:
	print(0)


(a, b, c) = map(int, input().split())
if a - b > 0:
	if a - b - c > 0:
		print('+')
	else:
		print('?')
if a - b == 0:
	if c == 0:
		print(0)
	else:
		print('?')
if a - b < 0:
	if a - b + c < 0:
		print('-')
	else:
		print('?')


a = list(map(int, input().split(' ')))
b = min(a[0], a[1])
a[0] -= b
a[1] -= b
if a[0] > 0:
	if a[2] >= a[0]:
		print('?')
	else:
		print('+')
elif a[1] > 0:
	if a[2] >= a[1]:
		print('?')
	else:
		print('-')
elif a[2] > 0:
	print('?')
else:
	print(0)


(x, y, z) = map(int, input().split())
b = x - y
if abs(b) > z:
	print('-' if b < 0 else '+')
elif z == 0:
	print(0)
else:
	print('?')


(x, y, z) = list(map(int, input().split()))
x += z
(A, B, C) = (False, False, False)
if x > y:
	A = True
elif x == y:
	B = True
else:
	C = True
x -= z
y += z
if x > y:
	A = True
elif x == y:
	B = True
else:
	C = True
if A and (not B) and (not C):
	print('+')
elif B and (not A) and (not C):
	print('0')
elif C and (not A) and (not B):
	print('-')
else:
	print('?')


(pl, m, n) = map(int, input().split())
if pl > m + n:
	print('+')
elif m > pl + n:
	print('-')
elif pl == m and n == 0:
	print(0)
elif pl == m and n != 0:
	print('?')
elif abs(pl - m) <= n:
	print('?')


arr = [int(x) for x in input().split()]
(x, y, z) = (arr[0], arr[1], arr[2])
if x > y + z:
	print('+')
elif y > x + z:
	print('-')
elif z == 0 and x == y:
	print('0')
else:
	print('?')


from sys import stdin
(a, b, c) = map(int, stdin.readline().strip().split())
if a > b + c:
	print('+')
elif b > a + c:
	print('-')
elif c == 0 and a == b:
	print(0)
else:
	print('?')


def vyries(x, y, z):
	if z == 0:
		if x > y:
			return '+'
		if x < y:
			return '-'
		return '0'
	(a, b) = (x + z, y + z)
	if x > b:
		return '+'
	if y > a:
		return '-'
	return '?'
(x, y, z) = list(map(int, input().split()))
print(vyries(x, y, z))


(x, y, z) = map(int, input().strip().split(' '))
diff = abs(x - y)
if x > y and diff > z:
	print('+')
elif x < y and diff > z:
	print('-')
elif x == y and z == 0:
	print('0')
else:
	print('?')


res = input().split(' ')
for i in range(len(res)):
	res[i] = int(res[i])
if res[0] > res[1] + res[2]:
	print('+')
elif res[1] > res[0] + res[2]:
	print('-')
elif res[0] is res[1] and res[2] is 0:
	print('0')
else:
	print('?')


def main():
	(x, y, z) = map(int, input().split())
	result = ''
	if x > y:
		result = '+'
	elif x == y:
		result = '0'
	else:
		result = '-'
	if z == 0:
		print(result)
		exit()
	diff = abs(x - y)
	if z >= diff:
		result = '?'
	print(result)
main()


(up, down, none) = map(int, input().split(' '))
total_votes = up + down + none
extraUp = up + none
extraDown = down + none
if up > total_votes // 2:
	print('+')
elif down > total_votes // 2:
	print('-')
elif up == down and none == 0:
	print('0')
else:
	print('?')


xyz = list(map(int, input().rstrip().split()))
up = xyz[0]
down = xyz[1]
tie = xyz[2]
if tie == 0:
	if up > down:
		print('+')
	elif down > up:
		print('-')
	else:
		print('0')
elif up == down and down == tie:
	print('?')
elif up == down and tie > up:
	print('?')
elif up > down + tie:
	print('+')
elif up == down + tie:
	print('?')
elif down > up + tie:
	print('-')
elif down == up + tie:
	print('?')
elif max(up, down) == up:
	if down + tie < up:
		print('+')
	elif down + tie == up:
		print('?')
	else:
		print('?')
elif max(up, down) == down:
	if up + tie < down:
		print('-')
	elif up + tie == down:
		print('?')
	else:
		print('?')


(x, y, z) = map(int, input().split())
ans = '?'
if x - y - z > 0 and x - y + z > 0:
	ans = '+'
if y - x - z > 0 and y - x + z > 0:
	ans = '-'
if z == 0 and x - y == 0:
	ans = '0'
print(ans)


(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
if a > b + c:
	print('+')
elif b > a + c:
	print('-')
elif c == 0:
	print('0')
else:
	print('?')


import sys, os
f = lambda : list(map(int, input().split()))
test = 'test'

def solve():
	(x, y, z) = f()
	maxup = x + z
	maxdown = y + z
	if x > maxdown:
		print('+')
	elif y > maxup:
		print('-')
	elif x == y and z == 0:
		print(0)
	else:
		print('?')
solve()


import os
import sys
from io import BytesIO, IOBase

def main():
	(x, y, z) = map(int, input().split())
	diff = x - y
	if diff > 0 and z < diff:
		print('+')
	elif diff < 0 and z < abs(diff):
		print('-')
	elif diff == 0 and z == 0:
		print(0)
	else:
		print('?')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


inp = input()
inps = inp.split()
x = int(inps[0])
y = int(inps[1])
z = int(inps[2])
if x > y + z:
	print('+')
elif y > x + z:
	print('-')
elif x == y and z == 0:
	print('0')
else:
	print('?')


(x, y, z) = map(int, input().split())
if x > y + z:
	print('+')
	exit()
if y > x + z:
	print('-')
	exit()
if y == x and z == 0:
	print(0)
	exit()
print('?')


def result():
	(x, y, z) = map(int, input().split())
	temp = x - y
	if temp > 0 and z < temp:
		return '+'
	elif temp > 0 and z >= temp:
		return '?'
	elif temp < 0 and temp * -1 > z:
		return '-'
	elif temp < 0 and temp * -1 <= z:
		return '?'
	elif temp == 0 and z == 0:
		return '0'
	else:
		return '?'
k = result()
print(k)


def check(a, b, c):
	result = a - b
	(m, n) = (result - c, result + c)
	if m == n == 0:
		return 0
	elif m > 0 and n > 0:
		return '+'
	elif m < 0 and n < 0:
		return '-'
	return '?'
(x, y, z) = [int(i) for i in input().split()]
print(check(x, y, z))


import sys
input = sys.stdin.readline
(x, y, z) = map(int, input().split())
n = x - y
if n + z > 0 and n - z > 0:
	print('+')
elif n + z == 0 and n - z == 0:
	print('0')
elif n + z < 0 and n - z < 0:
	print('-')
else:
	print('?')


(x, y, z) = map(int, input().split())
if x > y:
	if x > y + z:
		print('+')
	if x <= y + z:
		print('?')
if x < y:
	if x + z < y:
		print('-')
	if x + z >= y:
		print('?')
if x == y:
	if z == 0:
		print('0')
	else:
		print('?')


(x, y, z) = map(int, input().split(' '))
wakaru = x - y
min_ = wakaru - z
max_ = wakaru + z
if min_ < 0 and max_ >= 0 or (min_ <= 0 and max_ > 0):
	out = '?'
elif min_ == 0 and max_ == 0:
	out = '0'
elif min_ < 0 and max_ < 0:
	out = '-'
else:
	out = '+'
print(out)


inp = input().split(' ')
x = int(inp[0])
y = int(inp[1])
z = int(inp[2])
up = x
down = y
uncertain = z
vote = x - y
if x > y:
	if x > y + z:
		print('+')
	else:
		print('?')
elif x < y:
	if x + z < y:
		print('-')
	else:
		print('?')
elif x == y:
	if x + z == y and x == y + z:
		print('0')
	else:
		print('?')


l = list(map(int, input().split()))
a = l[0]
b = l[1]
c = l[2]
if a > b + c:
	print('+')
elif b > a + c:
	print('-')
elif a == b and c == 0:
	print('0')
elif a <= b + c or b <= a + c:
	print('?')


lst = input().split()
x = int(lst[0])
y = int(lst[1])
z = int(lst[2])
if x == y and z == 0:
	print('0')
elif x > y + z:
	print('+')
elif y > x + z:
	print('-')
else:
	print('?')


a = list(map(int, input().split()))
if a[0] == a[1] and a[2] == 0:
	print(0)
	exit()
if a[0] - a[1] > 0 and a[0] - a[1] > a[2]:
	print('+')
	exit()
elif a[1] - a[0] > 0 and a[1] - a[0] > a[2]:
	print('-')
	exit()
print('?')


(x, y, z) = map(int, input().split())
if x > y:
	up = x - y
	if z < up:
		print('+')
	else:
		print('?')
elif y > x:
	down = y - x
	if z < down:
		print('-')
	else:
		print('?')
elif z == 0:
	print('0')
else:
	print('?')


(n, m, b) = map(int, input().split())
import math
a = n - m
if a == 0:
	if b == 0:
		print(0)
	else:
		print('?')
if n < m:
	if n + b < m:
		print('-')
	else:
		print('?')
if n > m:
	if m + b < n:
		print('+')
	else:
		print('?')


(a, b, c) = list(map(int, input().split()))
p = z = n = 0
if a + c > b:
	p = 1
if b + c > a:
	n = 1
if a + c == b or b + c == a:
	z = 1
if p + n + z > 1:
	print('?')
elif p == 1:
	print('+')
elif n == 1:
	print('-')
elif z == 1:
	print('0')


(x, y, z) = [int(i) for i in input().split()]

def solve(x, y, z):
	if x > z + y:
		return '+'
	if y > x + z:
		return '-'
	if z == 0 and x == y:
		return '0'
	return '?'
print(solve(x, y, z))


for _ in range(1):
	(x, y, z) = map(int, input().split())
	l = x - y - z
	r = x - y + z
	if l < 0 and r < 0:
		print('-')
	elif l > 0 and r > 0:
		print('+')
	elif l == 0 and r == 0:
		print('0')
	else:
		print('?')


def nauuoAndVotes(x, y, z):
	if x == y and z == 0:
		return 0
	elif x == y and x + z > y:
		return '?'
	if x > y and y + z < x:
		return '+'
	elif x > y and y + z >= x:
		return '?'
	elif y > x and x + z < y:
		return '-'
	elif x < y and x + z >= y:
		return '?'
(x, y, z) = map(int, input().strip().split(' '))
print(nauuoAndVotes(x, y, z))


def convert(v):
	if v > 0:
		return '+'
	elif v < 0:
		return '-'
	else:
		return '0'
(x, y, z) = map(int, input().split())
total = x - y
l = total - z
r = total + z
m = convert(total)
if m == convert(l) == convert(r):
	print(m)
else:
	print('?')


(x, y, z) = map(int, input().split())
f = '?'
if x > y and y + z < x:
	f = '+'
elif y > x and x + z < y:
	f = '-'
elif x == y and (not z):
	f = '0'
print(*f)


import sys
input = sys.stdin.readline
from collections import *
(x, y, z) = map(int, input().split())
low = x - y - z
high = x - y + z
if low < 0 and high < 0:
	print('-')
elif low == 0 and high == 0:
	print('0')
elif low > 0 and high > 0:
	print('+')
else:
	print('?')


(x, y, z) = input('').split()
x = int(x)
y = int(y)
z = int(z)
if x > y + z:
	print('+')
elif y > x + z:
	print('-')
elif y == x:
	if z == 0:
		print('0')
	else:
		print('?')
elif z > x + y:
	print('?')
else:
	print('?')


(up, down, ques) = map(int, input().split())
if up > down + ques:
	print('+')
elif down > up + ques:
	print('-')
elif up == down and ques == 0:
	print('0')
else:
	print('?')


x = input()
a = x.split(' ')
a[0] = int(a[0])
a[1] = int(a[1])
a[2] = int(a[2])
if a[0] > a[1] + a[2]:
	print('+')
elif a[1] > a[0] + a[2]:
	print('-')
elif a[0] == a[1] and a[2] == 0:
	print('0')
else:
	print('?')


from math import ceil

def main():
	(x, y, z) = [int(v) for v in input().split()]
	if x > y + z:
		print('+')
	elif y > x + z:
		print('-')
	elif x + z == y and y + z == x:
		print(0)
	else:
		print('?')
main()


(a, b, c) = map(int, input().split())
d = abs(a - b)
if d > c:
	if a > b:
		print('+')
	elif b > a:
		print('-')
elif a == b and c == 0:
	print('0')
else:
	print('?')


(upvotes, downvotes, uncertain) = map(int, input().split())
if upvotes > downvotes + uncertain:
	print('+')
elif downvotes > upvotes + uncertain:
	print('-')
elif uncertain == 0 and upvotes == downvotes:
	print('0')
else:
	print('?')


import sys, os
f = lambda : list(map(int, input().split()))
if 'local' in os.environ:
	sys.stdin = open('./input.txt', 'r')

def solve():
	(x, y, z) = f()
	maxup = x + z
	maxdown = y + z
	if x > maxdown:
		print('+')
	elif y > maxup:
		print('-')
	elif x == y and z == 0:
		print(0)
	else:
		print('?')
solve()


def votes(aa):
	(x, y, z) = (aa[0], aa[1], aa[2])
	if x > y:
		if x > y + z:
			return '+'
		return '?'
	elif x < y:
		if y > x + z:
			return '-'
		return '?'
	elif x == y and z == 0:
		return 0
	else:
		return '?'
n = list(map(int, input().split()))
print(votes(n))


from sys import stdin, stdout

class scanner:
	inputIDX = 0
	Input = []
	stdin = stdin

	def __init__(self):
		self.inputGrab()

	def Out(self, x, end='\n'):
		stdout.write(str(x) + end)

	def In(self):
		return stdin.readline().strip()

	def inputGrab(self):
		for line in self.stdin:
			self.Input.extend(map(str, line.strip().split()))

	def hasNext(self):
		return True if self.inputIDX < len(self.Input) else False

	def nextInt(self):
		self.inputIDX += 1
		return int(self.Input[self.inputIDX - 1])

	def nextString(self):
		self.inputIDX += 1
		return self.Input[self.inputIDX - 1]

def main():
	s = scanner()
	x = s.nextInt()
	y = s.nextInt()
	z = s.nextInt()
	t = x - y
	if z == 0:
		if t > 0:
			print('+')
		elif t < 0:
			print('-')
		else:
			print('0')
		return
	if t >= 0:
		if t - z > 0:
			print('+')
		else:
			print('?')
	elif t + z < 0:
		print('-')
	else:
		print('?')
main()


from sys import stdin
[x, y, z] = map(int, stdin.readline().strip().split(' '))
res = x - y
if z == 0 or abs(z) < abs(res):
	if res > 0:
		print('+')
	elif res < 0:
		print('-')
	else:
		print('0')
else:
	print('?')


(x, y, z) = [int(i) for i in input().split()]
import math

def sign(a):
	if a < 0:
		return '-'
	elif a == 0:
		return '0'
	else:
		return '+'
if sign(x - y) == sign(x - y + z) and sign(x - y) == sign(x - y - z):
	print(sign(x - y))
else:
	print('?')


(a, b, c) = [int(x) for x in input().split()]
if a - b - c > 0:
	print('+')
elif c != 0:
	if a - b + c >= 0:
		print('?')
	else:
		print('-')
elif a - b == 0:
	print(0)
else:
	print('-')


(x, y, z) = map(int, input().split())
m = max(x, y)
n = min(x, y)
if m > n + z:
	if m == x:
		print('+')
	else:
		print('-')
elif m == n and z == 0:
	print('0')
else:
	print('?')


(x, y, z) = [int(i) for i in input().split()]
if x == y and z == 0:
	print(0)
elif max(x, y) <= z or (min(x, y) + z >= max(x, y) and z != 0):
	print('?')
elif x > y:
	print('+')
elif x < y:
	print('-')
else:
	print(0)


(x, y, z) = [int(x) for x in input().split()]
if x - y - z > 0:
	print('+')
elif x - y + z < 0:
	print('-')
elif x - y == 0 and z == 0:
	print(0)
else:
	print('?')


def do():
	x = a - b
	if x < 0 and abs(x) > c:
		print('-')
		return
	if x > 0 and abs(x) > c:
		print('+')
		return
	if x == 0 and c == 0:
		print('0')
		return
	print('?')
(a, b, c) = map(int, input().split())
do()


(a, b, c) = map(int, input().split())
if a == b and c == 0:
	print(0)
elif c >= abs(a - b):
	print('?')
elif b > a:
	print('-')
elif a > b:
	print('+')
elif a == b and z == 0:
	print(0)


def find_votes():
	(x, y, z) = map(int, input().split())
	if x > y + z:
		print('+')
	elif y > x + z:
		print('-')
	elif not z:
		print('0')
	else:
		print('?')
find_votes()


(x, y, z) = map(int, input().split())
if max(x, y) == x:
	sign = '+'
else:
	sign = '-'
if max(x, y) > min(x, y) + z:
	print(sign)
elif x == y and z == 0:
	print('0')
else:
	print('?')


import math
mod = 1000000007

def power(a, b):
	res = 1
	b = b % (mod - 1)
	while b > 0:
		if b % 2 != 0:
			res = res % mod * (a % mod) % mod
		b = b // 2
		a = a % mod
		a = a * a % mod
	res = res % mod
	return res
(x, y, z) = [int(i) for i in input().split()]
if x + z > y and y + z > x:
	print('?')
elif x + z == y and y > x or (x > y and y + z == x):
	print('?')
elif x > y + z:
	print('+')
elif y > x + z:
	print('-')
elif x == y and z == 0:
	print('0')


(up, down, unknown) = map(int, input().split())
known = up - down
if known > 0:
	if known > unknown:
		print('+')
	else:
		print('?')
elif known < 0:
	if -known > unknown:
		print('-')
	else:
		print('?')
elif unknown != 0:
	print('?')
else:
	print('0')


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

def case1(s):
	if s < 0:
		print('-')
	elif s == 0:
		print('0')
	elif s > 0:
		print('+')
if c == 0:
	case1(a - b)
else:
	x = a - b
	if x < 0:
		x = x * -1
	if c < x:
		case1(a - b)
	else:
		print('?')


(x, y, z) = map(int, input().split())
c = x - y
print('+' if c > 0 and c > z else '-' if c < 0 and abs(c) > z else '0' if x == y and z == 0 else '?')


import sys
import math
import array
import bisect
import collections
from collections import Counter, defaultdict
import fractions
import heapq
import re
sys.setrecursionlimit(1000000)

def array2d(dim1, dim2, init=None):
	return [[init for _ in range(dim2)] for _ in range(dim1)]

def argsort(l, reverse=False):
	return sorted(list(range(len(l))), key=lambda i: l[i], reverse=reverse)

def argmin(l):
	return l.index(min(l))

def YESNO(ans, yes='YES', no='NO'):
	print([no, yes][ans])
II = lambda : int(input())
MI = lambda : list(map(int, input().split()))
MIL = lambda : list(MI())
MIS = lambda : input().split()

def main():
	(x, y, z) = MI()
	u = x - y + z
	d = x - y - z
	if u > 0 and d > 0:
		return '+'
	if u < 0 and d < 0:
		return '-'
	if u == 0 and d == 0:
		return '0'
	return '?'

def __starting_point():
	print(main())
__starting_point()


def func(x, y):
	if x > y:
		print('+')
	elif x < y:
		print('-')
	else:
		print('0')
(x, y, z) = tuple([int(x) for x in input().split(' ')])
if z == 0:
	func(x, y)
elif z >= abs(x - y):
	print('?')
else:
	func(x, y)


import sys
import math
from functools import reduce
(x, y, z) = map(int, sys.stdin.readline().split())
if x > y:
	if x - y > z:
		print('+')
	else:
		print('?')
elif x < y:
	if y - x > z:
		print('-')
	else:
		print('?')
elif z == 0:
	print(0)
else:
	print('?')


b = input().split()
x1 = int(b[0])
x2 = int(b[1])
x3 = int(b[2])
a1 = x1 - x2
a2 = a1 - x3
a3 = a1 + x3
if a2 > 0 and a3 > 0:
	print('+')
elif a2 < 0 and a3 < 0:
	print('-')
elif a2 == 0 and a3 == 0:
	print('0')
else:
	print('?')


import time

def getResultedVotes(votes):
	votesResult = ''
	positive = votes[0]
	negative = votes[1]
	uncertain = votes[2]
	if positive > negative:
		if uncertain == 0 or positive > negative + uncertain:
			votesResult = '+'
		else:
			votesResult = '?'
	if positive < negative:
		if uncertain == 0 or negative > positive + uncertain:
			votesResult = '-'
		else:
			votesResult = '?'
	if positive == negative:
		if uncertain == 0:
			votesResult = '0'
		else:
			votesResult = '?'
	return votesResult

def solve():
	votes = [int(x) for x in input().split()]
	result = getResultedVotes(votes)
	print(result)
solve()


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [input() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [int(input()) for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def divisor(n):
		res = []
		i = 1
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				res.append(i)
				if i != n // i:
					res.append(n // i)
		return res

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

	@staticmethod
	def is_prime(n):
		if n < 2:
			return False
		if n == 2:
			return True
		if n % 2 == 0:
			return False
		d = int(n ** 0.5) + 1
		for i in range(3, d + 1, 2):
			if n % i == 0:
				return False
		return True

def pop_count(x):
	x = x - (x >> 1 & 6148914691236517205)
	x = (x & 3689348814741910323) + (x >> 2 & 3689348814741910323)
	x = x + (x >> 4) & 1085102592571150095
	x = x + (x >> 8)
	x = x + (x >> 16)
	x = x + (x >> 32)
	return x & 127
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def isOK(A):
	A.sort()
	for i in range(len(A) - 1):
		if A[i] + 1 != A[i + 1]:
			return False
	return True

def func(x):
	return 1

def solve():
	(x, y, z) = Scanner.map_int()
	r1 = x - y + z
	r2 = x - y - z
	if r1 > 0 and r2 > 0:
		print('+')
	elif r1 == 0 and r2 == 0:
		print('0')
	elif r1 < 0 and r2 < 0:
		print('-')
	else:
		print('?')

def main():
	solve()
main()


(a, b, c) = map(int, input().split())
q = a - b + c
w = a - b - c
if q > 0 and w > 0:
	print('+')
elif not q and (not w):
	print(0)
elif q < 0 and w < 0:
	print('-')
else:
	print('?')


x = list(map(int, input().split()))
if x[0] > x[1] + x[2]:
	print('+')
elif x[0] + x[2] < x[1]:
	print('-')
elif x[0] == x[1] and x[2] == 0:
	print('0')
else:
	print('?')


(x, y, z) = list(map(int, input().split(' ')))
tmp = abs(x - y)
if tmp == z == 0:
	print(0)
elif tmp > z:
	if x > y:
		print('+')
	else:
		print('-')
else:
	print('?')


(p, m, u) = map(int, input().split())

def f(i):
	if i == 0:
		return '0'
	elif i < 0:
		return '-'
	elif i > 0:
		return '+'
d = p - m
if f(d - u) != f(d + u):
	print('?')
elif d == 0:
	print(0)
elif d < 0:
	print('-')
else:
	print('+')


def sign(n):
	if n > 0:
		return 1
	if n < 0:
		return -1
	return 0
(x, y, z) = map(int, input().split())
up = sign(x - y + z)
down = sign(x - y - z)
if up * down > 0:
	print('+' if up > 0 else '-')
elif up is 0 and down is 0:
	print('0')
else:
	print('?')


(sim, nao, desconhecido) = input().split(' ')
sim = int(sim)
nao = int(nao)
desconhecido = int(desconhecido)
if sim == nao and desconhecido != 0:
	print('?')
elif sim == nao and desconhecido == 0:
	print(0)
elif sim > nao:
	pior_caso = sim - desconhecido
	if pior_caso > nao:
		print('+')
	else:
		print('?')
else:
	melhor_caso = sim + desconhecido
	if nao > melhor_caso:
		print('-')
	else:
		print('?')


import sys
import collections
input = sys.stdin.readline

def printnl(val):
	sys.stdout.write(str(val) + '\n')
(x, y, z) = map(int, input().split())
diff = x - y
if diff + z < 0 and diff - z < 0:
	print('-')
elif x + z > 0 and diff - z > 0:
	print('+')
elif diff + z == 0 and diff - z == 0:
	print('0')
else:
	print('?')


def f(x):
	if x[2] == 0:
		if x[0] > x[1]:
			return 1
		elif x[0] == x[1]:
			return 2
		else:
			return 3
	elif x[0] > x[1]:
		if x[0] == x[1] + x[2]:
			return 4
		else:
			x[0] = x[0] - 1
			x[2] = x[2] - 1
			return f(x)
	elif x[0] == x[1]:
		return 4
	elif x[1] == x[0] + x[2]:
		return 4
	else:
		x[1] = x[1] - 1
		x[2] = x[2] - 1
		return f(x)
n = input().split()
x = list()
for i in n:
	x.append(int(i))
if f(x) == 1:
	print('+')
elif f(x) == 2:
	print(0)
elif f(x) == 3:
	print('-')
else:
	print('?')


import sys
import heapq
import re
import bisect
import random
import math
import itertools
from collections import defaultdict, deque
from copy import deepcopy
from decimal import *
readl = lambda : list(map(int, sys.stdin.readline().split()))
readt = lambda : tuple(map(int, sys.stdin.readline().split()))
read = lambda : sys.stdin.readline().rstrip()
readi = lambda : int(read())
readmi = lambda : map(int, sys.stdin.readline().split())
readms = lambda : map(str, sys.stdin.readline().split())
(x, y, z) = readmi()
if x == y and z == 0:
	print(0)
elif x > y and x > y + z:
	print('+')
elif y > x and y > x + z:
	print('-')
else:
	print('?')


(a, b, c) = input('').split()
x = int(a)
y = int(b)
z = int(c)
if x == y and z == 0:
	print(0)
elif x == y and z != 0:
	print('?')
elif x > y and x - y > z:
	print('+')
elif x < y and y - x > z:
	print('-')
else:
	print('?')


import sys
input = sys.stdin.readline
(x, y, z) = [int(x) for x in input().strip().split()]
if x > y + z:
	print('+')
elif y > x + z:
	print('-')
elif x == y and z == 0:
	print('0')
else:
	print('?')


(x, y, z) = input().split(' ')
x = int(x)
y = int(y)
z = int(z)
t = x - y
s = '?'
if abs(x - y) > z:
	if x - y > 0:
		s = '+'
	elif x - y < 0:
		s = '-'
elif x - y == 0 and z == 0:
	s = '0'
print(s)


import sys, heapq
from collections import deque, defaultdict
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(input())
inl = lambda : list(map(int, input().split()))
inm = lambda : map(int, input().split())
DBG = True

def ddprint(x):
	if DBG:
		print(x)
(x, y, z) = inm()
if x - y - z > 0:
	print('+')
elif x - y + z < 0:
	print('-')
elif x - y == 0 and z == 0:
	print('0')
else:
	print('?')


def main():
	(x, y, z) = input().split(' ')
	x = int(x)
	y = int(y)
	z = int(z)
	val = x - y + z
	if val > 0:
		st = '+'
	elif val < 0:
		st = '-'
	else:
		st = '0'
	val2 = x - y - z
	if val2 > 0:
		st2 = '+'
	elif val2 < 0:
		st2 = '-'
	else:
		st2 = '0'
	if st == st2:
		print(st)
	else:
		print('?')
main()


l = list(map(int, input().split()))
print('+' if l[0] > l[1] + l[2] else '-' if l[1] > l[2] + l[0] else '0' if l[1] == l[0] and l[2] == 0 else '?')


def votes(up, down, draw):
	if up == down:
		if draw != 0:
			return '?'
		else:
			return '0'
	if up > down:
		if up > down + draw:
			return '+'
		else:
			return '?'
	elif down > up + draw:
		return '-'
	else:
		return '?'
(x, y, z) = list(map(int, input().split()))
print(votes(x, y, z))


from sys import stdin, stdout
(x, y, z) = map(int, stdin.readline().split())
if z == 0 and x == y:
	stdout.write('0\n')
elif x + z < y:
	stdout.write('-\n')
elif y + z < x:
	stdout.write('+\n')
else:
	stdout.write('?\n')


def Nauuo_and_voices():
	(x, y, z) = map(int, input().split(sep=' '))
	if x + z < y:
		print('-')
	elif y + z < x:
		print('+')
	elif x == y and z == 0:
		print('0')
	else:
		print('?')
Nauuo_and_voices()


while True:
	try:
		(x, y, z) = map(int, input().split())
		if x > y + z:
			print('+')
		elif y > x + z:
			print('-')
		elif x == y and z == 0:
			print('0')
		else:
			print('?')
	except EOFError:
		break
	except ValueError:
		break


(x, y, z) = list(map(int, input().split()))
num = x - y
if num > 0:
	print('+' if num - z > 0 else '?')
elif num < 0:
	print('-' if num + z < 0 else '?')
elif num == 0:
	print('0' if z == 0 else '?')


(x, y, z) = [int(s) for s in input().split()]
a = x - y - z
b = x - y + z
if a > 0:
	print('+')
elif a < 0 and b > 0:
	print('?')
elif a < 0 and b < 0:
	print('-')
elif a == 0 and b == 0:
	print('0')
elif a == 0 and b != 0:
	print('?')
elif a != 0 and b == 0:
	print('?')


(a, b, c) = (int(i) for i in input().split())
if a - b > 0:
	if a - b > c:
		ans = '+'
	else:
		ans = '?'
if a - b == 0:
	if c == 0:
		ans = 0
	else:
		ans = '?'
if a - b < 0:
	if b - a > c:
		ans = '-'
	else:
		ans = '?'
print(ans)


a = [int(i) for i in input().split()]
if a[0] == a[1] and a[2] == 0:
	print('0')
elif abs(a[0] - a[1]) > a[2]:
	if a[0] > a[1]:
		print('+')
	else:
		print('-')
else:
	print('?')


(x, y, z) = map(int, input().split())
if x < y:
	if x + z < y:
		print('-')
	elif x + z >= y:
		print('?')
elif y < x:
	if y + z < x:
		print('+')
	elif y + z >= x:
		print('?')
elif x == y:
	if x + z > y:
		print('?')
	elif x + z == y + z:
		print('0')


def voting_result(x, y, z):
	result = x - y
	if result == 0 and z == 0:
		return '0'
	elif result > 0 and result > z:
		return '+'
	elif result < 0 and result < -z:
		return '-'
	else:
		return '?'
(x, y, z) = map(int, input().split())
print(voting_result(x, y, z))


voice = input().split(' ')
(x, y, z) = (int(voice[0]), int(voice[1]), int(voice[2]))
a = x - y
if z >= abs(a) and a != 0 or (z > 0 and a == 0):
	print('?')
elif a < 0:
	print('-')
elif a > 0:
	print('+')
else:
	print('0')


from sys import stdin
input = stdin.readline
(x, y, z) = map(int, input().split())
xm = x + z
ym = y + z
result = set()
result.add(0 if xm == y else (xm - y) // abs(xm - y))
result.add(0 if x == ym else (x - ym) // abs(x - ym))
if len(result) > 1:
	print('?')
else:
	r = result.pop()
	if r > 0:
		print('+')
	elif r == 0:
		print(0)
	else:
		print('-')


def main():
	(x, y, z) = map(int, input().split())
	if x == y:
		if z == 0:
			print(0)
		else:
			print('?')
	elif y > x:
		diff = y - x
		if diff > z:
			print('-')
		else:
			print('?')
	else:
		diff = x - y
		if diff > z:
			print('+')
		else:
			print('?')
main()


pass
(u, d, n) = map(int, input().split())
if u > d + n:
	print('+')
elif d > u + n:
	print('-')
elif u == d and n == 0:
	print('0')
else:
	print('?')


(y, n, o) = list(map(int, input().split()))
if y - n - o == 0:
	if o == 0:
		print('0')
	elif y - n <= o:
		print('?')
	elif y - n > o:
		print('0')
elif y - n - o > 0:
	print('+')
elif y - n - o < 0:
	if n - y <= o:
		print('?')
	else:
		print('-')


(a, b, c) = list(map(int, input().split()))
if a > b and a > b + c:
	print('+')
elif a > b and a <= b + c:
	print('?')
elif b > a and b > a + c:
	print('-')
elif b > a and b <= a + c:
	print('?')
elif a == 0 and b == 0 and (c != 0):
	print('?')
elif a == b and c == 0:
	print('0')
elif a == b and c > 0:
	print('?')


def getN():
	return int(input())

def getList():
	return list(map(int, input().split()))
(x, y, z) = getList()
if z >= abs(x - y):
	if z == 0:
		print(0)
	else:
		print('?')
elif x > y:
	print('+')
else:
	print('-')


from math import *
from copy import *
from string import *
from random import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
import math

def bin1(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = k ** mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin1(mid + 1, r, k, t, b, val, ans)
		else:
			return bin1(l, mid - 1, k, t, b, val, ans)

def bin2(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = t * k ** mid + b * mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin2(l, mid - 1, k, t, b, val, ans)
		else:
			return bin2(mid + 1, r, k, t, b, val, ans)

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	l = []
	for i in range(2, n + 1):
		if prime[i]:
			l.append(i)
	return l

def bin(l, r, ll, val):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		if val >= ll[mid][0] and val <= ll[mid][1]:
			return mid
		elif val < ll[mid][0]:
			return bin(l, mid - 1, ll, val)
		else:
			return bin(mid + 1, r, ll, val)

def deci(n):
	s = ''
	while n != 0:
		if n % 2 == 0:
			n = n // 2
			s = '0' + s
		else:
			n = n // 2
			s = '1' + s
	return s

def diff(s1, s2):
	if len(s1) < len(s2):
		v = len(s1)
		while v != len(s2):
			s1 = '0' + s1
			v = v + 1
	else:
		v = len(s2)
		while v != len(s1):
			s2 = '0' + s2
			v = v + 1
	c = 0
	for i in range(len(s1)):
		if s1[i:i + 1] != s2[i:i + 1]:
			c = c + 1
	return c
from sys import stdin, stdout

def fac(a, b):
	v = a
	while a != b:
		v *= a - 1
		a = a - 1
	return v

def bino(l, r, n):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		val1 = math.log(n / mid + 1, 2)
		val2 = int(val1)
		if val1 == val2:
			return val1
		elif val1 < 1.0:
			return bino(l, mid - 1, n)
		else:
			return bino(mid + 1, r, n)

def binary(l, r, ll, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		if ll[mid] == val:
			return ll[mid]
		elif ll[mid] < val:
			ans = ll[mid]
			return binary(mid + 1, r, ll, val, ans)
		else:
			return binary(l, mid - 1, ll, val, ans)

def check(n):
	v = 1
	while n != 0:
		if n % 10 == 0 or n % 10 == 1:
			n = n // 10
		else:
			v = 0
			break
	return v
(a, b, c) = map(int, input().split(' '))
if abs(a - b) <= c and c != 0:
	print('?')
elif a > b:
	print('+')
elif a < b:
	print('-')
else:
	print(0)


(uv, dv, u) = map(int, input().split())
if uv > dv and dv + u < uv:
	print('+')
elif uv < dv and uv + u < dv:
	print('-')
elif uv == dv and u == 0:
	print('0')
else:
	print('?')


import sys
import math
import bisect

def main():
	A = list(map(int, input().split()))
	B = []
	for i in range(0, A[2] + 1):
		a = A[0] + i
		b = A[1] + (A[2] - i)
		B.append(a - b)
	C = []
	if min(B) < 0:
		C.append('-')
	if max(B) > 0:
		C.append('+')
	if 0 in B:
		C.append('0')
	if len(C) == 1:
		print(C[0])
	else:
		print('?')
main()


from sys import stdin
line = stdin.readline().split(' ')
x = int(line[0])
y = int(line[1])
z = int(line[2])
if y - z > x:
	print('-')
elif x - z > y:
	print('+')
elif y - z == x and x - z == y:
	print('0')
else:
	print('?')


from math import *
import sys, random

def nextInt():
	return int(input())

def nextStrs():
	return input().split()

def nextInts():
	return list(map(int, nextStrs()))

def main():
	(a, b, z) = nextInts()
	res = '?'
	if a == b:
		res = '0'
	elif a < b:
		res = '-'
	else:
		res = '+'
	a += z
	if a == b:
		if res != '0':
			res = '?'
	elif a < b:
		if res != '-':
			res = '?'
	elif res != '+':
		res = '?'
	if res == '?':
		print(res)
		return 0
	a -= z
	b += z
	if a == b:
		if res != '0':
			res = '?'
	elif a < b:
		if res != '-':
			res = '?'
	elif res != '+':
		res = '?'
	if res == '?':
		print(res)
		return 0
	print(res)
exit(main())


from sys import stdin
(a, b, c) = stdin.readline().strip().split()
x = int(a)
y = int(b)
z = int(c)
if x + z > y and y + z > x:
	print('?')
elif x + z > y and y + z < x:
	print('+')
elif x + z < y and y + z > x:
	print('-')
elif x == y:
	print('0')
else:
	print('?')


(c, d, u) = map(int, input().split())
if c > d:
	if c - d > u:
		print('+')
	else:
		print('?')
elif d > c:
	if d - c > u:
		print('-')
	else:
		print('?')
elif u == 0:
	print('0')
else:
	print('?')


arr = input().split(' ')
x = int(arr[0])
y = int(arr[1])
z = int(arr[2])
if x > y:
	if x > z + y:
		print('+')
	else:
		print('?')
elif x < y:
	if y > z + x:
		print('-')
	else:
		print('?')
elif z == 0:
	print('0')
else:
	print('?')


def max1(a):
	p = a[0]
	for x in a:
		if x > p:
			p = x
	return p

def prlist(a):
	for x in a:
		print(x, end=' ')
(x, y, z) = list(map(int, input().split()))
if x > y + z:
	print('+')
elif y > z + x:
	print('-')
elif x == y and z == 0:
	print('0')
else:
	print('?')


number_x = 0
number_y = 0
number_z = 0

def Input(number_x, number_y, number_z):
	(number_x, number_y, number_z) = list(map(int, input().split()))
	return (number_x, number_y, number_z)

def Output(number_x, number_y, number_z):
	if number_x > number_y + number_z:
		print('+')
	elif number_y > number_x + number_z:
		print('-')
	elif number_x == number_y:
		if number_z == 0:
			print('0')
		else:
			print('?')
	else:
		print('?')
(number_x, number_y, number_z) = Input(number_x, number_y, number_z)
Output(number_x, number_y, number_z)


def solve(x, y, z):
	res = set()
	for a in range(z + 1):
		b = z - a
		s = x + a
		t = y + b
		if s < t:
			res.add('-')
		elif s > t:
			res.add('+')
		else:
			res.add('0')
	return res
(x, y, z) = [int(x) for x in input().split()]
res = solve(x, y, z)
if len(res) > 1:
	print('?')
else:
	print(next(iter(res)))


import math
(up, dv, un) = list(map(int, input().split()))
if up - dv > 0 and un < up - dv:
	print('+')
elif up - dv > 0 and un >= up - dv:
	print('?')
elif up - dv < 0 and un < abs(up - dv):
	print('-')
elif up - dv < 0 and un >= abs(up - dv):
	print('?')
elif up - dv == 0 and un == 0:
	print('0')
elif up - dv == 0 and un > 0:
	print('?')


(a, b, c) = map(int, input().split())
if c == 0:
	if a == b:
		print('0')
		quit()
	if a < b:
		print('-')
		quit()
	if a > b:
		print('+')
		quit()
if a + c < b:
	print('-')
	quit()
if b + c < a:
	print('+')
	quit()
print('?')


(x, y, z) = map(int, input().split())
s = x - y
c1 = s + z
c2 = s - z
c3 = s
if c1 > 0 and c2 > 0 and (c3 > 0):
	print('+')
elif c1 < 0 and c2 < 0 and (c3 < 0):
	print('-')
elif c1 == 0 and c2 == 0 and (c3 == 0):
	print('0')
else:
	print('?')


(x, y, z) = [int(x) for x in input().split()]
if abs(x - y) > z or z == 0:
	if x > y:
		print('+')
	elif x == y:
		print('0')
	else:
		print('-')
else:
	print('?')


votes = input().split()
(u, d, q) = (int(votes[0]), int(votes[1]), int(votes[2]))
if u == d and q == 0:
	print('0')
elif u - d - q > 0:
	print('+')
elif d - u - q > 0:
	print('-')
else:
	print('?')


(plus, minus, anon) = [int(i) for i in input().split()]
if plus > minus + anon:
	print('+')
elif minus > plus + anon:
	print('-')
elif anon == 0 and minus == plus:
	print('0')
else:
	print('?')


def main():
	[x, y, z] = map(int, input().split())
	current_result = x - y
	if current_result == 0 and z == 0:
		print('0')
	elif current_result - z > 0:
		print('+')
	elif current_result + z < 0:
		print('-')
	else:
		print('?')
main()


t = input()
a = list(map(int, t.split()))
f = []
if a[0] + a[2] > a[1]:
	f.append('+')
if a[1] + a[2] > a[0]:
	f.append('-')
if a[0] + a[2] == a[1] or a[1] + a[2] == a[0]:
	f.append('0')
if len(f) == 1:
	print(f[0])
else:
	print('?')


a = input()
c = []
b = 0
for i in range(len(a)):
	if a[i] == ' ':
		c.append(a[b:i])
		b = i + 1
c.append(a[b:])
if int(c[0]) - int(c[1]) > 0 and int(c[0]) - int(c[1]) > int(c[2]):
	print('+')
elif int(c[1]) - int(c[0]) > 0 and int(c[1]) - int(c[0]) > int(c[2]):
	print('-')
elif int(c[0]) == int(c[1]) and int(c[2]) == 0:
	print('0')
else:
	print('?')


line = list(map(int, input().split(' ')))
(up, down, uncertain) = line
s0 = up - down
if abs(uncertain) == 0:
	if s0 > 0:
		print('+')
	elif s0 == 0:
		print('0')
	else:
		print('-')
elif abs(s0) > abs(uncertain):
	if s0 > 0:
		print('+')
	else:
		print('-')
else:
	print('?')


(x, y, z) = list((int(a) for a in input().split()))
if abs(x - y) <= z and z != 0:
	print('?')
elif x > y:
	print('+')
elif y > x:
	print('-')
else:
	print('0')


(x, y, z) = list(map(int, input().split()))
if x == y and z == 0:
	print(0)
elif x == y and z > 0 or max(x, y) - min(x, y) <= z:
	print('?')
elif x > y:
	print('+')
elif y > x:
	print('-')
else:
	print(0)


(x, y, z) = list(map(int, input().split()))
a = x - y
if abs(a) - z > 0:
	if a < 0:
		print('-')
	elif a == 0:
		print(0)
	else:
		print('+')
elif a == 0 and z == 0:
	print(0)
else:
	print('?')


sgn = lambda x: -1 if x < 0 else 1 if x > 0 else 0
results = ['0', '+', '-']
(upvotes, downvotes, uncertain) = [int(x) for x in input().split(' ')]
decision = upvotes - downvotes
print('?' if uncertain >= abs(decision) and (not uncertain == 0) else results[sgn(decision)])


(yes, no, z) = list(map(int, input().split()))
if z == 0 and yes == no:
	print(0)
elif yes > no + z:
	print('+')
elif yes + z < no:
	print('-')
else:
	print('?')


gi = lambda : list(map(int, input().strip().split()))
(x, y, z) = gi()
if x - z > y:
	print('+')
	exit()
if y - z > x:
	print('-')
	exit()
if x == y and z == 0:
	print('0')
	exit()
print('?')


a = str(input())
b = []
b = a.split()
x = int(b[0])
y = int(b[1])
z = int(b[2])
if x == y and z == 0:
	print('0')
elif x + z == y + z:
	print('?')
elif x == 0 and y == 0 and (z > 0):
	print('?')
elif x + z == y or y + z == x:
	print('?')
elif x + z > y and y + z < x:
	print('+')
elif y + z > x and x + z < y:
	print('-')
else:
	print('?')


(p, m, u) = map(int, input().split())
d = p - m
if u == 0:
	if d == 0:
		print('0')
	elif d > 0:
		print('+')
	else:
		print('-')
elif abs(d) <= u:
	print('?')
elif d == 0:
	print('0')
elif d > 0:
	print('+')
else:
	print('-')


def f():
	(x, y, z) = map(int, input().split())
	if z == 0:
		if x > y:
			print('+')
		elif x < y:
			print('-')
		else:
			print('0')
	elif x + z < y:
		print('-')
	elif y + z < x:
		print('+')
	else:
		print('?')
f()


from sys import stdin
(x, y, z) = [int(x) for x in stdin.readline().rstrip().split()]
if x > y + z:
	print('+')
elif y > x + z:
	print('-')
elif z == 0 and x == y:
	print('0')
else:
	print('?')


(x, y, z) = tuple(map(int, input().split()))
a = x + z
b = y + z
if a > y and x > b:
	print('+')
elif y > a and b > x:
	print('-')
elif a == b and z == 0:
	print('0')
else:
	print('?')


def main():
	s = [int(x) for x in input().split()]
	x = s[0]
	y = s[1]
	z = s[2]
	if z > 0:
		if x - y > z:
			print('+')
		elif y - x > z:
			print('-')
		else:
			print('?')
	elif x > y:
		print('+')
	elif y > x:
		print('-')
	elif x == y:
		print('0')
	else:
		print('?')
main()


import sys, math

def read_int():
	return int(sys.stdin.readline().strip())

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

def read_string():
	return sys.stdin.readline().strip()

def read_string_list(delim=' '):
	return sys.stdin.readline().strip().split(delim)
(x, y, z) = read_int_list()
(maxi, mini) = (x - y + z, x - y - z)
if maxi == mini == 0:
	print(0)
elif maxi < 0:
	print('-')
elif mini > 0:
	print('+')
else:
	print('?')


w = input()
ww = w.split()
x = int(ww[0])
y = int(ww[1])
z = int(ww[2])
if x > y + z:
	print('+')
elif y > x + z:
	print('-')
elif z == 0 and x == y:
	print(0)
else:
	print('?')


x = list(map(int, input().split()))
f1 = x[0] + x[2] > x[1]
f2 = x[2] + x[1] > x[0]
f3 = x[2] + x[1] == x[0] or x[0] + x[2] == x[1]
if f1 and f2 or (f1 and f3) or (f2 and f3):
	print('?')
elif f1:
	print('+')
elif f2:
	print('-')
else:
	print('0')


(a, b, c) = map(int, input().split())
x = a - b + c
y = a - b - c
d = '0'
e = '0'
if x > 0:
	d = '+'
if x < 0:
	d = '-'
if y > 0:
	e = '+'
if y < 0:
	e = '-'
if d == e:
	print(d)
else:
	print('?')


(a, b, c) = map(int, input().split())
anyway = a - b
if a - b < 0:
	if a - b + c >= 0:
		print('?')
	else:
		print('-')
elif a - b > 0:
	if a - b - c <= 0:
		print('?')
	else:
		print('+')
elif a - b == 0:
	if c != 0:
		print('?')
	else:
		print('0')


def solve(x, y, z):
	if y + z > x and y > x + z:
		return '-'
	elif x + z > y and x > y + z:
		return '+'
	elif x + z == y and y + z == x:
		return '0'
	else:
		return '?'

def main():
	(x, y, z) = list(map(int, input().split()))
	print(solve(x, y, z))
main()


def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	list(mi())
(x, y, z) = mi()
if x > y:
	if x > y + z:
		print('+')
	else:
		print('?')
elif x < y:
	if x + z < y:
		print('-')
	else:
		print('?')
elif z == 0:
	print('0')
else:
	print('?')


import itertools

def input_ints():
	return list(map(int, input().split()))

def output_list(v):
	print(' '.join((str(x) for x in v)))

def main():
	(a, b, c) = input_ints()
	x = a - b + c
	y = a - b - c
	if y > 0:
		print('+')
	elif x < 0:
		print('-')
	elif x == 0 and y == 0:
		print(0)
	else:
		print('?')
main()


INF = 100000000
t = 1
for test in range(t):
	(x, y, z) = map(int, input().split())
	if x > y + z:
		print('+')
	elif x + z < y:
		print('-')
	elif z == 0 and x == y:
		print('0')
	else:
		print('?')


from sys import stdin, stdout, exit as sys_ret
(f_input, f_print, f_flush) = (stdin.readline, stdout.write, stdout.flush)
(x, y, z) = map(int, f_input().split())
score = x - y
if score > 0:
	if score - z <= 0:
		f_print('?')
	else:
		f_print('+')
elif score < 0:
	if score + z >= 0:
		f_print('?')
	else:
		f_print('-')
elif score + z > 0 or score - z < 0:
	f_print('?')
else:
	f_print('0')


(positivo, negativo, pendente) = [int(x) for x in input().split()]
if positivo > negativo + pendente:
	print('+')
elif negativo > positivo + pendente:
	print('-')
elif positivo == negativo and pendente == 0:
	print('0')
else:
	print('?')


(p, m, x) = map(int, input().split())
if p == m and x == 0:
	print(0)
elif abs(p - m) == x:
	print('?')
elif abs(p - m) < x:
	print('?')
elif p > m:
	print('+')
else:
	print('-')


(pos, neg, un) = map(int, input().split())
if pos > neg and pos > neg + un:
	print('+')
elif neg > pos and neg > pos + un:
	print('-')
elif pos == neg and un == 0:
	print(0)
else:
	print('?')


import sys, math
data = sys.stdin.readlines()
(x, y, z) = list(map(int, data[0].strip().split(' ')))
if x > y + z:
	print('+')
elif y > x + z:
	print('-')
elif x == y and z == 0:
	print('0')
else:
	print('?')


def Thanos():
	(x, y, z) = list(map(int, input().split()))
	mi = x - y - z
	ma = x - y + z
	if mi == ma:
		if mi == 0:
			print(0)
		elif mi < 0:
			print('-')
		else:
			print('+')
	elif mi > 0:
		print('+')
	elif ma < 0:
		print('-')
	else:
		print('?')
Thanos()


import sys, os, io
from sys import stdin
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import math
alphabets = list('abcdefghijklmnopqrstuvwxyz')

def isPrime(x):
	for i in range(2, x):
		if i * i > x:
			break
		if x % i == 0:
			return False
	return True

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	return list(set(l))

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def si():
	return input()

def divideCeil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

def ii():
	return int(input())

def li():
	return list(map(int, input().split()))
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def solve():
	(x, y, z) = li()
	if abs(x - y) <= z and z != 0:
		print('?')
	else:
		if x == y:
			print('0')
			return
		if x > y:
			print('+')
		else:
			print('-')
t = 1
for _ in range(t):
	solve()


(X, Y, Z) = map(int, input().split())
now = X - Y
if abs(now) <= Z:
	if now == 0 and Z == 0:
		print('0')
	else:
		print('?')
elif now > 0:
	print('+')
else:
	print('-')


(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
d = a + c - b
e = b + c - a
if c == 0:
	if a > b:
		print('+')
	elif b > a:
		print('-')
	else:
		print('0')
elif d * e < 0:
	if d > 0:
		print('+')
	else:
		print('-')
else:
	print('?')


(up, down, no) = list(map(int, input().split()))
if up + no < down:
	print('-')
elif down + no < up:
	print('+')
elif up == down and no == 0:
	print(0)
else:
	print('?')


import math
(a, b, x) = [int(i) for i in input().split()]
c = abs(a - b)
if c > x:
	if a > b:
		print('+')
	elif a < b:
		print('-')
elif x == 0:
	print(0)
elif c < x:
	print('?')
else:
	print('?')


x = [int(a) for a in input().split()]
fS = x[0] - x[1]
pos = fS + x[2]
neg = fS - x[2]
if neg > 0 and fS > 0:
	print('+')
elif neg <= 0 and fS > 0:
	print('?')
elif fS < 0 and pos < 0:
	print('-')
elif fS < 0 and pos >= 0:
	print('?')
elif fS == 0 and pos == 0 and (neg == 0):
	print('0')
else:
	print('?')


(a, b, c) = map(int, input().split())
ans = '?'
if c == 0:
	c = a - b
	if c > 0:
		ans = '+'
	elif c < 0:
		ans = '-'
	else:
		ans = 0
elif abs(a - b) > c:
	ans = '+' if a - b > 0 else '-'
print(ans)


import sys
inf = float('inf')
mod = 1000000007

def get_array():
	return list(map(int, sys.stdin.readline().split()))

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

def input():
	return sys.stdin.readline()

def int1():
	return int(input())
import string
import math
from itertools import combinations

def main():
	(x, y, z) = get_array()
	if x > y and z == 0:
		print('+')
	if z > 0:
		if x < y:
			if x + z > y:
				print('?')
			if x > y + z:
				print('+')
			if y > x + z:
				print('-')
		if x > y:
			if y + z > x:
				print('?')
			if y > x + z:
				print('-')
			if x > y + z:
				print('+')
		if x + z == y or y + z == x:
			print('?')
	if y > x and z == 0:
		print('-')
	if x == y and z == 0:
		print('0')
	if x == y and z != 0:
		print('?')
main()


n = [int(i) for i in input().split()]
if n[0] - n[1] - n[2] > 0 and n[0] - n[1] + n[2] > 0:
	print('+')
elif n[0] - n[1] - n[2] == 0 and n[0] - n[1] + n[2] == 0:
	print('0')
elif n[0] - n[1] - n[2] < 0 and n[0] - n[1] + n[2] < 0:
	print('-')
else:
	print('?')


(x, y, z) = map(int, input().split())
a = x + z
b = y + z
Q = a >= y
W = b >= x
E = z == 0 and x == y
if E:
	print(0)
elif Q and W:
	print('?')
elif Q:
	print('+')
else:
	print('-')


(p, n, u) = map(int, input().split())
if u == 0 and p == n:
	print('0')
elif p - n > u:
	print('+')
elif n - p > u:
	print('-')
else:
	print('?')


(x, y, z) = map(int, input().split())
ans = x - y
a = []
if ans < 0:
	a.append('-')
elif ans == 0:
	a.append('0')
else:
	a.append('+')
for i in range(-z, z + 1, 2):
	if ans + i < 0:
		a.append('-')
	elif ans + i == 0:
		a.append('0')
	else:
		a.append('+')
a = list(set(a))
if len(a) > 1:
	print('?')
else:
	print(a[0])


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

def decision():
	if x - y > 0:
		print('+')
	if x - y == 0:
		print('0')
	if x - y < 0:
		print('-')
if z == 0:
	decision()
elif abs(x - y) > z:
	decision()
else:
	print('?')


def show():
	(x, y, z) = map(int, input().rstrip().split())
	if x > y:
		if x - y <= z:
			print('?')
		else:
			print('+')
	elif y > x:
		if y - x <= z:
			print('?')
		else:
			print('-')
	elif z == 0:
		print('0')
	else:
		print('?')
show()


num_people = input()
num_l = num_people.split()
x = int(num_l[0])
y = int(num_l[1])
z = int(num_l[2])
if z == 0 and x == y:
	print('0')
elif x > y + z:
	print('+')
elif y > x + z:
	print('-')
else:
	print('?')


import sys
import os
from io import BytesIO, IOBase

def cel(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def prr(a, sep=' '):
	print(sep.join(map(str, a)))

def dd():
	return defaultdict(int)

def ddl():
	return defaultdict(list)

def ddd():
	return defaultdict(defaultdict(int))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from collections import defaultdict
(x, y, z) = mi()
if abs(x - y) <= z and z != 0:
	print('?')
elif x > y:
	print('+')
elif x < y:
	print('-')
else:
	print('0')


(i, j, k) = map(int, input().split())
if i > j and abs(i - j) > k:
	print('+')
elif i < j and abs(i - j) > k:
	print('-')
elif i == j and k == 0:
	print('0')
else:
	print('?')


from sys import *
from math import *
(x, y, z) = map(int, stdin.readline().split())
m = x - y
f = 0
if m + z > 0 and m - z <= 0 or (m + z >= 0 and m - z < 0):
	f = 1
	print('?')
if f == 0:
	if m > 0:
		print('+')
	elif m < 0:
		print('-')
	else:
		print(0)


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

def sign(k):
	if k < 0:
		return -1
	if k > 0:
		return 1
	return 0
print('?' if sign(x - y + z) != sign(x - y - z) else '-0+'[sign(x - y + z) + 1])


def ain():
	return map(int, input().split())

def lin():
	return list(ain())

def plist(l):
	for x in l:
		print(x, end=' ')
	print()
(a, b, c) = ain()
if a > b + c:
	print('+')
elif b > a + c:
	print('-')
elif c == 0 and a == b:
	print('0')
else:
	print('?')


from sys import stdin

def main():
	(X, Y, Z) = map(int, input().split())
	n = sum([X, Y, Z]) // 2
	if not Z and X == Y:
		print(0)
	elif n < X and n < X + Z:
		print('+')
	elif n < Y and n < Y + Z:
		print('-')
	else:
		print('?')
input = lambda : stdin.readline()
main()


(x, y, z) = input().split()
x = int(x)
y = int(y)
z = int(z)
diff = x - y
if diff == 0:
	if z == 0:
		print('0')
	else:
		print('?')
elif diff > 0:
	if diff - z > 0:
		print('+')
	else:
		print('?')
elif abs(diff) - z > 0:
	print('-')
else:
	print('?')


v = input()
(x, y, z) = v.split()
x = int(x)
y = int(y)
z = int(z)
if x > y and z == 0 or z < x - y:
	print('+')
elif x < y and z == 0 or z < y - x:
	print('-')
elif x == y and z == 0:
	print('0')
elif z != 0:
	print('?')


def f(a):
	if a > 0:
		return '+'
	if a == 0:
		return '0'
	return '-'
(x, y, z) = list(map(int, input().split()))
if z == 0:
	print(f(x - y))
elif f(x - y - z) != f(x - y + z):
	print('?')
else:
	print(f(x - y - z))


import sys
import os
import math
import copy
from math import gcd
from bisect import bisect
from io import BytesIO, IOBase
from math import sqrt, floor, factorial, gcd, log, ceil
from collections import deque, Counter, defaultdict
from itertools import permutations, combinations
import itertools

def Int():
	return int(sys.stdin.readline())

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

def Lstr():
	return list(sys.stdin.readline().strip())

def Str():
	return sys.stdin.readline().strip()

def Mstr():
	return map(str, sys.stdin.readline().strip().split())

def List():
	return list(map(int, sys.stdin.readline().split()))

def Hash():
	return dict()

def Mod():
	return 1000000007

def Ncr(n, r, p):
	return fact[n] * (ifact[r] * ifact[n - r] % p) % p

def Most_frequent(list):
	return max(set(list), key=list.count)

def Mat2x2(n):
	return [List() for _ in range(n)]

def Lcm(x, y):
	return x * y // gcd(x, y)

def dtob(n):
	return bin(n).replace('0b', '')

def btod(n):
	return int(n, 2)

def common(l1, l2):
	return set(l1).intersection(l2)

def solution():
	(u, d, k) = Mint()
	if u > d + k:
		print('+')
	elif u + k < d:
		print('-')
	elif u == d and k == 0:
		print('0')
	else:
		print('?')
solution()


(x, y, z) = input().split()
rez = int(x) - int(y)
if rez == 0:
	print('0' if z == '0' else '?')
if rez > 0:
	print('+' if int(z) < rez else '?')
if rez < 0:
	print('-' if int(z) < abs(rez) else '?')


def result(x, y, z):
	if abs(x - y) > z or z == 0:
		if x > y:
			return '+'
		elif x < y:
			return '-'
		else:
			return '0'
	return '?'
(x, y, z) = [int(x) for x in input().split()]
print(result(x, y, z))


(x, y, z) = input().split(' ')
x = int(x)
y = int(y)
z = int(z)
if x > y and x - y > z:
	print('+')
elif x > y and x - y <= z:
	print('?')
elif x > y and z == 0:
	print('0')
elif y > x and y - x > z:
	print('-')
elif y > x and y - x <= z:
	print('?')
elif y > x and z == 0:
	print('0')
elif x == y and x == z and (z > 0):
	print('?')
elif x == y and z == 0:
	print('0')
elif x == y and x != z:
	print('?')


(x, y, z) = map(int, input().split())
a = abs(x - y)
if x > y:
	if z < a:
		print('+')
	else:
		print('?')
if x < y:
	if z < a:
		print('-')
	else:
		print('?')
if x == y:
	if z > 0:
		print('?')
	else:
		print('0')


s = list(map(int, input().split()))
a = s[0] - s[1]
ans = '+' if a > 0 else '-'
if a == 0:
	ans = '0'
if s[2] > 0:
	if abs(a) <= s[2]:
		ans = '?'
print(ans)


(x, y, z) = map(int, input().split())
plus = x - y
if x == y and z is 0:
	print('0')
	exit()
if plus > 0 and plus - z > 0:
	print('+')
elif plus < 0 and plus + z < 0:
	print('-')
else:
	print('?')


a = [int(i) for i in input().split()]
x = a[0]
y = a[1]
z = a[2]
if x > y + z:
	print('+')
elif y > x + z:
	print('-')
elif x == y and z == 0:
	print('0')
else:
	print('?')


from collections import Counter, deque, namedtuple, OrderedDict
from functools import reduce
from itertools import permutations, combinations
import math
(pluses, minuses, unknown) = [int(i) for i in input().strip().split(' ')]
if pluses - minuses - unknown > 0:
	print('+')
elif minuses - pluses - unknown > 0:
	print('-')
elif unknown == 0 and minuses == pluses:
	print('0')
else:
	print('?')


str = input()
(x, y, z) = str.split()
x = int(x)
y = int(y)
z = int(z)
if abs(x - y) > z and x > y:
	print('+\n')
elif abs(x - y) > z and x < y:
	print('-\n')
elif abs(x - y) == 0 and z == 0:
	print('0\n')
else:
	print('?\n')


def voting(ls):
	if ls[0] > ls[1] + ls[2]:
		return '+'
	elif ls[1] > ls[0] + ls[2]:
		return '-'
	elif ls[0] == ls[1] and ls[2] == 0:
		return '0'
	else:
		return '?'
ls = [int(i) for i in input().split()]
print(voting(ls))


def main():
	read = lambda : map(int, input().split())
	(x, y, z) = read()
	if abs(x - y) > z:
		print('+' if x > y else '-')
	elif x == y and z == 0:
		print(0)
	else:
		print('?')
main()


s = input().split()
for i in range(len(s)):
	s[i] = int(s[i])
x = s[0]
y = s[1]
z = s[2]
if x > y:
	if x > y + z:
		print('+')
	else:
		print('?')
if y > x:
	if y > x + z:
		print('-')
	else:
		print('?')
if x == y:
	if z > 0:
		print('?')
	if z == 0:
		print('0')


import sys

def get_array():
	return list(map(int, sys.stdin.readline().split()))

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

def input():
	return sys.stdin.readline().strip()

def main():
	(x, y, z) = get_ints()
	if x - y > z:
		print('+')
	elif x - y == 0 and z == 0:
		print(0)
	elif abs(x - y) > z:
		print('-')
	else:
		print('?')
main()


from sys import stdin, stdout
from itertools import combinations
from collections import defaultdict, OrderedDict
import math
import heapq

def listIn():
	return list(map(int, stdin.readline().strip().split()))

def stringListIn():
	return [x for x in stdin.readline().split()]

def intIn():
	return int(stdin.readline())

def stringIn():
	return stdin.readline().strip()
(x, y, z) = listIn()
if x < y:
	if x + z < y:
		print('-')
	else:
		print('?')
elif x == y:
	if z == 0:
		print('0')
	else:
		print('?')
elif y + z < x:
	print('+')
else:
	print('?')


a = input().split()
n = int(a[0])
m = int(a[1])
z = int(a[2])
x = n - m
if x > 0:
	if x - z <= 0:
		print('?')
	else:
		print('+')
if x == 0:
	if z != 0:
		print('?')
	else:
		print('0')
if x < 0:
	if x + z >= 0:
		print('?')
	else:
		print('-')


(plus, minus, unkw) = map(int, input().split())
delta = abs(plus - minus)
if delta == 0 and unkw == 0:
	print(0)
elif unkw >= delta or (delta == 0 and unkw > 0):
	print('?')
elif plus + unkw > minus + unkw:
	print('+')
else:
	print('-')


a = input().split()
x = int(a[0])
y = int(a[1])
z = int(a[2])
v = x + z
w = y + z
if x > y and x > w:
	print('+')
elif x < y and y > v:
	print('-')
elif x == y and z == 0:
	print('0')
elif x == w or y == v or x == y or (v > w) or (w > v):
	print('?')


(x, y, z) = input().split()
x = int(x)
y = int(y)
z = int(z)
if x > y:
	a = z + y
	if a < x:
		print('+')
	else:
		print('?')
if y > x:
	a = x + z
	if a < y:
		print('-')
	else:
		print('?')
if x == y:
	if z == 0:
		print(0)
	else:
		print('?')


l = list(map(int, input().split()))
if l[0] > l[1]:
	a = l[0] - l[1]
	if a > l[2]:
		print('+')
	else:
		print('?')
elif l[0] < l[1]:
	b = l[1] - l[0]
	if b > l[2]:
		print('-')
	else:
		print('?')
else:
	c = l[0] - l[1]
	if c == l[2]:
		print(0)
	else:
		print('?')


def main():
	t = input().split()
	(x, y, z) = (int(t[0]), int(t[1]), int(t[2]))
	check = x - y
	if check == 0:
		if z == 0:
			print('0')
		else:
			print('?')
	if check > 0:
		if check - z > 0:
			print('+')
		else:
			print('?')
	elif check < 0:
		if check + z < 0:
			print('-')
		else:
			print('?')
main()


def lala(i):
	if i == 0:
		return '0'
	elif i < 0:
		return '-'
	else:
		return '+'
(x, y, z) = map(int, input().split())
value = x - y
if lala(value - z) != lala(value + z):
	print('?')
elif value == 0:
	print(0)
elif value > 0:
	print('+')
else:
	print('-')


x = 0
y = 0
z = 0

def Input():
	global x, y, z
	(x, y, z) = list(map(int, input().split()))

def Output():
	if x > y:
		if x - y > z:
			print('+')
		else:
			print('?')
	elif x == y:
		if z == 0:
			print('0')
		else:
			print('?')
	elif y - x > z:
		print('-')
	else:
		print('?')
Input()
Output()


xyz = list(map(int, input().split()))
if xyz[0] > xyz[1]:
	if xyz[0] > xyz[1] + xyz[2]:
		print('+')
	else:
		print('?')
elif xyz[0] < xyz[1]:
	if xyz[1] > xyz[0] + xyz[2]:
		print('-')
	else:
		print('?')
elif xyz[0] == xyz[1]:
	if xyz[2] == 0:
		print(0)
	else:
		print('?')


import sys
input = sys.stdin.readline
from collections import defaultdict as dc
from collections import Counter
from bisect import bisect_right, bisect_left
import math
from heapq import heapify, heappop, heappush
(x, y, z) = map(int, input().split())
if z == 0 or abs(x - y) > z:
	if x > y:
		print('+')
	elif x < y:
		print('-')
	else:
		print(0)
else:
	print('?')


arr = list(map(int, input().split()))
diff = abs(arr[0] - arr[1])
if diff == 0:
	if arr[2] == 0:
		print('0')
	else:
		print('?')
elif arr[2] < diff:
	print('+' if arr[0] > arr[1] else '-')
else:
	print('?')


(a, b, c) = map(int, input().split())
z = a - b - c
zz = a - b + c
if z < 0:
	if zz < 0:
		print('-')
	else:
		print('?')
elif z > 0:
	if zz > 0:
		print('+')
elif zz > 0:
	print('?')
else:
	print('0')


import sys
(x, y, z) = list(map(int, sys.stdin.readline().strip().split()))
if x + z < y:
	print('-')
elif x > y + z:
	print('+')
elif x == y and z == 0:
	print('0')
else:
	print('?')


n = input().split()
n = list(map(int, n))
u = n[0]
d = n[1]
r = n[2]
if d > u:
	if d > u + r:
		print('-')
	else:
		print('?')
elif u > d:
	if u > d + r:
		print('+')
	else:
		print('?')
elif u == d:
	if r == 0:
		print(0)
	else:
		print('?')


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

def p():
	if x > y:
		print('+')
	elif x < y:
		print('-')
	else:
		print(0)
if z == 0 or abs(x - y) > z:
	p()
else:
	print('?')


def decideVotes(x, y, z):
	if x + z > y:
		if x > y + z:
			print('+')
		else:
			print('?')
	elif y + z > x:
		if y > x + z:
			print('-')
		else:
			print('?')
	elif x == y:
		if z == 0:
			print('0')
		else:
			print('?')

def main():
	ans = input()
	ans = ans.split()
	x = int(ans[0])
	y = int(ans[1])
	z = int(ans[2])
	decideVotes(x, y, z)
main()


import sys
sys.setrecursionlimit(10 ** 5 + 1)
inf = int(10 ** 20)
max_val = inf
min_val = -inf
RW = lambda : sys.stdin.readline().strip()
RI = lambda : int(RW())
RMI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
RWI = lambda : [x for x in sys.stdin.readline().strip().split()]
(a, b, c) = RMI()
if a == b and c == 0:
	print('0')
elif a > b + c:
	print('+')
elif b > a + c:
	print('-')
else:
	print('?')


(x, y, z) = map(int, input().split())
(mn, mx) = (x - y - z, x - y + z)
print('+' if mn > 0 else '0' if mn == mx == 0 else '-' if mx < 0 else '?')


XYZ = input()
XYZ = XYZ.split()
counter = 0
for number in XYZ:
	XYZ[counter] = int(number)
	counter = counter + 1
variable = XYZ[0] - XYZ[1]
if variable + XYZ[2] < 0:
	print('-')
elif variable - XYZ[2] > 0:
	print('+')
elif XYZ[0] == XYZ[1] and XYZ[2] == 0:
	print('0')
else:
	print('?')


from math import *
from collections import *
import sys
sys.setrecursionlimit(10 ** 9)
(x, y, z) = map(int, input().split())
if z == 0:
	if x == y:
		print('0')
	elif x > y:
		print('+')
	else:
		print('-')
elif x > y + z:
	print('+')
elif y > x + z:
	print('-')
else:
	print('?')


class Nauuo:

	def __init__(self, x, y, z):
		self.x = x
		self.y = y
		self.z = z

	def Iden(self):
		x = self.x
		y = self.y
		z = self.z
		q = abs(x - y)
		if z == 0:
			if x > y:
				return '+'
			elif x < y:
				return '-'
			else:
				return '0'
		elif q <= z:
			return '?'
		elif x > y:
			return '+'
		else:
			return '-'
temp = map(int, input().split(' '))
(x, y, z) = temp
t = Nauuo(x, y, z)
print(t.Iden())


Q = [int(x) for x in input().split()]
upVote = Q[0]
downVote = Q[1]
unkVote = Q[2]
prob = [False, False, False]
ans = ['+', '-', '0']
if upVote + unkVote > downVote:
	prob[0] = True
if downVote + unkVote > upVote:
	prob[1] = True
if upVote + unkVote == downVote or downVote + unkVote == upVote:
	prob[2] = True
count = 0
for i in prob:
	if i == True:
		count += 1
if count > 1:
	print('?')
else:
	for i in range(3):
		if prob[i] == True:
			print(ans[i])


votes = input()
votes = votes.split()
upvotes = int(votes[0])
downvotes = int(votes[1])
unknown = int(votes[2])
possible_high = unknown + upvotes
possible_low = unknown + downvotes
if unknown == 0 and upvotes == downvotes:
	print('0')
elif downvotes >= upvotes and possible_high >= downvotes or (upvotes >= downvotes and possible_low >= upvotes):
	print('?')
elif upvotes > downvotes:
	print('+')
elif downvotes > upvotes:
	print('-')


l = list(input().split())
upvote = int(l[0])
downvote = int(l[1])
z = int(l[2])
if abs(upvote - downvote) <= z and z != 0:
	print('?')
elif upvote - downvote == 0 and z == 0:
	print('0')
elif upvote > downvote:
	print('+')
else:
	print('-')


(i, j, k) = input().split()
i = int(i)
j = int(j)
k = int(k)
y = 0
y += i - j
t = y + k
p = y - k
if t < 0 and p < 0:
	print('-')
elif t > 0 and p > 0:
	print('+')
elif t == 0 and p == 0:
	print('0')
else:
	print('?')


(x, y, z) = map(int, input().split())
max1 = max([x, y])
max2 = x + y - max1
if x == y and z == 0:
	print(0)
elif x == y and z != 0:
	print('?')
elif max1 - max2 - z <= 0:
	print('?')
elif max1 == x:
	print('+')
elif max1 == y:
	print('-')


user_input = input()
votes = user_input.split()
up_votes = int(votes[0])
down_votes = int(votes[1])
unknown_votes = int(votes[2])
if up_votes + unknown_votes < down_votes:
	print('-')
elif down_votes + unknown_votes < up_votes:
	print('+')
elif unknown_votes == 0:
	print('0')
else:
	print('?')


from math import *
from itertools import *
(x, y, z) = map(int, input().split(' '))
if y > x + z:
	print('-')
elif x > y + z:
	print('+')
elif x == y and z == 0:
	print(0)
else:
	print('?')


from sys import stdin, stdout
l = list(map(int, stdin.readline().split()))
(x, y, z) = (l[0], l[1], l[2])
if x > y:
	if x - y - z <= 0:
		stdout.write('?')
	else:
		stdout.write('+')
elif x < y:
	if x - y + z >= 0:
		stdout.write('?')
	else:
		stdout.write('-')
elif z == 0:
	stdout.write('0')
else:
	stdout.write('?')


R = lambda : map(int, input().split())
(x, y, z) = R()
if x == y and z == 0:
	print('0')
	exit()
if x > y + z:
	print('+')
elif y > x + z:
	print('-')
else:
	print('?')


l = list(map(int, input().split(' ')))
(a, b, c) = l
if c == 0:
	if a > b:
		print('+')
	elif a < b:
		print('-')
	else:
		print('0')
else:
	k = a - b
	if abs(k) <= c:
		print('?')
	elif a > b:
		print('+')
	else:
		print('-')


(x, y, z) = map(int, input().strip().split())
curr_votes = x - y
s1 = curr_votes + z
s2 = curr_votes - z
if s1 > 0 and s2 > 0:
	print('+')
elif s1 < 0 and s2 < 0:
	print('-')
elif s1 == 0 and s2 == 0:
	print('0')
else:
	print('?')


def sgn(a):
	if a > 0:
		return 0
	elif a == 0:
		return 1
	else:
		return 2
(x, y, z) = map(int, input().split())
M = sgn(x - y + z)
m = sgn(x - y - z)
if M != m:
	print('?')
else:
	print(['+', '0', '-'][M])


(x, y, z) = map(int, input().split())
ans1 = ''
ans2 = ''
if x + z > y:
	ans1 = '+'
if y + z < x:
	ans2 = '+'
if x + z == y:
	ans1 = '0'
if y + z == x:
	ans2 = '0'
if x + z < y:
	ans1 = '-'
if y + z > x:
	ans2 = '-'
if ans1 == ans2:
	print(ans1)
else:
	print('?')


(x, y, z) = list(map(int, input().split()))
if x > y:
	print('+' if x > y + z else '?')
	exit()
if y > x:
	print('-' if y > x + z else '?')
	exit()
print('0' if z == 0 else '?')


(n, a, b) = map(int, input().split())
if n - b > a:
	print('+')
elif a > n + b:
	print('-')
elif n == a and b == 0:
	print('0')
else:
	print('?')


(x1, y1, z1) = input().split()
x = int(x1)
y = int(y1)
z = int(z1)
if z == 0:
	if x < y:
		print('-')
	elif x > y:
		print('+')
	else:
		print('0')
elif x < y:
	x = x + z
	if x < y:
		print('-')
	else:
		print('?')
elif x > y:
	y = y + z
	if x > y:
		print('+')
	else:
		print('?')
else:
	print('?')


(u, d, un) = map(int, input().split())
if u == d and un == 0:
	print(0)
elif u + un < d:
	print('-')
elif d + un < u:
	print('+')
else:
	print('?')


from sys import stdin, stdout
ar = stdin.readline().split()
a = int(ar[0])
b = int(ar[1])
c = int(ar[2])
res = a - b
if a - b > c:
	print('+')
elif b - a > c:
	print('-')
elif c == 0:
	print('0')
else:
	print('?')


import math
(x, y, z) = map(int, input().split())
xx = x - y
if abs(xx) > z or z == 0:
	if xx < 0:
		print('-')
	elif xx == 0:
		print(0)
	else:
		print('+')
else:
	print('?')


def res(x, y, z):
	if z == 0:
		if x > y:
			return '+'
		elif x < y:
			return '-'
		else:
			return 0
	elif y + z < x:
		return '+'
	elif x + z < y:
		return '-'
	else:
		return '?'
(x, y, z) = [int(i) for i in input().split()]
print(res(x, y, z))


(up, down, unk) = [int(x) for x in input().split()]
all_unk_up = up + unk
all_unk_down = down + unk
if up > all_unk_down:
	print('+')
elif down > all_unk_up:
	print('-')
elif up == down and unk == 0:
	print('0')
else:
	print('?')


str = input()
(x, y, z) = str.split(' ')
x = int(x)
y = int(y)
z = int(z)
ans = '?'
if x == y and z == 0:
	ans = '0'
if x > y + z:
	ans = '+'
if y > x + z:
	ans = '-'
print(ans)


(p, m, z) = map(int, input().split())
rr = p - m
if rr + z >= 0 and rr - z < 0:
	print('?')
elif rr + z > 0 and rr - z <= 0:
	print('?')
else:
	if rr > 0:
		print('+')
	if rr == 0:
		print('0')
	if rr < 0:
		print('-')


a = list(map(int, input().split()))
k = a[0] - a[1]
if k == 0 and a[2] == 0:
	print(0)
elif k >= 0 and k > a[2]:
	print('+')
elif k >= 0 and k <= a[2]:
	print('?')
elif k < 0 and abs(k) > a[2]:
	print('-')
elif k < 0 and abs(k) <= a[2]:
	print('?')


from sys import stdin

def input():
	return stdin.readline()
(x, y, z) = map(int, input().split())
if z != 0 and min(x, y) + z >= max(x, y):
	print('?')
elif x == y:
	print(0)
elif x > y:
	print('+')
else:
	print('-')


import sys
from collections import Counter

def input():
	return sys.stdin.readline().strip()

def dinput():
	return int(input())

def tinput():
	return input().split()

def rinput():
	return map(int, tinput())

def main():
	(a, s, d) = rinput()
	q = a - s
	if q > 0 and q - d <= 0 or (q == 0 and d != 0) or (q < 0 and q + d >= 0):
		print('?')
	elif q > 0:
		print('+')
	elif q == 0:
		print(0)
	else:
		print('-')
main()


number = [int(x) for x in input().split()]
x = number[0]
y = number[1]
z = number[2]
if x > y + z:
	print('+')
elif y > x + z:
	print('-')
elif z == 0:
	print('0')
else:
	print('?')


entrada = list(map(int, input().split()))
diff = entrada[0] - entrada[1]
z = entrada[2]
if diff > 0 and diff > z:
	print('+')
elif diff < 0 and abs(diff) > z:
	print('-')
elif diff == 0 and z == 0:
	print('0')
else:
	print('?')


(x, y, z) = map(int, input().split())
p = x - y
if abs(p) > z and p > 0:
	print('+')
elif abs(p) > z and p < 0:
	print('-')
elif abs(p) == z and z == 0:
	print('0')
elif abs(p) <= z and z != 0:
	print('?')


xyz = [int(k) for k in input().split()]
total = xyz[0] - xyz[1]
if xyz[2] == 0 or abs(total) > xyz[2]:
	if total > 0:
		print('+')
	elif total == 0:
		print('0')
	else:
		print('-')
else:
	print('?')


from sys import stdin, setrecursionlimit
import heapq
(x, y, z) = list(map(int, stdin.readline().split()))
diff = abs(x - y)
if z == 0 or diff > z:
	if x > y:
		print('+')
	elif x < y:
		print('-')
	else:
		print('0')
else:
	print('?')


def s():
	(x, y, z) = [int(x) for x in input().split(' ')]
	if x - y > z:
		print('+')
	elif y - x > z:
		print('-')
	elif z > 0:
		print('?')
	else:
		print('0')
s()


def main():
	(x, y, z) = map(int, input().split())
	if x + z < y:
		print('-')
		return
	if y + z < x:
		print('+')
		return
	if x == y and z == 0:
		print('0')
		return
	print('?')
main()


s = [int(i) for i in input().split(' ')]
x = s[0]
y = s[1]
z = s[2]
t = x - y
if t > 0:
	if t + z < 0 or t + z == 0 or t - z < 0 or (t - z == 0):
		print('?')
	else:
		print('+')
elif t < 0:
	if t + z > 0 or t + z == 0 or t - z > 0 or (t - z == 0):
		print('?')
	else:
		print('-')
elif t + z > 0 or t + z < 0 or t - z > 0 or (t - z < 0):
	print('?')
else:
	print('0')


(x, y, z) = map(int, input().split())
(p, n) = (x - y, y - x)
if p > 0 and n < 0:
	a = p
else:
	a = n
if z > a:
	print('?')
elif z < a and p > n:
	print('+')
elif z < a and n > p:
	print('-')
elif z == 0 and a == 0:
	print('0')
else:
	print('?')


def main():
	[x, y, z] = list(map(int, input().split()))
	plus = 0
	minus = 0
	zero = 0
	uncertain = 0
	if x + z > y and x > y + z:
		plus = 1
	elif x + z < y and x < y + z:
		minus = 1
	elif x + z == y and x == y + z:
		zero = 1
	else:
		uncertain = 1
	if zero == 1:
		print('0')
	elif minus == 1:
		print('-')
	elif plus == 1:
		print('+')
	elif uncertain == 1:
		print('?')
main()


(p, n, u) = map(int, input().split())
s = '?'
ip = p - n + u
do = p - n - u
if ip == 0 and do == 0:
	s = '0'
elif ip > 0 and do > 0:
	s = '+'
elif ip < 0 and do < 0:
	s = '-'
else:
	s = '?'
print(s)


from sys import maxsize, stdout, stdin
mod = int(1000000000.0 + 7)

def I():
	return int(stdin.readline())

def lint():
	return [int(x) for x in stdin.readline().split()]

def S():
	return input().strip()

def grid(r, c):
	return [lint() for i in range(r)]
(x, y, z) = map(int, S().split())
if z == 0:
	if x > y:
		print('+')
	elif y > x:
		print('-')
	else:
		print(0)
elif x > y + z:
	print('+')
elif y > x + z:
	print('-')
else:
	print('?')


t = 1
while t:
	(x, y, z) = map(int, input().split())
	if z == 0:
		if x - y > 0:
			print('+')
		elif x - y < 0:
			print('-')
		else:
			print(0)
	elif x - y - z > 0:
		print('+')
	elif x - y + z < 0:
		print('-')
	else:
		print('?')
	t -= 1


v = list(map(int, input().split()))
x = v[0]
y = v[1]
z = v[2]
if z == 0:
	if x > y:
		print('+')
	elif x < y:
		print('-')
	else:
		print('0')
elif x + z < y:
	print('-')
elif z + y < x:
	print('+')
else:
	print('?')


ll = ['+', '-', '0', '?']
t = list(map(int, input().split()))
ans = ''
x = t[0]
y = t[1]
z = t[2]
if z == 0:
	if x - y > 0:
		print(ll[0])
	elif x - y < 0:
		print(ll[1])
	elif x == y:
		print(ll[2])
elif x == 0 and y == 0:
	print(ll[3])
elif x - y > 0:
	if x - y < z:
		print('?')
	elif x - y > z:
		print('+')
	elif x - y == z:
		print('?')
elif x - y == 0:
	print('?')
elif x - y < 0:
	if y - x < z:
		print('?')
	elif y - x > z:
		print('-')
	elif y - x == z:
		print('?')


def solution(x, y, z):
	s = x - y
	if z == 0:
		if x > y:
			return '+'
		elif x < y:
			return '-'
		else:
			return '0'
	elif z != 0:
		if s < 0:
			if z >= -s:
				return '?'
			z = z + s
			if z < -s:
				return '-'
		if z >= s:
			return '?'
		elif z < s:
			return '+'

def main():
	(x, y, z) = map(int, input().split())
	result = solution(x, y, z)
	print(result)
	return result
main()


(x, y, z) = map(int, input().split())
s = x - y
u = s + z
v = s - z
if u > 0 and v > 0:
	print('+')
elif u < 0 and v < 0:
	print('-')
elif u == 0 and v == 0 and (z == 0):
	print(0)
else:
	print('?')


(x, y, z) = [int(x) for x in input().split()]
c = z + abs(x - y) and '?'
print(f'{c}+-'[(x > y + z) + 2 * (y > x + z)])


from math import *
from collections import *
from itertools import *
from functools import *
from bisect import *
from heapq import *
from operator import *
from sys import *
setrecursionlimit(100000000)
(a, b, c) = map(int, input().split())
x = abs(a - b)
if a == b and c == 0:
	print(0)
	exit()
if x <= c:
	print('?')
elif a > b:
	print('+')
else:
	print('-')


(a, b, z) = [int(x) for x in input().split(' ')]
c = a - b
if c < 0 and c + z >= 0 or (c > 0 and c - z <= 0) or (c == 0 and c - z != 0) or (c == 0 and c + z != 0):
	print('?')
elif c == 0:
	print(0)
elif c > 0:
	print('+')
else:
	print('-')


n = list(map(int, input().split()))
a = n[0] - n[1]
a1 = a + n[2]
a2 = a - n[2]
if a1 > 0 and a2 > 0:
	print('+')
elif a1 < 0 and a2 < 0:
	print('-')
elif a1 == 0 and a2 == 0:
	print('0')
elif a1 != a2:
	print('?')


def __starting_point():
	(x, y, z) = list(map(int, input().split()))
	if x > y:
		up = x - y
		if z < up:
			print('+')
		else:
			print('?')
	elif y > x:
		down = y - x
		if z < down:
			print('-')
		else:
			print('?')
	elif z == 0:
		print('0')
	else:
		print('?')
__starting_point()


inputs = input()
line = inputs.split()
upvote = int(line[0])
downvote = int(line[1])
unknown = int(line[2])
if upvote > downvote + unknown:
	print('+')
elif downvote > upvote + unknown:
	print('-')
elif downvote == upvote:
	if unknown > 0:
		print('?')
	else:
		print('0')
else:
	print('?')


[x, y, z] = [int(i) for i in input().split()]
b = x - y
if z == 0:
	if b < 0:
		print('-')
	elif b == 0:
		print('0')
	else:
		print('+')
elif b + z < 0:
	print('-')
elif b - z > 0:
	print('+')
else:
	print('?')


def main():
	buf = input()
	buflist = buf.split()
	x = int(buflist[0])
	y = int(buflist[1])
	z = int(buflist[2])
	minimum = x - y - z
	maximum = x - y + z
	if minimum > 0 and maximum > 0:
		print('+')
	elif minimum < 0 and maximum < 0:
		print('-')
	elif minimum == 0 and maximum == 0:
		print('0')
	else:
		print('?')
main()


a = list(map(int, input().split()))
if a[0] > a[1]:
	t = a[1] + a[2]
	if t < a[0]:
		print('+')
	else:
		print('?')
elif a[0] < a[1]:
	t = a[0] + a[2]
	if t < a[1]:
		print('-')
	else:
		print('?')
elif a[2] == 0:
	print(0)
else:
	print('?')


import math
q = 1
for _ in range(q):
	(x, y, z) = map(int, input().split())
	if y - x > z:
		print('-')
	elif x - y > z:
		print('+')
	elif x - y == z and z == 0:
		print(0)
	else:
		print('?')


from sys import *
A = stdin.readline().split()
for i in A:
	(x, y, z) = (int(A[0]), int(A[1]), int(A[2]))
if x == 0 and y == 0 and (z == 0):
	stdout.write(str('0') + '\n')
elif x == y and z == 0:
	stdout.write(str('0') + '\n')
elif x > y + z:
	stdout.write(str('+') + '\n')
elif y > x + z:
	stdout.write(str('-') + '\n')
else:
	stdout.write(str('?') + '\n')


(x, y, z) = map(int, input().split())
s = x - y
ma = s + z
mi = s - z
if ma > 0 and mi > 0:
	print('+')
elif ma < 0 and mi < 0:
	print('-')
elif mi == 0 and ma == 0:
	print('0')
else:
	print('?')


def nauuoVotes(x, y, z):
	d = x - y
	if z == 0:
		if d > 0:
			print('+')
		elif d < 0:
			print('-')
		else:
			print('0')
	elif abs(d) > z:
		if d > 0:
			print('+')
		elif d < 0:
			print('-')
	else:
		print('?')
(x, y, z) = map(int, input().rstrip().split())
nauuoVotes(x, y, z)


def CalResult(votes):
	(upvotes, downvotes, uncertain) = (int(votes[0]), int(votes[1]), int(votes[2]))
	partial_result = None
	complete_result = None
	if upvotes >= downvotes:
		if upvotes - downvotes > uncertain:
			partial_result = '+'
		elif upvotes - downvotes < uncertain:
			partial_result = '?'
		elif upvotes - downvotes == 0 and uncertain == 0:
			partial_result = '0'
		elif upvotes - downvotes == uncertain:
			partial_result = '?'
	elif downvotes - upvotes > uncertain:
		partial_result = '-'
	elif downvotes - upvotes < uncertain:
		partial_result = '?'
	elif -upvotes + downvotes == uncertain:
		partial_result = '?'
	complete_result = partial_result
	return complete_result
people = []
x = input()
people = x.split(' ')
result = CalResult(people)
print(result)


import sys
input = sys.stdin.readline

class Problem:

	def __init__(self):
		pass

	def solve(self):
		print(self._solve())

	def _solve(self):
		(x, y, z) = [int(item) for item in input().split()]
		if x - y + z < 0:
			return '-'
		elif x - y - z > 0:
			return '+'
		elif x == y and z == 0:
			return '0'
		return '?'

def main():
	problem = Problem()
	problem.solve()
main()


def winner():
	(a, b, c) = [int(x) for x in input().split()]
	if a > b:
		if a > b + c:
			return '+'
		else:
			return '?'
	elif b > a:
		if b > a + c:
			return '-'
		else:
			return '?'
	elif b == a and c == 0:
		return '0'
	else:
		return '?'
print(winner())


import atexit
import io
import sys
_I_B = sys.stdin.read().splitlines()
input = iter(_I_B).__next__
_O_B = io.StringIO()
sys.stdout = _O_B

@atexit.register
def write():
	sys.__stdout__.write(_O_B.getvalue())

def main():
	(x, y, z) = map(int, input().split())
	if x - y + z > 0 and x - y - z > 0:
		print('+')
	elif x - y + z < 0 and x - y - z < 0:
		print('-')
	elif x - y + z == 0 and x - y - z == 0:
		print(0)
	else:
		print('?')
main()


n = list(map(int, input().split()))
if n[0] > n[1] and n[2] < abs(n[0] - n[1]):
	print('+')
if n[1] > n[0] and n[2] < abs(n[0] - n[1]):
	print('-')
if n[0] == n[1] and n[2] == 0:
	print('0')
elif n[2] >= abs(n[0] - n[1]):
	print('?')


(x, y, z) = map(int, input().split())
first = x - y - z
second = x - y + z
if first == second == 0:
	print(0)
elif (first == 0 or second == 0) and first + second != 0:
	print('?')
elif first * second > 0:
	if second < 0:
		print('-')
	else:
		print('+')
else:
	print('?')


a = [int(i) for i in input().split()]
x = a[0]
y = a[1]
z = a[2]
out = '?'
if x > y + z:
	out = '+'
if y > x + z:
	out = '-'
if x - y == 0 and z == 0:
	out = '0'
print(out)


(a, b, c) = list(map(int, input().split()))
d = a + b + c
if c == 0:
	if a == b:
		print('0')
	elif a > b:
		print('+')
	else:
		print('-')
elif a * 2 > d:
	print('+')
elif b * 2 > d:
	print('-')
else:
	print('?')
exit(0)


import math
from collections import Counter
(a, b, c) = map(int, input().split())
if c >= abs(a - b) and c != 0:
	print('?')
elif a > b:
	print('+')
elif b > a:
	print('-')
else:
	print('0')


(x, y, z) = [int(x) for x in input().split(' ')]
canWin = False
canLose = False
if x == y:
	if z:
		print('?')
	else:
		print('0')
elif x > y:
	if x > y + z:
		print('+')
	else:
		print('?')
elif x + z < y:
	print('-')
else:
	print('?')


inp = input()
inp = inp.split(' ')
up_votes = int(inp[0])
down_votes = int(inp[1])
other_votes = int(inp[2])
answer = up_votes - down_votes
if answer > 0:
	if answer - other_votes <= 0:
		print('?')
	else:
		print('+')
elif answer < 0:
	if answer + other_votes >= 0:
		print('?')
	else:
		print('-')
elif other_votes > 0:
	print('?')
else:
	print('0')


m = list(map(int, input().split()))[:3]
if m[0] > m[1]:
	if m[1] + m[2] >= m[0]:
		print('?')
	else:
		print('+')
elif m[1] > m[0]:
	if m[0] + m[2] >= m[1]:
		print('?')
	else:
		print('-')
elif m[2] > 0:
	print('?')
else:
	print('0')


(x, y, z) = map(int, input().split())
x = x
y = -y
r = x + y
r1 = x + y + z
r2 = x + y - z
if r > 0 and (r1 > 0 and r2 > 0):
	print('+')
elif r < 0 and (r1 < 0 and r2 < 0):
	print('-')
elif r == 0 and r1 == r2:
	print('0')
else:
	print('?')


def solve():
	(x, y, z) = map(int, input().split())
	if x == y and z == 0:
		print('0')
		return
	if abs(x - y) > z:
		if x > y:
			print('+')
		else:
			print('-')
	else:
		print('?')
solve()


(x, y, z) = list(map(int, input().split(' ')))
if x == y and z == 0:
	print(0)
if x == y and z != 0:
	print('?')
if x > y and z >= x - y:
	print('?')
if x > y and z < x - y:
	print('+')
if x < y and z >= y - x:
	print('?')
if x < y and z < y - x:
	print('-')


from sys import stdin, setrecursionlimit
setrecursionlimit(10 ** 7)

def iin():
	return int(stdin.readline())

def lin():
	return list(map(int, stdin.readline().split()))

def main():
	(x, y, z) = lin()
	sol = ['+', '-', '0', '?']
	ans = 3
	if z == 0 and x == y:
		ans = 2
	else:
		ch = 0
		if x + z < y:
			ch += 1
			ans = 1
		if x > y + z:
			ch += 1
			ans = 0
		if ch > 1:
			ans = 3
	print(sol[ans])
main()


from math import *
from cmath import *
from itertools import *
from decimal import *
from fractions import *
from sys import *
for _ in range(1):
	(a, b, c) = map(int, input().split())
	if a - b > c:
		print('+')
	elif b - a > c:
		print('-')
	elif c == 0 and a == b:
		print(0)
	else:
		print('?')


class cinn:

	def __init__(self):
		self.x = []

	def cin(self, t=int):
		if len(self.x) == 0:
			a = input()
			self.x = a.split()
			self.x.reverse()
		return self.get(t)

	def get(self, t):
		return t(self.x.pop())

	def clist(self, n, t=int):
		l = [0] * n
		for i in range(n):
			l[i] = self.cin(t)
		return l

	def clist2(self, n, t1=int, t2=int, t3=int, tn=2):
		l = [0] * n
		for i in range(n):
			if tn == 2:
				a1 = self.cin(t1)
				a2 = self.cin(t2)
				l[i] = (a1, a2)
			elif tn == 3:
				a1 = self.cin(t1)
				a2 = self.cin(t2)
				a3 = self.cin(t3)
				l[i] = (a1, a2, a3)
		return l

	def clist3(self, n, t1=int, t2=int, t3=int):
		return self.clist2(self, n, t1, t2, t3, 3)

	def cout(self, i, ans=''):
		if ans == '':
			print('Case #' + str(i + 1) + ':', end=' ')
		else:
			print('Case #' + str(i + 1) + ':', ans)

	def printf(self, thing):
		print(thing, end='')

	def countlist(self, l, s=0, e=None):
		if e == None:
			e = len(l)
		dic = {}
		for el in range(s, e):
			if l[el] not in dic:
				dic[l[el]] = 1
			else:
				dic[l[el]] += 1
		return dic

	def talk(self, x):
		print(x, flush=True)

	def dp1(self, k):
		L = [-1] * k
		return L

	def dp2(self, k, kk):
		L = [-1] * k
		for i in range(k):
			L[i] = [-1] * kk
		return L
c = cinn()
x = c.cin()
y = c.cin()
z = c.cin()
if x > y + z:
	print('+')
elif y > x + z:
	print('-')
elif x == y and z == 0:
	print('0')
else:
	print('?')


def answer():
	a = [int(x) for x in input().split()]
	dec = a[0] - a[1]
	if dec == 0 and a[2] == 0:
		print(0)
	elif abs(dec) <= a[2]:
		print('?')
	elif dec > 0:
		print('+')
	else:
		print('-')
answer()


from collections import defaultdict as dd
import math
import sys
input = sys.stdin.readline

def nn():
	return int(input())

def li():
	return list(input())

def mi():
	return map(int, input().split())

def lm():
	return list(map(int, input().split()))
(u, d, k) = mi()
if u > d + k:
	print('+')
elif d > k + u:
	print('-')
elif k == 0 and d == u:
	print(0)
else:
	print('?')


(up_vote, down_vote, uncertain) = map(int, input().split())
if abs(up_vote - down_vote) <= uncertain and uncertain != 0:
	print('?')
elif up_vote > down_vote:
	print('+')
elif down_vote > up_vote:
	print('-')
else:
	print(0)


(x, y, z) = map(int, input().split())
c = z + abs(x - y) and '?'
print(f'{c}+-'[(x > y + z) + 2 * (y > x + z)])


(x, y, z) = map(int, input().split())
ans = {'+': x > y + z, '-': y > x + z, '0': x == y and z == 0, '?': True}
for (i, j) in ans.items():
	if j:
		print(i)
		exit()


(u, d, c) = map(int, input().split())
(x, y) = (u + c, d + c)
if u > d and u > y:
	print('+')
elif d > u and d > x:
	print('-')
elif u == d and c == 0:
	print('0')
else:
	print('?')


import math
import sys

def left(d):
	(h, *b) = d
	return b + [h]
(x, y, z) = map(int, input().split())
t = x - y
s = ''
if z >= abs(t) and z != 0:
	print('?')
elif t + z < 0:
	print('-')
elif t - z > 0:
	print('+')
elif t - z == t + z == 0:
	print(0)


(x, y, z) = input().split()
vote = int(x) - int(y)
fin = []
fin.append(vote + int(z))
fin.append(vote - int(z))
if fin[0] > 0 and fin[1] > 0:
	print('+')
elif fin[0] == 0 and fin[1] == 0:
	print('0')
elif fin[0] < 0 and fin[1] < 0:
	print('-')
else:
	print('?')


import sys

def main():
	(x, y, z) = map(int, sys.stdin.read().strip().split())
	if x - z > y:
		return '+'
	if y - z > x:
		return '-'
	if not z and x == y:
		return 0
	return '?'
print(main())


(f, g, h) = input('').split()
a = int(f)
b = int(g)
c = int(h)
if a + c > b and a > b + c:
	print('+')
elif b + c > a and b > c + a:
	print('-')
elif a + c == b and b + c == a:
	print('0')
elif a + c > b and b + c >= a or (a + c >= b and b + c > a):
	print('?')


lst = [int(i) for i in input().split()]
p = lst[0]
m = lst[1]
z = lst[2]
if p > m + z:
	print('+')
elif m > p + z:
	print('-')
elif m == p and z == 0:
	print(0)
else:
	print('?')


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

def result(a, b):
	if a == b:
		return '0'
	elif a > b:
		return '+'
	else:
		return '-'
if z == 0:
	print(result(x, y))
elif result(x + z, y) == result(x, y + z):
	print(result(x + z, y))
else:
	print('?')


import math
from collections import deque, defaultdict
from sys import stdin, stdout
input = stdin.readline
listin = lambda : list(map(int, input().split()))
mapin = lambda : map(int, input().split())
(x, y, z) = mapin()
if x == y and z == 0:
	print(0)
elif abs(x - y) > z:
	if x - y > 0:
		print('+')
	else:
		print('-')
else:
	print('?')


(x, y, z) = map(int, input().split())
(p, m, ze) = (False, False, False)
if x + z > y:
	p = True
if y + z > x:
	m = True
if abs(x - y) <= z and (z - abs(x - y)) % 2 == 0:
	ze = True
if p + m + ze >= 2:
	print('?')
elif p:
	print('+')
elif m:
	print('-')
else:
	print('0')


(n, m, k) = map(int, input().split())
if n > m and n > k + m:
	print('+')
elif n < m and n + k < m:
	print('-')
elif n == m and k == 0:
	print('0')
else:
	print('?')


def votes(x, y, z):
	if x > y + z:
		return '+'
	elif y > x + z:
		return '-'
	elif y == x and z == 0:
		return 0
	return '?'
arr = list(map(int, input().split()))
print(votes(arr[0], arr[1], arr[2]))


def input_int():
	return int(input())
(true_votes, false_votes, draw_votes) = map(int, input().split())
if true_votes > false_votes + draw_votes:
	print('+')
elif false_votes > true_votes + draw_votes:
	print('-')
elif false_votes == true_votes and draw_votes == 0:
	print('0')
else:
	print('?')


def Input(x, y, z):
	(x, y, z) = list(map(int, input().split()))
	return (x, y, z)

def Processing(x, y, z):
	if x == y:
		if z == 0:
			print(0)
		else:
			print('?')
	elif x > y:
		if x <= y + z:
			print('?')
		else:
			print('+')
	elif y <= x + z:
		print('?')
	else:
		print('-')
x = 0
y = 0
z = 0
(x, y, z) = Input(x, y, z)
Processing(x, y, z)


t = input()
(x, y, z) = t.split()
dif = abs(int(x) - int(y))
if dif == 0 and int(z) == 0:
	print(0)
elif dif <= int(z):
	print('?')
elif int(x) > int(y):
	print('+')
else:
	print('-')


b = [int(q) for q in input().strip().split()]
if b[0] > b[1] + b[2]:
	print('+')
elif b[1] > b[0] + b[2]:
	print('-')
elif b[0] == b[1] and b[2] == 0:
	print(0)
else:
	print('?')


def main(x, y, z):
	if z == 0:
		if x > y:
			return '+'
		elif x < y:
			return '-'
		else:
			return '0'
	elif x > y:
		if x > y + z:
			return '+'
		else:
			return '?'
	elif y > x:
		if y > x + z:
			return '-'
		else:
			return '?'
	else:
		return '?'
c = list(map(int, input().rstrip().split()))
x = c[0]
y = c[1]
z = c[2]
res = main(x, y, z)
print(res)


(a, b, c) = [int(i) for i in input().split(' ')]
if a > b + c:
	print('+')
elif b > a + c:
	print('-')
elif a == b and c == 0:
	print('0')
else:
	print('?')


x = input()
y = x.split()
z = [int(d) for d in y]
if z[0] == z[1] and z[2] != 0:
	print('?')
elif z[0] == z[1] and z[2] == 0:
	print('0')
elif z[0] > z[1] and z[2] < z[0] - z[1]:
	print('+')
elif z[0] > z[1] and z[2] >= z[0] - z[1]:
	print('?')
elif z[0] < z[1] and z[2] >= z[1] - z[0]:
	print('?')
elif z[0] < z[1] and z[2] < z[1] - z[0]:
	print('-')


(up, down, unknown) = input().split()
up = int(up)
down = int(down)
unknown = int(unknown)
if up - down - unknown > 0:
	print('+')
elif down - up - unknown > 0:
	print('-')
elif unknown == 0 and up == down:
	print('0')
else:
	print('?')


(a, b, c) = list(map(int, input().split()))
if c == 0:
	if a > b:
		print('+')
	if a < b:
		print('-')
	if a == b:
		print(0)
else:
	Dif = a - b
	if Dif >= 0:
		if Dif > c:
			print('+')
		else:
			print('?')
	elif abs(Dif) > c:
		print('-')
	else:
		print('?')


def fun(u, d, un):
	s = '?'
	if u == d:
		s = '0'
		r = 0
	elif u > d:
		r = u - d
		s = '+'
	else:
		r = d - u
		s = '-'
	if un:
		r = r - un
		if r <= 0:
			s = '?'
	return s
x = list(map(int, input().split()))
print(fun(x[0], x[1], x[2]))


(x, y, z) = map(int, input().split())
a = x - y - z
b = x - y + z
if a * b > 0:
	print('+' if a > 0 else '-')
elif a or b:
	print('?')
else:
	print(0)


import sys
IS_LOCAL = False

def readInput():
	return tuple(map(int, input().split()))

def writeResult(r):
	print(r)

def main():
	(x, y, z) = (3, 7, 0) if IS_LOCAL else readInput()
	if x > y + z and y < x + z:
		writeResult('+')
	elif y > x + z and x < y + z:
		writeResult('-')
	elif z == 0 and x == y:
		writeResult('0')
	else:
		writeResult('?')
if len(sys.argv) > 1 and sys.argv[1] == 'True':
	IS_LOCAL = True
main()


RI = lambda : [int(x) for x in input().strip().split()]
rw = lambda : input().strip().split()
(x, y, z) = RI()
x -= y
maxo = x + z
mini = x - z
if maxo > 0 and mini > 0:
	print('+')
elif maxo < 0 and mini < 0:
	print('-')
elif x == 0 and z == 0:
	print('0')
else:
	print('?')


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

def sol(x, y, z):
	if y + z < x:
		return '+'
	elif x + z < y:
		return '-'
	if z == 0:
		if x == y:
			return '0'
	else:
		return '?'
print(sol(x, y, z))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 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():
	(x, y, z) = LI()
	if x == y and z == 0:
		return 0
	if x > y + z:
		return '+'
	if y > x + z:
		return '-'
	return '?'
print(main())


ll = lambda : list(map(int, input().split()))
testcases = 1
for testcase in range(testcases):
	[x, y, z] = ll()
	tl = x - y
	if tl > z:
		print('+')
	elif tl < 0 and tl + z < 0:
		print('-')
	elif tl == 0 and z == 0:
		print(0)
	else:
		print('?')


n = [int(c) for c in input().split()]
if n[0] > n[1] + n[2]:
	out = '+'
elif n[1] > n[0] + n[2]:
	out = '-'
elif n[0] == n[1] and n[2] == 0:
	out = '0'
else:
	out = '?'
print(out)


def main():
	(x, y, z) = map(int, input().split())
	ans = abs(x - y)
	if z == 0:
		print('-' if x - y < 0 else '+' if x - y > 0 else '0')
	elif ans <= z:
		print('?')
	elif x - y < 0:
		print('-')
	else:
		print('+')
main()


ii = lambda : int(input())
mi = lambda : map(int, input().split())
li = lambda : list(mi())
si = lambda : input()
msi = lambda : map(int, stdin.readline().split())
lsi = lambda : list(msi())
(x, y, z) = li()
if x == y and z == 0:
	print(0)
	exit(0)
(n1, n2) = (x + z, y + z)
if y < n1 and x < n2:
	print('?')
	exit(0)
if y > n1:
	print('-')
	exit(0)
if x > n2:
	print('+')
	exit(0)
print('?')


a = list(map(int, input().split()))
i = '?'
if a[0] == a[1] and a[2] == 0:
	i = 0
if a[0] - a[1] > 0 and a[0] - a[1] > a[2]:
	i = '+'
if a[1] - a[0] > 0 and a[1] - a[0] > a[2]:
	i = '-'
print(i)


(a, b, c) = map(int, input().split())
z = a * 1
z = z + b * -1
if z != 0:
	if abs(z) > c:
		if z == 0:
			print(0)
		elif z < 0:
			print('-')
		else:
			print('+')
	else:
		print('?')
elif c >= 1:
	print('?')
else:
	print(0)


x = input().split()
a = int(x[0])
b = int(x[1])
c = int(x[2])
if c == 0 or abs(a - b) > c:
	if a > b:
		print('+')
	elif a < b:
		print('-')
	else:
		print('0')
else:
	print('?')


x_y_z = [int(x) for x in input().split(' ')]
res_up = x_y_z[0] - x_y_z[1] + x_y_z[2]
res_down = x_y_z[0] - x_y_z[1] - x_y_z[2]
if res_down > 0:
	print('+')
elif res_down == 0 and res_up == 0:
	print('0')
elif res_up < 0:
	print('-')
else:
	print('?')


from collections import Counter
(x, y, z) = map(int, input().split())
p = x - y
if p > 0:
	print('+' if p > z else '?')
elif p < 0:
	print('-' if abs(p) > z else '?')
else:
	print(0 if z == 0 else '?')


arr = list(map(int, input().split()))
x = arr[0]
y = arr[1]
z = arr[2]
maxa = max(x, y)
mini = min(x, y)
if maxa - mini < z:
	print('?')
elif maxa - mini > z:
	if x > y:
		print('+')
	else:
		print('-')
elif mini - maxa == 0:
	print('0')
else:
	print('?')


(up, down, unk) = [int(x) for x in input().split()]
if down < up and down + unk >= up or (up < down and up + unk >= down) or (unk >= abs(up - down) and unk > 0):
	print('?')
elif up > down + unk:
	print('+')
elif down > up + unk:
	print('-')
else:
	print('0')