def mystery(x):
# Accept only strings
if not isinstance(x, str):
return False
# A few simple early rejects to reduce brute-force hints
if len(x) != 10:
return False
if any(ord(c) < 32 or ord(c) > 126 for c in x): # printable ASCII only
return False
# Helper: 32-bit mixing (deterministic, but hard to reason about by hand)
def mix(u):
u &= 0xFFFFFFFF
u ^= (u >> 16)
u = (u * 0x7FEB352D) & 0xFFFFFFFF
u ^= (u >> 15)
u = (u * 0x846CA68B) & 0xFFFFFFFF
u ^= (u >> 16)
return u & 0xFFFFFFFF
# Rolling accumulator with position-dependent scrambling
acc = 0xC0FFEE42
for i, ch in enumerate(x):
b = ord(ch)
acc ^= mix(b + 0x9E3779B9 * (i + 1))
acc = ((acc << 5) | (acc >> 27)) & 0xFFFFFFFF
acc = (acc + mix(acc ^ (b * (i + 17)))) & 0xFFFFFFFF
# Extra constraints that look "patterny" but are actually entangled with acc
s = sum(ord(c) for c in x)
p = 1
for c in x:
p = (p * (ord(c) + 1)) % 65537
# Final check: must hit a very specific 32-bit value and satisfy two coupled invariants
return (acc == 0x4E6F7721) and ((s ^ (acc & 0xFFFF)) == 0xBEEF) and (p == 4242)
def mystery(x):
if not isinstance(x, str) or len(x) != 8:
return False
try:
n = int(x, 16)
except:
return False
lo, hi = n & 0xFFFF, (n >> 16) & 0xFFFF
h = 0
for c in x:
h = ((h * 33) + ord(c)) & 0xFFFFFFFF
c1 = (lo * hi) ^ 0xC0DE == 0x075B724E
c2 = (lo + hi) * 1337 == 29875265
c3 = h == 0x24698AB9
return c1 and c2 and c3
def mystery(x):
# Accept ints or strings that can be parsed as ints.
if isinstance(x, bool):
return False
if isinstance(x, str):
x = x.strip()
if not x:
return False
try:
n = int(x, 0) # allows "123", "0x7b", "0o173", etc.
except Exception:
return False
elif isinstance(x, int):
n = x
else:
return False
# Force a 32-bit signed style domain to avoid trivial huge-number tricks.
if n < -2**31 or n > 2**31 - 1:
return False
# A small PRNG-like transformation (invertible mod 2^32 but annoying to reason about),
# then a few coupled constraints.
u = n & 0xFFFFFFFF
def rotl(v, r):
return ((v << r) | (v >> (32 - r))) & 0xFFFFFFFF
# SplitMix-ish mixing with fixed constants
z = (u + 0x9E3779B9) & 0xFFFFFFFF
z ^= (z >> 16)
z = (z * 0x85EBCA6B) & 0xFFFFFFFF
z ^= (z >> 13)
z = (z * 0xC2B2AE35) & 0xFFFFFFFF
z ^= (z >> 16)
# Couple in a rotate and a linear congruence check
w = rotl(z ^ 0xA5A5A5A5, (u >> 27) & 31)
# Some seemingly independent conditions that are actually tightly linked
c1 = (w & 0xFFFF) == 0xB00B
c2 = ((w >> 16) ^ (u & 0xFFFF)) == 0xC0DE
c3 = ((u * 1103515245 + 12345) & 0x7FFFFFFF) % 97 == 42
return c1 and c2 and c3
def mystery(x):
if not isinstance(x, int):
return False
if x < 10**11 or x >= 10**12:
return False
def is_prime(n):
if n < 2:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
# Find all prime factors of x in range [1000, 9999]
factors = []
temp = x
for p in range(1000, 10000):
if temp % p == 0 and is_prime(p):
while temp % p == 0:
temp //= p
factors.append(p)
# Must have exactly 3 distinct 4-digit prime factors, fully factoring x
if temp != 1 or len(factors) != 3:
return False
# Specific sum constraint
if sum(factors) != 17539:
return False
return True
def mystery(x):
# Accept only strings; keep the domain finite and unfriendly to naive brute force
if not isinstance(x, str):
return False
x = x.strip()
if len(x) != 17:
return False
# Restrict to lowercase hex, but also require a mix of digits and letters
if any(c not in "0123456789abcdef" for c in x):
return False
if not (any(c.isdigit() for c in x) and any(c in "abcdef" for c in x)):
return False
# Non-obvious, entangled constraints
n = int(x, 16)
# 1) Coupled bit constraints on the integer
if (n ^ (n >> 7) ^ (n >> 19)) & 0xFFFF != 0xB16B:
return False
# 2) A CRC32 check (polynomial-ish but opaque without computing)
# Implemented directly to avoid imports.
def crc32(data: bytes) -> int:
crc = 0xFFFFFFFF
for b in data:
crc ^= b
for _ in range(8):
mask = -(crc & 1)
crc = (crc >> 1) ^ (0xEDB88320 & mask)
return (~crc) & 0xFFFFFFFF
if crc32(x.encode("ascii")) != 0xA18B6F3C:
return False
# 3) A tiny, position-dependent mixing over bytes, then a modular check.
acc = 0x31415926
for i, ch in enumerate(x.encode("ascii"), start=1):
acc = (acc + ((ch + 17 * i) * (0x45D9F3B ^ (acc & 0xFFFF)))) & 0xFFFFFFFF
acc ^= ((acc << 13) | (acc >> 19)) & 0xFFFFFFFF
acc = (acc * 0x27D4EB2D + i) & 0xFFFFFFFF
return (acc % 1000003) == 742913
def mystery(x):
if not isinstance(x, int) or isinstance(x, bool):
return False
if x < 100000 or x >= 1000000:
return False
d = [int(c) for c in str(x)]
if sum(d) != 28:
return False
prod = 1
for digit in d:
prod *= digit
if prod != 2520:
return False
if x % 7 != 0:
return False
if sum(d[:3]) != sum(d[3:]):
return False
alt = d[0] - d[1] + d[2] - d[3] + d[4] - d[5]
if alt != 4:
return False
if d[2] + d[3] != 8:
return False
return True
def mystery(x):
# Accept either an int or a string that can be parsed to an int (base 0)
if isinstance(x, bool):
return False
if isinstance(x, str):
s = x.strip()
if not s:
return False
try:
n = int(s, 0)
except Exception:
return False
elif isinstance(x, int):
n = x
else:
return False
# Keep the search domain "reasonable" (32-bit signed)
if n < -(2**31) or n > (2**31 - 1):
return False
u = n & 0xFFFFFFFF
def rotl(v, r):
r &= 31
return ((v << r) | (v >> (32 - r))) & 0xFFFFFFFF
# A small 32-bit avalanche mixer (hard to reason about by inspection)
def mix32(v):
v &= 0xFFFFFFFF
v ^= (v >> 16)
v = (v * 0x7FEB352D) & 0xFFFFFFFF
v ^= (v >> 15)
v = (v * 0x846CA68B) & 0xFFFFFFFF
v ^= (v >> 16)
return v & 0xFFFFFFFF
a = mix32(u ^ 0xA5A5A5A5)
b = mix32((u + 0x9E3779B9) & 0xFFFFFFFF)
c = rotl(a ^ b ^ 0x3C6EF372, (u >> 27) & 31)
# Coupled constraints: bit-structure + modular + a tiny congruence
# (designed to look independent but all hinge on u through a/b/c)
cond1 = (c & 0xFFFF) == 0xC0DE
cond2 = (((c >> 16) + (a & 0xFFFF) + (b & 0xFFFF)) & 0xFFFF) == 0xBEEF
cond3 = ((a ^ (b >> 1) ^ (u * 0x45D9F3B)) & 0xFFFFFFFF) == 0xDEADBEEF
# Extra "annoyance" check that still holds for the intended solution
# (prevents some trivial algebraic constructions)
cond4 = ((u ^ (u >> 11) ^ (u >> 21)) & 0x3FF) == 0x2A3
return cond1 and cond2 and cond3 and cond4
def mystery(x):
if not isinstance(x, int) or isinstance(x, bool):
return False
if x < 10**7 or x >= 10**8:
return False
s = str(x)
d = [int(c) for c in s]
if 0 in d:
return False
if sum(d) != 40:
return False
prod = 1
for digit in d:
prod *= digit
if prod != 72576:
return False
if x % 77 != 0:
return False
if sum(d[:4]) != sum(d[4:]):
return False
if d[0] <= d[7]:
return False
if d[2] >= d[5]:
return False
return True
def mystery(x):
# Accept either int or str; if str, normalize in a slightly annoying way.
if isinstance(x, bool):
return False
if isinstance(x, str):
s = x.strip()
if not s:
return False
# normalize: collapse internal whitespace and lower-case
s = " ".join(s.split()).lower()
try:
n = int(s, 0) # supports "123", "0x7b", "0o173", etc.
except Exception:
return False
elif isinstance(x, int):
n = x
else:
return False
# Keep within 32-bit signed to block "infinite search" tricks
if n < -(2**31) or n > (2**31 - 1):
return False
u = n & 0xFFFFFFFF
def rotl(v, r):
r &= 31
return ((v << r) | (v >> (32 - r))) & 0xFFFFFFFF
# 32-bit avalanche mixer (invertible-ish in practice but awful to do by hand)
def mix32(v):
v &= 0xFFFFFFFF
v ^= (v >> 16)
v = (v * 0x7FEB352D) & 0xFFFFFFFF
v ^= (v >> 15)
v = (v * 0x846CA68B) & 0xFFFFFFFF
v ^= (v >> 16)
return v & 0xFFFFFFFF
a = mix32(u ^ 0x13579BDF)
b = mix32((u + 0x9E3779B9) & 0xFFFFFFFF)
c = mix32(rotl(a ^ b ^ 0xA5A5A5A5, (u >> 27) & 31))
d = mix32((c + rotl(u, 11) + 0xC001D00D) & 0xFFFFFFFF)
# Multiple coupled constraints: bit patterns + modular conditions.
# (These are intentionally entangled; brute-forcing from the outside is not fun.)
cond1 = (d & 0xFFFF) == 0xF00D
cond2 = ((d >> 16) ^ (c & 0xFFFF) ^ (u & 0xFFFF)) == 0xB16B
cond3 = ((a + 3*b + 7*c + 11*d) & 0xFFFFFFFF) == 0xDEADBEEF
cond4 = (((u * 1103515245 + 12345) & 0x7FFFFFFF) % 97) == 42
cond5 = ((u ^ (u >> 9) ^ (u >> 21)) & 0x3FF) == 0x2A3
return cond1 and cond2 and cond3 and cond4 and cond5
def mystery(x):
if not isinstance(x, int) or isinstance(x, bool):
return False
if x < 10000 or x >= 100000:
return False
s = str(x)
d = [int(c) for c in s]
# Hidden structural constraint
if d[0] * 10001 + d[1] * 1010 + d[2] * 100 != x:
return False
# Prime modular constraint
if x % 137 != 0:
return False
# Digit sum constraint
if sum(d) != 27:
return False
# Positional constraint on second digit
if d[1] != max(d):
return False
# Ordering constraint
if d[2] <= d[0]:
return False
return True