import time
from pwn import *

standard_ops = set(['+', '-', '*', '/'])
isTargetFound = False

def main():
    start = time.time()
    target = 14396.55
    inputNumbers = ['9', '32', '52', '31', '41', '91', '81', '78']
    stringToNumber = getAllPermutations(inputNumbers, target)

    for possible in stringToNumber:
        if stringToNumber[possible] == target:
            print("Took", time.time()-start, "seconds.")
            print(str(possible))

def ctf():
    global isTargetFound
    r = remote('ppc-01.v7frkwrfyhsjtbpfcppnu.ctfz.one', 2445)
    inp = r.recvline().decode("utf-8")

    while True:
        numbers = inp.split()
        target = float(numbers[len(numbers) - 1])
        print('target: ', target, 'numbers: ', numbers[:-1])
        start = time.time()
        permutations = getAllPermutations(numbers[:-1], target)
        isTargetFound = False
        print("Took ", time.time()-start, " seconds.")
        answer = ''
        for possible in permutations:
            if permutations[possible] == target:
                answer = str(possible)
                break
        print(answer)
        r.sendline(answer)
        print('Answer: ', r.recvline().decode("utf-8"))
        inp = r.recvline().decode("utf-8")



def getAllPermutations(inputNumbers, target, operations = standard_ops):
    toReturn = dict()
    consideredPermutations = set()
    currentPermutation = tuple(inputNumbers)
    toReturn.update(getNumbers(currentPermutation, target, operations))
    return toReturn

# Get a map from an order of operations on the "inputNumbers"
# (where operations are from "operations") to the value they produce.
def getNumbers(inputNumbers, target, operations):
    inputStrings = list()
    newInputNumbers = list()
    for inputNumber in inputNumbers:
        inputStrings.append(str(inputNumber))
        newInputNumbers.append(float(inputNumber))
    return helpGetNumbers(inputStrings,
                          newInputNumbers,
                          operations,
                          target,
                          dict())

# Add to the map "answers" all the possible order of operations on the
# "inputNumbers" (where operations are from "operations").
# Keep track of the current state of the operations in "inputStrings".
def helpGetNumbers(inputStrings,
                   inputNumbers,
                   operations,
                   target,
                   answers):
    global isTargetFound
    if isTargetFound:
        return answers
    if len(inputNumbers) == 1 and inputNumbers[0] == target:
        isTargetFound = True
        answers[inputStrings[0]] = inputNumbers[0]
    else:
        if len(inputNumbers) == 1:
            answers[inputStrings[0]] = inputNumbers[0]
        else:
            for firstIndex in range(len(inputNumbers) - 1):
                for operation in operations:
                    result = operate(operation,
                                    inputNumbers[firstIndex],
                                    inputNumbers[firstIndex + 1])
                    if result != None:
                        newString = "(" + inputStrings[firstIndex] + \
                                    operation + inputStrings[firstIndex + 1] + ")"
                        newNumbers, newStrings = replaceNumber(firstIndex,
                                                            result,
                                                            newString,
                                                            inputNumbers,
                                                            inputStrings)
                        helpGetNumbers(newStrings,
                                    newNumbers,
                                    operations,
                                    target,
                                    answers)
    return answers
def replaceNumber(index,
                  newResult,
                  newString,
                  inputNumbers,
                  inputStrings):
    newNumbers = list()
    newStrings = list()
    for currentIndex in range(index):
        newNumbers.append(inputNumbers[currentIndex])
        newStrings.append(inputStrings[currentIndex])
    newNumbers.append(newResult)
    newStrings.append(newString)
    for currentIndex in range(index + 1, len(inputNumbers) - 1):
        newNumbers.append(inputNumbers[currentIndex + 1])
        newStrings.append(inputStrings[currentIndex + 1])
    return newNumbers, newStrings

# Given a binary "operation", do the mathematical operation
# on the two arguments.
def operate(operation, firstNumber, secondNumber):
    if operation == '+':
        return firstNumber + secondNumber
    if operation == '-':
        return firstNumber - secondNumber
    if operation == '*':
        return firstNumber * secondNumber
    if operation == '/':
        return None if secondNumber == 0 else firstNumber / secondNumber
    raise Exception("Unsupported operation: " + operation)

if __name__ == '__main__':
    # main()
    ctf()