def mystery(x):
if not isinstance(x, str) or len(x) != 6:
return False
a = [ord(c) for c in x]
if not all(32 <= c <= 126 for c in a):
return False
p = [2, 3, 5, 7, 11, 13]
return (
sum(a[i] * p[i] for i in range(6)) == 4540 and
sum(a[i] * p[5-i] for i in range(6)) == 4733 and
sum(a[i] * (i+1) for i in range(6)) == 2346 and
sum(a) == 682 and
a[0] * a[5] == 11312 and
a[2] == a[3]
)
def mystery(x):
import unicodedata
if not isinstance(x, str):
return False
# Must already be in a canonical form (prevents "visually similar" tricks).
if x != unicodedata.normalize("NFKC", x):
return False
if len(x) != 10:
return False
a = [ord(c) for c in x]
# Keep it to visible ASCII (but allow punctuation).
if not all(33 <= v <= 126 for v in a):
return False
primes = (2, 3, 5, 7, 11, 13, 17, 19, 23, 29)
# A pile of constraints, mixing linear, modular, XOR, and multiplicative structure.
s1 = sum(a)
s2 = sum((i + 1) * v for i, v in enumerate(a))
s3 = sum(v * p for v, p in zip(a, primes))
s4 = sum(v * p for v, p in zip(a, reversed(primes)))
v = 0
for i, b in enumerate(a):
v ^= (b ^ ((i * 31 + 7) & 0xFF))
sq = sum((b - 32) * (b - 32) for b in a) % 997
prod = 1
for i, b in enumerate(a):
prod = (prod * (b + 17 * i)) % 10007
acc = 0
for b in a:
acc = (acc * 131 + b) & 0xFFFF
return (
s1 == 1006 and
s2 == 5244 and
s3 == 11886 and
s4 == 13647 and
v == 190 and
sq == 812 and
prod == 6720 and
acc == 62466 and
(a[0] + a[-1]) == 141 and
(a[1] ^ a[8]) == 9 and
(a[3] * a[4] - a[5] * a[6]) == 2244 and
((a[7] << 8) | a[6]) == 29806
)
def mystery(x):
if not isinstance(x, str) or len(x) != 5:
return False
a = [ord(c) for c in x]
if not all(33 <= c <= 126 for c in a):
return False
w1 = sum(c * p for c, p in zip(a, [2, 3, 5, 7, 11]))
w2 = sum(c * p for c, p in zip(a, [11, 7, 5, 3, 2]))
xr = 0
for c in a:
xr ^= c
pr = 1
for c in a:
pr = (pr * c) % 10007
rh = 0
for c in a:
rh = (rh * 37 + c) % 10009
return (
sum(a) == 403 and
w1 == 2071 and
w2 == 2352 and
xr == 77 and
pr == 8198 and
rh == 8420 and
a[1] - a[4] == 63 and
a[0] + a[3] == 189
)
def mystery(x):
import unicodedata
if not isinstance(x, str):
return False
# eliminate "looks-like" / alternate unicode encodings
if x != unicodedata.normalize("NFKC", x):
return False
if len(x) != 12:
return False
a = [ord(c) for c in x]
# visible ASCII only (no spaces)
if not all(33 <= v <= 126 for v in a):
return False
# lightweight "cipher" layer
s = 0xAD
t = []
for i, v in enumerate(a):
s = (s * 17 + 43) & 0xFF
k = s ^ ((i * 19 + 0x55) & 0xFF)
t.append(v ^ k)
# stateful mixing layer
acc = 0
u = []
for i, w in enumerate(t):
acc = (acc + w + i * 11) & 0xFF
u.append(w ^ acc)
# a couple of extra cross-checks (to kill near-misses)
xors = 0
for v in a:
xors ^= v
return (
bytes(u) == bytes([0, 197, 32, 191, 45, 50, 216, 1, 195, 194, 185, 0])
and ((sum(a) * 31337 + xors) % 100000) == 84974
and (((a[0] << 8) | a[-1]) == 19745)
)
def mystery(x):
if not isinstance(x, str) or len(x) != 7:
return False
a = [ord(c) for c in x]
if not all(33 <= c <= 126 for c in a):
return False
w = [2, 3, 5, 7, 11, 13, 17]
v = 0
for i, c in enumerate(a):
v ^= (c + i) & 0xFF
m = 1
for c in a:
m = (m * c) % 9973
h = 0
for c in a:
h = (h * 53 + c) % 10007
q = sum(c * (i*i + 1) for i, c in enumerate(a))
return (
sum(a) == 588 and
sum((i+1) * c for i, c in enumerate(a)) == 2392 and
sum(c * p for c, p in zip(a, w)) == 5007 and
v == 115 and
m == 4215 and
h == 528 and
q == 8514 and
a[0] ^ a[6] == 55 and
a[2] + a[4] == 159
)
def mystery(x):
import unicodedata
if not isinstance(x, str):
return False
# Canonicalize to prevent Unicode "look-alikes" / alternate encodings.
if x != unicodedata.normalize("NFKC", x):
return False
if len(x) != 12:
return False
a = [ord(c) for c in x]
# Visible ASCII only.
if not all(33 <= v <= 126 for v in a):
return False
n = 12
# Stateful byte-mixer with wraparound dependency on the previous character.
seed = 0xA7
u = []
for i, b in enumerate(a):
seed = (seed * 73 + 41 + i) & 0xFF
left = (b + seed) & 0xFF
right = (a[(i - 1) % n] * 7 + i * 19) & 0xFF
u.append(left ^ right)
if bytes(u) != bytes([244, 69, 109, 28, 187, 207, 147, 153, 110, 126, 49, 233]):
return False
primes = (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37)
s1 = sum(a)
s2 = sum((i + 1) * v for i, v in enumerate(a))
s3 = sum(v * p for v, p in zip(a, primes))
s4 = sum(v * p for v, p in zip(a, reversed(primes)))
xr = 0
for i, v in enumerate(a):
xr ^= (v ^ (i * 17 + 43)) & 0xFF
h = 0
for v in a:
h = (h * 131 + v) % 65521
prod = 1
for i, v in enumerate(a):
prod = (prod * ((v + 17 * i) % 10007)) % 10007
return (
s1 == 885
and s2 == 5239
and s3 == 12692
and s4 == 15926
and xr == 175
and h == 32651
and prod == 5675
and ((a[0] << 8) | a[-1]) == 19233
and (a[2] ^ a[7]) == 74
and (a[8] + a[9] + a[10]) == 197
and (a[3] * a[4] - a[5] * a[6]) == 4348
and (a[1] - a[11]) == 18
and (a[6] & 15) == 14
)
def mystery(x):
if not isinstance(x, str) or len(x) != 8:
return False
a = [ord(c) for c in x]
if not all(33 <= c <= 126 for c in a):
return False
# Stateful mixing layer
s = 0x5A
t = []
for i, c in enumerate(a):
s = ((s * 31 + c + i) ^ (s >> 3)) & 0xFF
t.append(s)
primes = [2, 3, 5, 7, 11, 13, 17, 19]
w1 = sum(c * p for c, p in zip(a, primes))
w2 = sum(c * p for c, p in zip(a, reversed(primes)))
prod = 1
for c in a:
prod = (prod * c) % 9973
h = 0
for c in a:
h = (h * 67 + c) % 10009
xr = 0
for i, c in enumerate(a):
xr ^= (c + t[i]) & 0xFF
return (
sum(a) == 599 and
w1 == 5143 and
w2 == 6160 and
sum((i+1) * c for i, c in enumerate(a)) == 2495 and
prod == 8184 and
h == 4015 and
t[-1] == 228 and
xr == 181 and
a[0] + a[7] == 105 and
a[2] ^ a[5] == 54
)
def mystery(x):
import unicodedata
if not isinstance(x, str):
return False
# Prevent alternate Unicode spellings / lookalikes.
if x != unicodedata.normalize("NFKC", x):
return False
if len(x) != 12:
return False
a = [ord(c) for c in x]
# Visible ASCII only (no spaces).
if not all(33 <= v <= 126 for v in a):
return False
# A few "cheap" constraints that don't reveal much alone.
if sum(a) != 1091:
return False
if sum((i + 1) * v for i, v in enumerate(a)) != 7130:
return False
xr = 0
for v in a:
xr ^= v
if xr != 77:
return False
if (a[0] ^ a[-1]) != 20:
return False
if a[6] != 95:
return False
if (a[1] + a[10]) != 161:
return False
if (a[7] - a[8]) != -20:
return False
# Stateful keystream + XOR "cipher" layer (depends on previous plaintext byte).
seed = 0xA7
prev = 0
out = []
for i, b in enumerate(a):
seed = (seed * 57 + 13 + 11 * i + prev * 19) & 0xFF
term = (29 * i + (prev >> 1)) & 0xFF
k = seed ^ (seed >> 4) ^ term
out.append(b ^ k)
prev = b
outb = bytes(out)
# Extra aggregates on the transformed bytes.
if sum(outb) != 1736:
return False
y = 0
for v in outb:
y ^= v
if y != 94:
return False
target = bytes.fromhex("4c9775fa3bda74d7df1651d0")
return outb == target
def mystery(x):
if not isinstance(x, str) or len(x) != 8:
return False
a = [ord(c) for c in x]
if not all(33 <= c <= 126 for c in a):
return False
s = 0x5A
t = []
for i, c in enumerate(a):
s = ((s * 31 + c + i) ^ (s >> 3)) & 0xFF
t.append(s)
primes = [2, 3, 5, 7, 11, 13, 17, 19]
w1 = sum(c * p for c, p in zip(a, primes))
w2 = sum(c * p for c, p in zip(a, reversed(primes)))
prod = 1
for c in a:
prod = (prod * c) % 9973
h = 0
for c in a:
h = (h * 67 + c) % 10009
xr = 0
for i, c in enumerate(a):
xr ^= (c + t[i]) & 0xFF
return (
sum(a) == 723 and
w1 == 7151 and
w2 == 6759 and
sum((i+1) * c for i, c in enumerate(a)) == 3334 and
prod == 7767 and
h == 8401 and
t[-1] == 20 and
xr == 199 and
sum(c * c for c in a) == 69815 and
a[0] + a[7] == 180 and
a[2] ^ a[5] == 67 and
a[3] - a[4] == 28
)
def mystery(x):
import unicodedata
if not isinstance(x, str):
return False
# eliminate alternate Unicode encodings / lookalikes
if x != unicodedata.normalize("NFKC", x):
return False
if len(x) != 12:
return False
a = [ord(c) for c in x]
if not all(33 <= v <= 126 for v in a): # visible ASCII, no spaces
return False
# a few cheap checks (easy to test, hard to guess without structure)
if sum(a) != 921:
return False
s2 = sum((i + 1) * v for i, v in enumerate(a))
if s2 != 5581:
return False
xr = 0
for v in a:
xr ^= v
if xr != 97:
return False
if ((a[0] << 8) | a[-1]) != 21025:
return False
# pass 1: stateful keystream XOR; keystream depends on previous plaintext
seed = 0xC3
prev = 0
t = []
for i, b in enumerate(a):
seed = (seed * 45 + 17 + i * 11) & 0xFF
k = seed ^ ((seed << 3) & 0xFF) ^ ((prev * 7) & 0xFF)
t.append(b ^ k)
prev = b
# pass 2: accumulator mask + XOR, with accumulator updated by plaintext-derived state
acc = 0x5D
u = []
for i, w in enumerate(t):
acc = (acc * 33 + 7 * i + 0x21) & 0xFF
u.append(w ^ acc)
acc = (acc + w) & 0xFF
ub = bytes(u)
# extra aggregates on the transformed bytes
if sum(ub) != 1692:
return False
y = 0
for v in ub:
y ^= v
if y != 194:
return False
target = bytes([212, 41, 248, 238, 134, 11, 85, 54, 185, 247, 59, 178])
return ub == target