The sky is the limit.

[realicraft]

round post id, that last post had

[realicraft]

where is everyone

[realicraft]

radioactive rabbits eat round raw radishes

[realicraft]

Brown bricks.

[realicraft]

Minecrap.

[donotforgetmycode]

The temperature is 90.
The temperature is rising.
Therefore, 90 is rising.

A white horse is not a horse, because "white horse" and "horse" refer to different concepts.

[realicraft]

The temperature is 90.
The temperature is rising.
Therefore, 90 is rising.

A white horse is not a horse, because "white horse" and "horse" refer to different concepts.

then what're these

Code (#minecraft:horses) Select Expand

{
  "values": [
    "#minecraft:colored_horses",
    "minecraft:skeleton_horse",
    "minecraft:zombie_horse"
  ]
}


Code (#minecraft:colored_horses) Select Expand

{
  "values": [
    "minecraft:white_horse",
    "minecraft:light_gray_horse",
    "minecraft:gray_horse",
    "minecraft:black_horse",
    "minecraft:brown_horse",
    "minecraft:red_horse",
    "minecraft:orange_horse",
    "minecraft:yellow_horse",
    "minecraft:lime_horse",
    "minecraft:green_horse",
    "minecraft:cyan_horse",
    "minecraft:light_blue_horse",
    "minecraft:blue_horse",
    "minecraft:purple_horse",
    "minecraft:magenta_horse",
    "minecraft:pink_horse"
  ]
}
(disclaimer: i am lying)

[Luigis_Pizza]

Reali calm down! Your scaring me!

[PkmnQ]

759

[PkmnQ]

760

[PkmnQ]

761

[realicraft]

*you're

[realicraft]

file_sheet

[Zan]

stop calming down

[realicraft]

stop calming down

Noo, sir!

[Byron_Inc_TBG]

;

[realicraft]

pootis

[realicraft]

scroll_sheet2

[Incendiary]

U

[realicraft]

spoiler

spoiler

[Luigis_Pizza]

spoiler

spoiler

AAA

[Zan]

I think my internet is normal at last

[realicraft]

spoiler

spoiler

AAA

scarier spoiler

boo

[PkmnQ]

spoiler

spoiler

AAA

scarier spoiler

boo

reply to the scarier spoiler, which spoils the scarier spoiler, thus warranting a spoiler

yeah i know them

[PkmnQ]

Code Select Expand

class PolarizedList:
    def __init__(self, polarity=True, content=0):
        self.polarity = polarity
        if type(content) is int:
            self.list = []
            for _ in range(content):
                self.list.append(PolarizedList())
        else:
            self.list = content

    def __eq__(self, other):
        return self.polarity == other.polarity and self.list == other.list
    def __len__(self):
        return len(self.list)
    def __iter__(self):
        return iter(self.list)

    def __neg__(self):
        return PolarizedList(not polarity, content)

    def fuse(self):
        pre_fuse = []
        for i in self:
            separator = i.polarity
            for j in i:
                pre_fuse.append((separator, j))
                separator = None
            if separator is not None:
                pre_fuse.append((separator, None))
        new_list = []
        previous_polarity = None
        for separator, element in pre_fuse:
            if element is None:
                new_list.append(PolarizedList(separator))
                previous_polarity = None
                continue
            if previous_polarity and not element.polarity:
                separator = {True: None, None: False, False: True}[separator]
            if separator is not None:
                new_list.append(PolarizedList(separator))
            new_list[-1].list.append(-element)
        self.list[:] = new_list
    def defuse(self):
        pre_fuse = []
        for i in self:
            separator = i.polarity
            for j in i:
                pre_fuse.append((separator, j))
                separator = None
            if separator is not None:
                pre_fuse.append((separator, None))
        new_list = []
        previous_polarity = None
        for separator, element in pre_fuse:
            if element is None:
                new_list.append(PolarizedList(separator))
                previous_polarity = None
                continue
            if not previous_polarity and element.polarity:
                separator = {False: None, None: True, True: False}[separator]
            if separator is not None:
                new_list.append(PolarizedList(separator))
            new_list[-1].list.append(-element)
        self.list[:] = new_list

    def segmented_transposition(self):
        segments = []
        segment_polarity, segment_length = None, None
        for i in self:
            if segment_polarity != i.polarity or segment_length != len(i):
                segments.append([])
            segments[-1].append(i)
        new_list = []
        previous_length = None
        for i in segments:
            if len(i) == previous_length:
                return
            previous_length = len(i)
            transposed_segment = [[*j] for j in zip(*i)]
            if len(transposed_segment) == 0:
                return
            new_list += transposed_segment
        self.list[:] = new_list
    def ignorant_reversal(self):
        subelements = [sub_i for i in self for sub_i in i]
        re_insert = iter(reversed(subelements))
        for i in self:
            for sub_i, _ in enumerate(i):
                i[sub_i] = next(re_insert)

class Thread:
    def __init__(self, stack, shiny=True, parent=None):
        self.stack = stack
        self.shiny = shiny
        self.__parent = parent
    def parent(self):
        if self.__parent is None:
            self.__parent = Thread(
                [PolarizedList(True, [PolarizedList(True, self.stack)])]
            )
        return self.__parent

    def literal(self, content):
        if len(self.stack) == 0 or self.stack[0] == -content:
            self.stack.pop(0)
        else:
            self.stack.insert(0, content)
    def illiteral(self, content):
        self.literal(-content)

    def fuse(self):
        if self.stack == []:
            return
        self.stack[0].fuse()
    def defuse(self):
        if self.stack == []:
            return
        self.stack[0].defuse()

    def summon(self):
        if len(self.stack) < 3:
            return
        self.stack.insert(0, self.stack.pop(2))
    def banish(self):
        if len(self.stack) < 3:
            return
        self.stack.insert(2, self.stack.pop(0))

    def fork(self):
        if self.stack == [] or (substacks := self.stack[0].list) == []:
            return [Thread([], False)]
        new_threads = []
        for _, stack in substacks:
            new_threads.append(Thread(stack))
        return new_threads
    # spoon is implemented separately

    def hokey(self):
        if self.stack == []:
            return
        self.stack[0].segmented_transposition()
        self.stack[0].ignorant_reversal()
    def cokey(self):
        if self.stack == []:
            return
        self.stack[0].ignorant_reversal()
        self.stack[0].segmented_transposition()

    # double checking these may be wise
    def kitten(self):
        if self.stack == []:
            return
        top = self.stack[0]
        try:
            if top.polarity:
                top.list.insert(0, self.stack.pop(1))
            else:
                self.stack.insert(1, top.list.pop(0))
        except IndexError:
            self.stack[0] = -top
    def antikitten(self):
        if self.stack == []:
            return
        top = self.stack[0]
        try:
            if not top.polarity:
                top.list.insert(0, self.stack.pop(1))
            else:
                self.stack.insert(1, top.list.pop(0))
        except IndexError:
            self.stack[0] = -top
Time to actually test any of this at all