did it

#!/usr/bin/env python3

from random import randint
import sys
from flag import flag

def die(*args):
	pr(*args)
	quit()

def pr(*args):
	s = " ".join(map(str, args))
	sys.stdout.write(s + "\n")
	sys.stdout.flush()

def sc():
	return sys.stdin.buffer.readline()

def did(n, l, K, A):
	A, K = set(A), set(K)
	R = [pow(_, 2, n) + randint(0, 1) for _ in A - K]
	return R

def main():
	border = "+"
	pr(border*72)
	pr(border, ".::   Hi all, she DID it, you should do it too! Are you ready? ::.  ", border)
	pr(border*72)

	_flag = False
	n, l = 127, 20
	N = set(list(range(0, n)))
	K = [randint(0, n-1) for _ in range(l)]
	cnt, STEP = 0, 2 * n // l - 1
	
	while True:
		ans = sc().decode().strip()
		try:
			_A = [int(_) for _  in ans.split(',')]
			if len(_A) <= l and set(_A).issubset(N):
				DID = did(n, l, K, _A)
				pr(border, f'DID = {DID}')
				if set(_A) == set(K):
					_flag = True
			else:
				die(border, 'Exception! Bye!!')
		except:
			die(border, 'Your input is not valid! Bye!!')
		if _flag:
			die(border, f'Congrats! the flag: {flag}')
		if cnt > STEP:
			die(border, f'Too many tries, bye!')
		cnt += 1

if __name__ == '__main__':
	main()

from json import dumps
from pwn import *
import random


known = []


def get_conflicts(tried, did_input):
    inp = tried
    mappa = {}
    for _ in inp:
        s, s1 = _ ** 2 % 127, (_ ** 2 + 1) % 127
        if s not in mappa:
            mappa[s] = []
        if s1 not in mappa:
            mappa[s1] = []
        mappa[s].append(_)
        mappa[s1].append(_)

    known_fs = inp.copy()
    inp2 = did_input
    conflict = []
    for _ in inp2:
        assert _ in mappa
        if len(mappa[_]) == 1:
            q = mappa[_][0]
            for _2 in mappa:
                if q in mappa[_2]:
                    mappa[_2].remove(q)
            if q in known_fs:
                known_fs.remove(q)
        else:
            for _2 in mappa[_]:
                conflict.append(_2)
                if _2 in known_fs:
                    known_fs.remove(_2)
    conflicting = list(set(conflict))
    return known_fs, conflicting


def main():
    p = remote("00.cr.yp.toc.tf", 11337)
    queue = [_ for _ in list(range(127))]
    times = 0
    while len(queue):
        tried, queue = queue[:20], queue[20:]
        print(f"Sending: {str(tried).encode('ascii')[1:-1]}")
        p.sendline(str(tried).encode('ascii')[1:-1])
        p.recvuntil(b"DID = ")
        did_result = eval(p.recvuntil(b']').decode('ascii'))
        print(f"Received: {did_result}")
        known_add, conflicts = get_conflicts(tried, did_result)
        known.extend(known_add)
        print(f"Known ({len(known)}): {known}")
        while len(conflicts):
            queue.insert(random.randint(0, len(queue)), conflicts.pop(0))
        print(f"Length of queue: {len(queue)}")
        if times == 10:
            break
        times += 1
    p.interactive()


if __name__ == '__main__':
    main()