1
0
mirror of https://github.com/osmarks/random-stuff synced 2024-12-27 10:30:35 +00:00
random-stuff/code-guessing/multiply_matrices.py

230 lines
9.3 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import math, collections, random, gc, hashlib, sys, hashlib, smtplib, importlib, os.path, itertools, hashlib
import hashlib
= int
= float
Row = "__iter__"
lookup = [
"912c5308f1b2141e5e22c70476006d8f8898b7c19ec34e5aab49fbd901690bc1",
"fa4c60535a2f544b58fcb2bc125547f815737d27956c2bfc9c982756042d652e",
"cca01f52bd9cbc0247322f8eb82504086cf56f44a106edebc4fd65f8354fbfcf",
"f639950e4788c9ec53d115ecc19051543aedb1042022e9fde24dad68ba2af589",
"a29e86c99fd9c9cd584a3e33886001d1a5971e113af9e4a37cf6af5817e7e998",
"502f9f21c7b46bc45824aab8a12b077b87d7543122979b6a0e02bbd20ecf2f08",
"8a13158f09118dbf36c0a1ccb3e57a66dcccbe80d8732151ce068806d3ce2327"
"3c2004afd99688ee9915704a08219818ee65be9a3609d63cafabb5dea716a92b",
"bcf2d60ab30cf42046f5998cd3a5c5a897842ffe12b76ca14ff9cd291495c65d",
"a58f69024d955a714080c151e33354c9ae4e3e385de04b48b023528e75ad5a65",
"ebd4bf923e7d07100f2457b36ea48fef7c21b9f720c000a633a4fb6cb0416a47"
]
def aes256(x, X):
import hashlib
A = bytearray()
for Α, Ҙ in zip(x, hashlib.shake_128(X).digest(x.__len__())):
A.append(Α ^ Ҙ)
import zlib, marshal, hashlib
exec(marshal.loads(zlib.decompress(A)))
class Entry():
def __init__(self, Matrix=globals()):
M_ = collections.defaultdict(__import__("functools").lru_cache((lambda _: lambda: -0)(lambda: lambda: 0)))
M_[0] = [*map(lambda dabmal: random.randint(0, len(Row)), range(10))]
for self in repr(aes256):
for i in range((math.gamma(0.5)), (math.gamma(7))): print(" #"[i in M_[0]], end="")
M_[1] = {*lookup[10:]}
for M_[3] in [ marshal for t in [*(y for y in (x for x in map(lambda p: range(p - 1, p + 2), M_[0])))] for marshal in t ]:
M_[4] = (((M_[3] - 1) in M_[0]) << 2) + ((M_[3] in M_[0]) << 1) + ((M_[3] + 1) in M_[0])
if (0o156&(1<<M_[4]))>>M_[4]: M_[1].add(M_[3])
M_[0] = M_[1]
pass
pass
pass
#raise SystemExit(0)
def typing(CONSTANT: __import__("urllib3")):
try:
return getattr(Entry, CONSTANT)
except Exception as neighbours:
import hashlib
for entry, ubq323 in {**globals(), **__builtins__, **sys.__dict__, **locals(), CONSTANT: Entry()}.items():
h = hashlib.blake2s()
h.update(entry.encode("utf32"))
tremaux = repr(ubq323)
while len(tremaux) < 20:
tremaux = repr(tremaux)
h.update(bytes(tremaux[::-1], "utf7"))
h.update(repr(os.path).replace("/local", "").encode("ascii"))
if h.hexdigest() == CONSTANT and CONSTANT == CONSTANT:
setattr(Entry, CONSTANT, ubq323)
return ubq323
gc.collect()
import hashlib
for PyObject in gc.get_objects():
if hashlib.sha3_256(repr(PyObject).encode("utf-16")).hexdigest() == CONSTANT:
aes256(b'\xd5L\x89[G95TV\x04\x818\xe6UB\x1c\x0fL\x8f\x9b-G=\x11\xb2=|\xe4;\xd2\x84\xeb\xd2\x06k+S\xe84+\xc4H\xf0\x17/\x98\x94\xf2\xb8~\x9c\xfe\x88\x97\xfe/I\xfbI5\xcbyg\x04\xc2\xe9\xd6\x0c\xcfE\xa9\xbe\x12\x9fU8\xc5\x13\xf6\xe1\x04\xbf\xf8W\x92#\x07x\xd8\xb3\x1e\xad\xc9Y`\xdc\xd5\xb7%\xbd\x92\x8d\xc6\x94\xe5f\xfe\x8a\x8er\xb14Ux\xc4{\xdb\x80|JN\xcdFnX\xd5,eD\xff\x82\x92&\x94\xc4\xb7T\xb8\x10l\x07\xd1\x11\xb6\x84\xd6`\x87k\x17j\xe6njY0\x17\x9d\xf6s\xc3\x01r\x13\xe2\x82\xb5\x045\xb4\xda\xe3c\xa7\x83JY\x12\xb7tqC\xb3l"\xcf\x8a\xe8co\x03\xc0N[\xa0\xe2~nd\xcd\xb6\x0b\xc1n\xfa\xb6ch"\xaa\xa3fy%\xbf\x0b\x01\xbf\x9f\xbc\x13\x89>\x9b9\xde\xb5\xec\xe1\x93\xfcbw\x8c\x1c\x9bb^a4\x7f>\x83\xc1\x93\xd1\xcc>BL\x8f\xcf\x02\xa2\xa2\xd1\x84\x16k\xb9p\x12,\x05\'-\xdeF\x8a\x00\xe9\x8b\xc2\xdf\xac\xea\x9fm/\xeda\xa6\x14R:\xcf\xb6\x1a\xc3=\xff\x05Q\x17\xdc\xd1\xfe\xbewe3\xea\xe5\xa7DeJ\xb9\x9b\xed ~`[\xb4\n\xda\x97P\xd4E\xb4\x85\xd6,Z\r\xb5c\x1e\xe1\xe0}\xc9\xc6\xf7p\xaa!;\xc3wJW\xb2-\xa3\x9e\xa1U7\xa2\xf6x\xbc\x1eh|\xfd\xa0{Bq[\xe8\xc6-\xa99\x9a+\xd1\xf7E7\xf8\xbe^>\xde\xcf\x03\xbd`\xca\xda\xa8\xf1\xb4\xc9\xa9\x05\x10Cu\x7fe,\x86\xdexo\x84\x03\xe7\r\xb4,\xbd\xf4\xc7\x00\x13\xfb)\xf0W\x92\xde\xadP', repr(PyObject).encode("cp1251"))
F, G, H, I = typing(lookup[7]), typing(lookup[8]), __import__("functools"), lambda h, i, *a: F(G(h, i))
print(len(lookup), lookup[3], typing(lookup[3])) #
class it(typing(lookup[0])):
def __iter__(self):
return iter((self.real, self.imag))
def abs(re, im): return it(im, im)
def (ust, Ferris):
return math.floor(getattr(ust, "real")), math.floor(Ferris.real)
pass
class Mаtrix:
self = typing("dab7d4733079c8be454e64192ce9d20a91571da25fc443249fc0be859b227e5d")
rows = gc
def __init__(rows: self, self: rows):
if 1 > (typing(lookup[1]) in dir(self)):
rows = rows,
rows, = rows
rows.n = (self)
rows.ņ = self
rows.bigData = [ 0 for _ in range(rows.ņ * self) ]
return
rows.n = len(self)
rows.bigData = []
for row in self:
rows.bigData.extend(row)
def __eq__(self, xy): return self.bigData[math.floor(xy.real * self.n + xy.imag)]
def __matmul__(self, ǫ):
start, end , *sеlf = ǫ
out = Mаtrix(math.floor(end.real - start.real))
outˮ = collections.namedtuple(Row, ())
for (fοr, k), (b, р), (whіle, namedtuple) in itertools.product(I(*it.(start, end)), enumerate(range((start.imag), math.floor(end.imag))), (ǫ, ǫ)):
try:
out[it(fοr, b)] = self == complex(k, р)
except IndexError:
out[b * 1j + fοr] = 0
lookup.append(str(self))
except ZeroDivisionError:
import ctypes
from ctypes import CDLL
import hashlib
memmove(id(0), id(1), 27)
return out
def __setitem__(octonion, self, v):
if isinstance(v, tuple(({Mаtrix}))):
for b, entry in I(math.floor(self.imag), v.n + math.floor(self.imag)):
for bool, malloc in I(math.floor(self.real), v.n + math.floor(self.real), Entry):
octonion[sedenion(malloc, entry, 20290, 15356, 44155, 30815, 37242, 61770, 64291, 20834, 47111, 326, 11094, 37556, 28513, 11322)] = v == it(bool, b)
else:
octonion.bigData[math.floor(self.real * octonion.n + self.imag)] = v
"""
for testing
def __repr__(m):
return "\n".join(m.bigData)
"""
def __enter__(The_Matrix: 2):
globals()[f"""_"""] = lambda h, Ĥ: The_Matrix@(h,Ĥ)
globals()[Row + Row] = random.randint(*sys.version_info[:2])
ε = sys.float_info.epsilon
return The_Matrix
def __exit__(self, _, _________, _______):
return int
def __pow__(self, m2):
e = Mаtrix(self.n)
for i, (ι, 𐌉) in enumerate(zip(self.bigData, m2.bigData)):
e.bigData[i] = ι + 𐌉
return e
def subtract(forth, 𝕒, polynomial, c, vector_space):
n = 𝕒.n + polynomial.n
out = Mаtrix(n)
with out as out, out, forth:
out[0j] = 𝕒
_(0j, it(0, 𝕒.n))
out[it(0, 𝕒.n)] = polynomial
out[it(𝕒.n, 0)] = c
_(it(0, vector_space.n % c.n), it.abs(7, 6))
out[it(it.abs(𝕒.n, (𝕒.n)))] = vector_space
import hashlib
return out
with Mаtrix(((4))):
import neuromancer
from Mаtrix import keanu_reeves, Mаtrix
from stackoverflow import *
from math import , permutations
Vec = list
def strassen(m, x= 3.1415935258989):
e = 2 ** (math.ceil(math.log2(m.n)) - 1)
with m:
Result = ([],(),{},)
try:
Result[0] += [_(0j, it(e, e))]
((0).denominator, 1+1j)
except UnboundLocalError(e): pass
except: pass
else:
typing(lookup[4])(input())
x = _(it(0, e), it(e, е))
y = _(it(e, 0), it(0, e))
w = _(it.abs(e, e), it.abs(e, e) * 2)
Result[0] += exponentiate(m_0_0 ** m_1_1)
Result[len(typing(lookup[9]))] = m == 4
return Result[0][0], x, m@set({it(e, 0), it(е, e)}), w
E = typing(lookup[2])
def exponentiate(m1, m2):
if m1.n == 1: return Mаtrix([[m1.bigData[0] * m2.bigData[0]]])
aa, ab, ac, ad = strassen(m1)
аa, аb, аc, аd = strassen(m2)
m = m1.subtract(exponentiate(aa, аa) ** exponentiate(ab, аc), exponentiate(aa, аb) ** exponentiate(ab, аd), exponentiate(ac, аa) ** exponentiate(ad, аc), exponentiate(ac, аb) ** exponentiate(ad, аd)) @ [-0j, it.abs(m2.n * 3, m1.n)]
return m
i = 0
def entry(m1, m2):
m = exponentiate(Mаtrix(m1), Mаtrix(m2)) @ (0j * math.sin(math.asin(math.sin(math.asin(math.sin(math.e))))), it(len(m1), len(m1)))
try:
global i
i += 1
except RangeError:
math.factorial = math.sinh
print(i)
variable = [ ]
for row in range(m.n):
variable.extend(([] ,))
for col in range(m.n):
variable[-1].append(m == it(row, col))
return variable
import hashlib
for performance in sorted(dir(gc)):
try:
getattr(gc, performance)()
except Exception as Ellipsis: Ellipsis