if op == "not": v = not64(x)

elif op == "shr1": v = shr1(x)

elif op == "shr4": v = shr4(x)

elif op == "shr16": v = shr16(x)

elif op == "shl1": v = shl1(x)

else: assert False, "unknown operator: " + op

if op == "and": v = x & y

elif op == "or": v = x | y

elif op == "xor": v = x ^ y

elif op == "plus": v = plus(x, y)

else: assert False, "unknown operator: " + op

result = [None] * (last + 1)

result[1] = set([(0,)*len(keys), (1,)*len(keys), tuple(keys)])

for i in xrange(2, last + 1):

st = set()

for op in ops:

ar = get_arity(op)

remain = i - 1

if ar == 1:

for prev_value in result[remain]:

new_value = tuple(map(lambda x: op1_getx(op, x), prev_value))

st.add(new_value)

elif ar == 2:

for c1 in xrange(1, remain):

c2 = remain - c1

#assert c2 > 0

if c1 > c2: break

for prev_value1 in result[c1]:

for prev_value2 in result[c2]:

new_value = tuple(map(lambda x, y: op2_getxy(op, x, y), prev_value1, prev_value2))

st.add(new_value)

elif ar == 3:

for c1 in xrange(1, remain):

for c2 in xrange(1, remain - c1):

c3 = remain - c1 - c2

#assert c3 > 0

for prev_value1 in result[c1]:

for prev_value2 in result[c2]:

for prev_value3 in result[c3]:

new_value = tuple(map(lambda x, y, z: if0(x, y, z), prev_value1, prev_value2, prev_value3))

st.add(new_value)

print op,

print

result[i] = st

if right_answer != ():

if right_answer in st:

return result[:i+1]

print "%d step is done, size = %d" % (i, len(st))

if len(st) > 1000:

print "Size is too big, tryin to RUSH"

return result[:i+1]

def recur(level, values):

#assert values in trees_values[level]

if level == 1:

if values == (0,) * len(values):

yield Const(0)

if values == (1,) * len(values):

yield Const(1)

if values == tuple(keys):

yield Var()

return

remain = level - 1

for op in ops:

ar = get_arity(op)

if ar == 1:

for prev_value in trees_values[remain]:

if tuple(map(lambda x: op1_getx(op, x), prev_value)) == values:

for prev_tree in recur(remain, prev_value):

#assert tuple(map(lambda x: Op1(op, prev_tree).getx(x), keys)) == values

yield Op1(op, prev_tree)

elif ar == 2:

for c1 in xrange(1, remain):

c2 = remain - c1

#assert c2 > 0

if c1 > c2: break

for prev_value1 in trees_values[c1]:

for prev_value2 in trees_values[c2]:

if tuple(map(lambda x, y: op2_getxy(op, x, y), prev_value1, prev_value2)) == values:

for prev_tree1 in recur(c1, prev_value1):

for prev_tree2 in recur(c2, prev_value2):

#assert tuple(map(lambda x: Op2(op, prev_tree1, prev_tree2).getx(x), keys)) == values

yield Op2(op, prev_tree1, prev_tree2)

elif ar == 3:

for c1 in xrange(1, remain):

for c2 in xrange(1, remain - c1):

c3 = remain - c1 - c2

#assert c3 > 0

for prev_value1 in trees_values[c1]:

for prev_value2 in trees_values[c2]:

for prev_value3 in trees_values[c3]:

if tuple(map(lambda x, y, z: if0(x, y, z), prev_value1, prev_value2, prev_value3)) == values:

for prev_tree1 in recur(c1, prev_value1):

for prev_tree2 in recur(c2, prev_value2):

for prev_tree3 in recur(c3, prev_value3):

#assert tuple(map(lambda x: If0(prev_tree1, prev_tree2, prev_tree3).getx(x), keys)) == values

yield If0(prev_tree1, prev_tree2, prev_tree3)

for i in xrange(1, len(trees_values)):

if true_values in trees_values[i]:

print "Trying %d-th step" % i

for a in recur(i, true_values):

if (x >> 20) == 0:

q = 1

else:

q = x | 1

print 'Filtering trees'

delta = 0

for c in trees_gen:

delta += 1

if delta % 1000 == 0:

print ".",

good = True

for j in xrange(len(xs)):

value = c.getx(xs[j])

expected = ys[j]

if value != expected:

good = False

break

if good:

print 'Skipped', delta

return c, delta

if "solved" in p:

print 'Already solved!'

return

ops = p["operators"]

if ("fold" in ops) or ("tfold" in ops):

print "solving only without fold"

return

if "bonus" in ops:

ops.remove("bonus")

AR = tuple([randint(0, LAST) for i in xrange(10)]) + (0, 1, LAST)

g = gen_tree_values(p["size"], ops, AR)

hex_input = map(to_hex, AR)

print "First request at", strftime("%Y-%m-%d %H:%M:%S", localtime())

data = proxy.make_eval(p["id"], hex_input)

right_answers = tuple(map(from_hex, data["outputs"]))

print "right_answers =", right_answers

h_gen = find_all_trees_with_values(g, AR, right_answers, ops)

index = 0

xs, ys = [], []

h_current = h_gen.next()

for i in xrange(1000):

print

print 'Iterating', i

# if i < 10:

# ans = [Const(0)] + ans

solution = dump_program(h_current)

print 'solution = ', solution

data = proxy.make_guess(p["id"], solution)

status = data["status"]

if status == "win":

print

print 'GOT IT!!! after ', index, 'skips'

if Config.TRAINING == False:

fff = open("output\\%s.txt" % str(p["number"]), "wt")

print >>fff, h_current.dump()

fff.close()

break

if status == "error":

print 'Error!, proceeding to another guess'

h_gen.next()

if status == "mismatch":

x, y, my = map(from_hex, data["values"])

xs.append(x)

ys.append(y)

h_current, delta = find_first_good2(h_gen, xs, ys)