jesus christ in heaven

using an except block for the happy path is cursed enough in itself

After seeing this program, i wrote a script for making doing these things easier:

import base64

def main():
    while True:
        val = input(">")
        encoded = base64.b64encode(val.encode())
        print(f"{encoded}")
        print(put_b64_in_python(f"{encoded}"))

def put_b64_in_python(data):
    return f"exec(b64decode({data}).decode())"

if __name__ == "__main__":
  main()

You enter a python command, then it converts it to something you can paste into your code.

Example:

>global x; x = 5
b'Z2xvYmFsIHg7IHggPSA1'
exec(b64decode(b'Z2xvYmFsIHg7IHggPSA1').decode())
>

Have fun with it!

Can simebody explain me how this monster of intencional spaghetti code works?

Uh... i left something in my car, i have to go get it.

Umm...

Javascript?

HERES MINE:

import sys

class Cursed(type):
def new(cls, name, bases, attrs):
sys.stdout.write("".join(map(chr, [104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 10])))
return super().new(cls, name, bases, attrs)

class _(import("builtins").object, metaclass=Cursed):
pass

def cursed_decorator(f):
exec("print('hello world')")
return lambda: None

@cursed_decorator
def totally_normal_function():
print("hello world")

(eval("import('builtins').exec"))("print('hello world')")

import types
bc = compile("print('hello world')", "", "exec")
types.FunctionType(bc, {}).call()

Here is my cursed code to print "hello world":

def hello_world():
    import functools
    import operator
    global the_most_peculiar_global_variable
    def a_function_that_does_almost_nothing():
        def another_incredibly_boring_function(input_parameter_x):
            return input_parameter_x
        return another_incredibly_boring_function
    the_most_peculiar_global_variable = a_function_that_does_almost_nothing()
    a_list_of_random_things = list()
    for a_totally_arbitrary_number in (0x68, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64):
        exec(f"a_list_of_random_things.append(chr(a_totally_arbitrary_number))")
    def a_function_that_combines_things_together(a_list_of_items):
        def a_sub_function_that_adds_items(item_a, item_b):
            return item_a + item_b
        a_resulting_amalgamation = functools.reduce(a_sub_function_that_adds_items, a_list_of_items, "")
        return a_resulting_amalgamation
    result = the_most_peculiar_global_variable((lambda an_input_list: a_function_that_combines_things_together(an_input_list))(a_list_of_random_things))
    return result

Enjoy ! :)

you're crazy

I started with a much more normal looking code and iterated through transformations to end up with this monstrosity

holy shit

HE WON

holy shit, have you made this thing by head?

you sir have won the kumite