code guessing, round #59 (completed)

# hey, moshikoi. youre finally awake. you can trust me. i know what i'm doing.
# just copy my submissive! or read up on https://esolangs.org/wiki/Stack <3 <3

who = 0;
STACK = [];
p = 0;
KCATS = [];
q = 0;
RAM = {};


def POP() -> int:
   global who, STACK, p, KCATS, q;
   if (who):
      if (not KCATS):
         return 0;
      else:
         q = q - 1;
         return KCATS[q];
   else:
      if (not STACK):
         return 0;
      else:
         p = p - 1;
         return STACK[p];


def PUSH(v: int) -> None:
   global who, STACK, p, KCATS, q;
   if (who):
      if (len(KCATS) > q):
         KCATS[q] = v;
      else:
         KCATS = KCATS + [v];
      q = q + 1;
   else:
      if (len(STACK) > p):
         STACK[p] = v;
      else:
         STACK = STACK + [v];
      p = p + 1;


def READ(i: int) -> int:
   global RAM;
   return RAM.get(i, 0);


def WRITE(i: int, v: int) -> None:
   global RAM;
   RAM[i] = v;


from random import randrange as RAND;
from random import seed as ROUND;
def RECOMB(S: str) -> list[int | tuple[int, str, str]]:
   global who;
   i: int; j: int; c: int; m: int;
   i = 0;
   while (i < len(S)):
      match (S[i]):
         case 's':
            who = 1 - who;
         case 'o':
            who = 0;
         case 'p':
            WRITE(POP(), 0);
         case 'f':
            PUSH(READ(POP()));
         case 'w':
            WRITE(POP(), who);
         case '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' as v:
            PUSH(v - '0');
         case '"':
            j = i + 1;
            while ((d := S[j]) != '"'):
               PUSH(d);
               j = j + 1;
            i = j;
         case '?':
            PUSH(RAND(POP() + 1));
         case '¿':
            ROUND(POP());
         case '+':
            PUSH(POP() + 1);
         case '-':
            PUSH(POP() - 1);
         case '/':
            PUSH(1 / POP() * POP());
         case '*':
            PUSH(POP() * POP() / 1);
         case '%':
            PUSH(-POP() + POP());
         case '<' | '=' | '>' | '&' | '|' as c:
            PUSH(eval(str(POP()) + c + str(POP())));
         case '!':
            WRITE(POP(), POP());
         case '\\':
            c = POP();
            PUSH(c);
         case ':':
            PUSH(POP());
            PUSH(i);
         case '@':
            PUSH(READ(POP()));
         case '#':
            PUSH(0);
         case '.':
            POP();
         case ',':
            PUSH(READ(i));
         case 'î':
            if (POP()):
               PUSH(POP());
               PUSH(i);
         case 'ô':
            if (POP()):
               PUSH(p);
            else:
               PUSH(q);
         case '[':
            c = 1;
            j = i;
            while (c):
               j = j + 1;
               match (S[j]):
                  case '[':
                     c = c + 1;
                  case ']':
                     c = c - 1;
                  case '|':
                     if (c == 1):
                        m = j;
            c = POP();
            while (1):
               RECOMB(S[i + 1:m]);
               if (not POP() or not c):
                  break;
               RECOMB(S[m + 1:j]);
               c = c - 1;
            i = j;
         case '~':
            who = POP() % 2;
         case '§':
            i = -1;
         case _:
            None;
      i = i + 1;


if (__name__ == "__main__"):
   import sys;
   
   ROUND(59);
   
   if (len(sys.argv) - 1):
      RECOMB(sys.argv[1]);
   else:
      RECOMB(input());
   
   print(f"{STACK[:p]}\040\162\145\163\165\154\164\163\040\061\060\060\045\
   \157\146\040\164\150\145\040\164\151\155\145\056\040\040\040\040\040\040");
   #\163\141\156\163\040\165\156\144\145\162\164\141\154\145 look at stripes!
   #/   /   /   /   /   /   /   /   /   /   /   /   /   /   ,_______________
  #/   /   /   /   /   /   /   /   /   /   /   /   /   /   /   /   /   /   |\
#--\___\___\___\___\___\___\___\___\___\___\___\___\___\___\___\___\___\___\/

local function gen_array(n, x)
    local l = {}
    for i=1,n do
        l[i] = x
    end
    return l
end

local function clone_table(original)
    local copy = {}
    for key, value in pairs(original) do
        if type(value) == "table" then
            copy[key] = clone_table(value)
        else
            copy[key] = value
        end
    end
    return copy
end

local function push_table(dest, src)
    for i=1,#src do
        dest[#dest + 1] = src[i]
    end
end

local MAX_DEPTH = 10
local finished_interpreters = {}
local new_interpreters = {}

local function make_interpreter()
    local interpreter = {
        stack = {},
        random_access_memory = gen_array(30000, 0),
        depth = 0,
        bounds = {},
        loops = {},
        idx = 1,
        has_finished = false,
        coe = 1.0,
        code = '',
    }

    function interpreter.pop_stack(i)
        if #i.stack == 0 then
            return 0
        end

        local x = i.stack[#i.stack]
        table.remove(i.stack)
        return x
    end

    function interpreter.push_stack(i, x)
        table.insert(i.stack, x)
    end

    function interpreter.clone(i, upto)
        if i.depth >= MAX_DEPTH then
            return {}
        end

        local clones = {}
        for idx=0,upto do
            local new_interpreter = clone_table(i)
            new_interpreter.depth = i.depth + 1
            new_interpreter.coe = i.coe / (upto + 1)
            new_interpreter:push_stack(idx)
            table.insert(clones, new_interpreter)
        end
        return clones
    end

    function interpreter.step(i)
        if i.has_finished then
            return false
        end
        if i.idx > #i.code or i.depth >= MAX_DEPTH then
            table.insert(finished_interpreters, i)
            i.has_finished = true
            return false
        end

        local chr = string.sub(i.code, i.idx, i.idx)
        i.idx = i.idx + 1

        if chr == '#' then
            i:push_stack(0)
        elseif chr == '+' then
            local x = i:pop_stack()
            i:push_stack(x + 1)
        elseif chr == '@' then
            local address = i:pop_stack() + 1
            i:push_stack(i.random_access_memory[address])
        elseif chr == '!' then
            local address = i:pop_stack() + 1
            local value = i:pop_stack()
            i.random_access_memory[address] = value
        elseif chr == '?' then
            local number = i:pop_stack()
            push_table(new_interpreters, i:clone(number))
            return false
        elseif chr == '[' then
            local bound = i:pop_stack()
            table.insert(i.bounds, bound)
            table.insert(i.loops, i.idx)
        elseif chr == '|' then
            local condition = i:pop_stack()
            if condition == 0 or i.bounds[#i.bounds] == 0 then
                table.remove(i.loops, #i.loops)
                table.remove(i.bounds, #i.bounds)
                local lc = 0
                while true do
                    local char = string.sub(i.code, i.idx, i.idx)
                    if char == '[' then
                        lc = lc + 1
                    elseif char == ']' then
                        if lc == 0 then
                            break
                        end
                        lc = lc - 1
                    end
                    i.idx = i.idx + 1
                end
                i.idx = i.idx + 1
            end
        elseif chr == ']' then
            i.bounds[#i.bounds] = i.bounds[#i.bounds] - 1
            i.idx = i.loops[#i.loops]
        end

        return true
    end
    return interpreter
end


function entry(code)
    local interpreter = make_interpreter()
    interpreter.code = code

    local interpreters = {interpreter}
    finished_interpreters = {}
    new_interpreters = {}

    local stepped = true
    while stepped or #new_interpreters ~= 0 do
        new_interpreters = {}
        stepped = false

        local idx = 1
        while idx <= #interpreters do
            local i = interpreters[idx]
            if i:step() == false then
                table.remove(interpreters, idx)
            else
                stepped = true
                idx = idx + 1
            end
        end

        push_table(interpreters, new_interpreters)
    end

    local outputs = {}

    for _,i in ipairs(finished_interpreters) do
        local top = i:pop_stack()
        if outputs[top] == nil then
            outputs[top] = i.coe
        else
            outputs[top] = outputs[top] + i.coe
        end
    end

    local most_probable_outcomes = {}
    local high = 0

    for k,v in pairs(outputs) do
        if v > high then
            most_probable_outcomes = {k}
            high = v
        elseif v == high then
            table.insert(most_probable_outcomes, k)
        end
    end

    return most_probable_outcomes
end

local function gen_array(n, x)
    local l = {}
    for i=1,n do
        l[i] = x
    end
    return l
end

local function clone_table(original)
    local copy = {}
    for key, value in pairs(original) do
        if type(value) == "table" then
            copy[key] = clone_table(value)
        else
            copy[key] = value
        end
    end
    return copy
end

local interpreter = {
    stack = {},
    random_access_memory = gen_array(30000, 0),

    pop_stack = function (i)
        if #i.stack == 0 then
            return 0
        end
        
        local x = i.stack[#i.stack]
        table.remove(i.stack)
        return x
    end,
    push_stack = function (i, x)
        table.insert(i.stack, x)
    end,
    execute = function (i, stmts)
        for _, v in ipairs(stmts) do
            v:run(i)
        end
    end,
    clone = function (i, upto)
        local clones = {}
        for idx=0,upto do
            local new_interpreter = clone_table(i)
            new_interpreter:push_stack(idx)
            table.insert(clones, new_interpreter)
        end
        return clones
    end
}

local function instruction_new(exec)
    return {
        run = exec,
    }
end

local function loop_new(c, b)
    return {
        cond = c,
        body = b,
        run = function (self, i)
            local bound = i:pop_stack()

            while bound ~= 0 do
                i:execute(self.cond)
                local num = i:pop_stack()

                if num == 0 or bound == 0 then
                    break
                end

                i:execute(self.body)
                bound = bound - 1
            end
        end,
    }
end

local instructions = {
    h = instruction_new(function (_, i)
        i:push_stack(0)
    end),
    p = instruction_new(function (_, i)
        local x = i:pop_stack()
        i:push_stack(x + 1)
    end),
    a = instruction_new(function (_, i)
        local address = i:pop_stack() + 1
        i:push_stack(i.random_access_memory[address])
    end),
    e = instruction_new(function (_, i)
        local address = i:pop_stack() + 1
        local value = i:pop_stack()
        i.random_access_memory[address] = value
    end),
    q = instruction_new(function (_, i)
        local number = i:pop_stack()
        i:push_stack(math.random(number + 1) - 1)
    end),
}

local function parse(code, idx)
    local stmts = {}

    while idx <= #code do
        local char = string.sub(code, idx, idx)

        if char == '#' then
            table.insert(stmts, instructions.h)
        elseif char == '+' then
            table.insert(stmts, instructions.p)
        elseif char == '@' then
            table.insert(stmts, instructions.a)
        elseif char == '!' then
            table.insert(stmts, instructions.e)
        elseif char == '?' then
            table.insert(stmts, instructions.q)
        elseif char == '|' or char == ']' then
            return stmts, idx
        elseif char == '[' then
            local body
            local condition

            condition, idx = parse(code, idx + 1)
            char = string.sub(code, idx, idx)

            if char ~= '|' then
                print("Expected '|', got '"..char.."'")
                os.exit(1)
            end

            body, idx = parse(code, idx + 1)
            char = string.sub(code, idx, idx)
            if char ~= ']' then
                print("Expected ']', got '"..char.."'")
                os.exit(1)
            end
            table.insert(stmts, loop_new(condition, body))
        end
        idx = idx + 1
    end

    return stmts, idx
end

function entry(code)
    local parsed = parse(code, 1)

    local N = 10000
    local dict = {}
    for _=1,N do
        interpreter:execute(parsed)

        local outcome = interpreter:pop_stack()
        if dict[outcome] == nil then
            dict[outcome] = 1
        else
            dict[outcome] = dict[outcome] + 1
        end
    end

    local max = 0
    local max_k = 0
    for k,v in pairs(dict) do
        if v > max then
            max_k = k
            max = v
        end
    end

    return max_k
end

def encourage(bottom, pleading=[]):
    bottom = [squirm for squirm in bottom]

    def lap(top):
        try:
            top.hard.append (
                top.soft [
                    top.hard.pop()])
        except (IndexError, KeyError):
            reduce(0)

    def reduce(item):
        item.hard.append(0)

    def induce(current):
        try:
            golden = current.hard.pop()
        except IndexError:
            golden = 0
        try:
            retriever = current.hard.pop()
        except IndexError:
            retriever = 0
        current.soft [
            golden ]= retriever

    def seduce(victim):
        try:
            victim.hard.append (
                victim.hard.pop() + 1)
        except IndexError:
            victim.hard.append(1)

    def deduce(crime):
        try:
            crime.hard.append (
                crime.random (
                    crime.hard.pop()))
        except IndexError:
            crime.hard.append(0)
            return

    def genetic(spawn):
        try:
            insistence = spawn.hard.pop()
        except IndexError:
            insistence = 0
        spawn.crows.append(insistence)

    def stochastic(crow):
        relativity = crow.monads [
            crow.monadic]
        crow.monadic = crow.monadic + 1
        try:
            questionable = crow.hard.pop()
        except IndexError:
            questionable = 0
        try:
            dogmatic = crow.crows[-1:][0]
            sabotage = 42
            sabotage /= questionable
            sabotage /= dogmatic
        except ZeroDivisionError:
            crow.monadic = relativity
            crow.crows.pop()

    def deterministic(pickle):
        relativity = pickle.monads [
            pickle.monadic]
        pickle.monadic = relativity
        pickle.crows.append (
            pickle.crows.pop() - 1)

    class constructor:
        genetic = None
        stochastic = None
        deterministic = None

    clone = __import__("copy").deepcopy
    copy = __import__("copy").copy

    class objection:
        soft = {}
        hard = []
        crows = []
        monads = []
        monadic = 0
        constructural = []
        random = None
        def __deepcopy__(self, memo):
            obj = objection()
            obj.monads = self.monads
            obj.monadic = self.monadic
            obj.random = self.random
            obj.hard = clone(self.hard,memo)
            obj.soft = clone(self.soft,memo)
            obj.crows = clone(self.crows,memo)
            return obj

    def std__forward_inserter(iterator,iterant,functor):
        def fungus(objection):
            objection.monads.append(functor)
        iterator[iterant] = fungus

    def std__genetic_inserter(iterator,iterant):
        def fungus(objection):
            const = constructor()
            const.genetic = len(objection.monads)
            objection.constructural.append(const)
            objection.monads.append(genetic)
        iterator[iterant] = fungus

    def std__stochastic_inserter(iterator,iterant):
        def fungus(objection):
            const = objection.constructural[-1:][0]
            const.stochastic = (len(objection.monads)
                if const.stochastic == None
                else 1/0)
            objection.monads.append(stochastic)
            objection.monads.append(None)
        iterator[iterant] = fungus

    def std__deterministic_inserter(iterator,iterant):
        def fungus(objection):
            const = objection.constructural.pop()
            const.deterministic = len(objection.monads)
            objection.monads [
                const.stochastic + 1 ]= const.deterministic + 2
            objection.monads.append(deterministic)
            objection.monads.append(const.genetic + 1)
        iterator[iterant] = fungus

    npcs = {}
    std__forward_inserter(npcs,"@",lap)
    std__forward_inserter(npcs,"#",reduce)
    std__forward_inserter(npcs,"!",induce)
    std__forward_inserter(npcs,"+",seduce)
    std__forward_inserter(npcs,"?",deduce)
    std__genetic_inserter(npcs,"[")
    std__stochastic_inserter(npcs,"|")
    std__deterministic_inserter(npcs,"]")

    world = objection()
    for sans_undertale in bottom:
        try:
            excited = npcs[sans_undertale]
        except:
            continue
        excited(objection)

    outputs = {}

    def excite(objection):
        while objection.monadic < len(objection.monads):
            monad = objection.monads[objection.monadic]
            if monad == deduce and objection.random == None:
                for i in range(0,([0] + objection.hard[-1:]).pop() + 1):
                    __objection__ = clone(objection)
                    def random(n):
                        return i
                    __objection__.random = random
                    excite(__objection__)
                return
            objection.monadic = objection.monadic + 1
            monad(objection)
            objection.random = None
        output = tuple(objection.hard)
        outputs[output] = (outputs.get(output) or 0) + 1

    world.hard = clone(pleading)
    excite(world)

    return list(sorted(outputs.items(), key=lambda key:key[1]).pop()[0])

#include <algorithm>
#include <format>
#include <iostream>
#include <map>
#include <numeric>
#include <print>
#include <ranges>
#include <stack>
#include <string>
#include <string_view>
#include <vector>

class Interpreter {
  std::reference_wrapper<std::vector<Interpreter>> _interpreters;

  std::stack<int> _stack;
  std::stack<std::size_t> _reps;
  std::stack<std::size_t> _jmps;
  std::size_t _ic = 0;
  bool _finished = false;
  double _weight = 0.0;
  std::string_view _code;

  std::vector<int> _memory;

public:
  Interpreter(std::vector<Interpreter> &interpreters, std::string_view code)
      : _interpreters{interpreters}, _code{code}, _memory(0xffffff) {}

  int pop() {
    if (_stack.empty()) {
      return 0;
    }
    auto const value = _stack.top();
    _stack.pop();
    return value;
  }

  bool step() {
    if (_ic >= _code.length()) {
      return false;
    }

    char const ch = _code[_ic++];
    switch (ch) {
    case '#':
      _stack.push(0);
      break;
    case '+':
      ++_stack.top();
      break;
    case '@': {
      auto const address = pop();
      _stack.push(_memory[address]);
      break;
    }
    case '!': {
      auto const address = pop();
      auto const value = pop();
      _memory[address] = value;
      break;
    }
    case '?': {
      auto const value = pop();
      _interpreters.get().append_range(make_copies(value));
      break;
    }
    case '[': {
      auto const value = _stack.top();
      _reps.push(value);
      _jmps.push(_ic);
      break;
    }
    case ']':
      --_reps.top();
      _ic = _jmps.top();
      break;
    case '|': {
      auto const value = _stack.top();
      if (value == 0 or _reps.top() == 0) {
        _reps.pop();
        _jmps.pop();
        int braces = 1;

        while (true) {
          if (_code[_ic] == '[') {
            ++braces;
          } else if (_code[_ic] == ']') {
            if (braces == 0) {
              break;
            } else {
              --braces;
            }
          }
          ++_ic;
        }
        ++_ic;
      }
    }
    default:
      throw std::runtime_error(std::format("Invalid character {}", ch));
    }
    return true;
  }

  std::vector<Interpreter> make_copies(int n) {
    return to<std::vector>(std::ranges::views::iota(n) |
                           std::ranges::views::transform([&](auto i) {
                             auto copy = *this;
                             copy._weight = _weight / (n + 1);
                             copy._stack.push(_ic);
                             return copy;
                           }));
  }

  double weight() { return _weight; }
};

int interpret(std::string_view code) {
  std::vector<Interpreter> interpreters;
  std::vector<Interpreter> finished_interpreters;

  interpreters.emplace_back(interpreters, code);

  while (not interpreters.empty()) {
    for (int i = 0; i < interpreters.size();) {
      if (not interpreters[i].step()) {
        finished_interpreters.push_back(interpreters[i]);
        interpreters.erase(interpreters.begin() + i);
      } else {
        ++i;
      }
    }
  }

  std::map<int, double> outputs;
  for (auto &&interpreter : finished_interpreters) {
    outputs[interpreter.pop()] += interpreter.weight();
  }

  return std::ranges::max_element(
             outputs, [](auto &p1, auto &p2) { return p1.second < p2.second; })
      ->first;
}

int main() {
  std::string line;
  std::getline(std::cin, line);
  std::println("{"
               "}",
               interpret(line));
}

#!/usr/bin/env -S jq -Rrf

def parse: [
  scan("(?<r>[#+@!?]|\\[((?&r)*)\\|((?&r)*)])") |
  if .[1] != null then {cond: .[1] | parse, body: .[2] | parse}
  else .[0]
  end
];

def new_state: {
    stack: [],
    memory: {},
};

def ensure_height($height):
  .stack |= [range([$height - (. | length), 0] | max) | 0] + .
;

def gcd($a; $b): if $b == 0 then $a else gcd($b; $a % $b) end;
def lcm($a; $b): $a * $b / gcd($a; $b);
def lcm: reduce .[] as $n (1; lcm(.; $n));

def probpipe(x; y):
  [x | [y]] | (map(length) | lcm) as $l |
  .[] as $p | range($l / ($p | length)) | $p[]
;

def for($vals; filter):
  if ($vals | length) == 0 then .
  else {val: $vals[0], state: .} | filter | for(vals[1:]; filter)
  end
;

def eval($code):
  def do_loop($bound; $loop): probpipe(
    eval($loop.cond);
    ensure_height(1) | .stack[-1] as $cond | del(.stack[-1]) |
    if $bound != 0 and $cond != 0 then
      eval($loop.body) | do_loop($bound - 1; $loop)
    end
  );

  for($code; . as {$val, $state} | $state |
    if $val == "#" then
      .stack += [0]
    elif $val == "+" then
      ensure_height(1) | .stack[-1] += 1
    elif $val == "@" then
      ensure_height(1) | .stack[-1] = .memory[.stack[-1] | tostring]
    elif $val == "!" then
      ensure_height(2) |
      .memory[.stack[-1] | tostring] = .stack[-2] |
      del(.stack[-1, -2])
    elif $val == "?" then
      ensure_height(1) |
      range(.stack[-1] + 1) as $n | .stack[-1] = $n
    else
      ensure_height(1) |
      .stack[-1] as $bound | del(.stack[-1]) | do_loop($bound; $val)
    end
  )
;

def run:
  parse as $code | new_state | eval($code) |
  ensure_height(1).stack[-1] | tostring
;

def most_frequent:
  reduce .[] as $k ({}; .[$k] += 1) | to_entries | max_by(.value).key
;

[run] | most_frequent

// the extension time is almost gone, and i don't have anymore time to work on this (im going to a concert!)
// so i can't work on this anymore. so, i'm submitting an unfinished copy of this.
// i really am sorry about it being unfinished, but i don't have much of a choice here: it's either participate or don't,
// and i really do want to participate.

// P.S. compile with       g++ kimapr.c -fpermissive -lgmp
//      IF  :   you dont have obstack
//      THEN:   add obstack.c to the g++ command.


/* DONE:
    all of the trivial shit
*/

/* TODO:
    fix all of the FIXME list
    add randomi[zs]ation for probablistic-ization of PricK
*/

/* FIXME:
    conditionals are fucked
    like really really fucked
*/

/*
The author of this file IS NOT one of the following people:
 lyricly
 razetime
 r. "essaie" sa
 olive
 olus "olly" 2000
 olivia
 IFcoltransG
 sofia
 kotnen
 zptr yui
 mark
 palailogos
 at (DataKinds)

The author of this file IS one of the following people:
 GNU Radio Shows
 seshoumara

Impersonating people who aren't even playing is fun. Maybe next time i'll impersonate someone else.
*/



#if __has_include(<obstack.h>)
# include <obstack.h>
#else
# include "obstack.h"
#endif


static struct flags
{
    int helpinfo, versions;
    char*verb,*post,*p, sn;
} flgs;

#include <unordered_map>

#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
static int c, i, v, n;
void parseopt(int argc, char *const argv[])
{
    static const struct option lopts[] = {
        {"help",     no_argument,       &flgs.helpinfo, 1},
        {"version",  no_argument,       &flgs.versions, 1},
        {"before",   required_argument, 0,              'b'},
        {"after",    required_argument, 0,              'a'},
        {"command",  required_argument, 0,              'c'},
        {0,          0,                 0,              0},
    };
    while((c = getopt_long(argc, argv, "hHvVc:C:b:B:a:A:",
                           lopts, &i)) != -1){
        switch(c) {
        case '?':
            printf("use --help\n");
        case 0:
            break;
        case 'h': case 'H':
            flgs.helpinfo = 1;
            break;
        case 'v': case 'V':
            flgs.versions = 1;
            break;
        case 'c': case 'C':
            flgs.p=optarg;
            flgs.sn=1;
            break;
        case 'b': case 'B':
            flgs.verb=optarg;
            break;
        case 'a': case 'A':
            flgs.post=optarg;
            break;
        }
    }
    if (optind < argc){
        if (flgs.p||++optind<argc) {
            printf("%s: unexpected positional argument -- %s",
                   argv[0], argv[optind]);
            exit(-1);
        }
        flgs.p = argv[--optind];
    }
}



#include <string.h>
#include <stack>
char *E;
int exc(char*e){strcpy((E=realloc(E,(n+=(i=strlen(e)))+1))+n-i,e);}



#if __has_include(<gmp.h>)
# include <gmp.h>
#else
# error what the SIGMA?!you promised me gmplib!
#endif
int rnc();
static struct Ss{
    struct obstack ostcak{};
    std::stack<int> stcak{};
    std::unordered_map<int,int> arm{}; // sparse memory representation
} *stk;
#define MPZ_POP(n)\
if(cr.stcak.empty())mpz_init(n); \
else (mpz_init_set_ui(n,cr.stcak.top()),cr.stcak.pop());
#define MPZ_MEM(n, a)\
if(!cr.arm.count(mpz_get_ui(a)))mpz_init(n); \
else mpz_init_set_ui(n,cr.arm[mpz_get_ui(a)]);
#ifdef useobskcatk
#define OBJECTSTAKDFLK\
obstack_init(&cr.ostcak);obstack_free(&cr.ostcak, NULL);
#else
#define OBJECTSTAKDFLK
#endif
#define FALL \
for(c = 0; c < v; c++){struct Ss& cr = stk[c];OBJECTSTAKDFLK
int cond(){
    struct Ss& cr = stk[c];
    i++;
    int I=i;
    int J=i;
    int bal=1;
    for(;bal;J++){
        bal += E[J] == '[';
        bal -= E[J] == ']';
    };
    mpz_t b; MPZ_POP(b);
    while (1){
        while(E[i]!='|')
            rnc();
        mpz_t N; MPZ_POP(N);
        if (mpz_cmp_ui(N, 0) && mpz_cmp_ui(b, 0)){
            while(E[i]!=']')
                rnc();
        } else break;
        i=I;
    }
    i=J;
}
int rnc(){
    printf("%d %c\n", E[i], E[i]);
switch(E[i]){
case '#':
    FALL;cr.stcak.push(0);};
break;case '+':
    FALL;mpz_t t;MPZ_POP(t);mpz_add_ui(t, t, 1);
   cr.stcak.push(mpz_get_ui(t));mpz_clear(t);};
break;case '@':
    FALL;mpz_t s,m;MPZ_POP(s);MPZ_MEM(m,s);mpz_clear(s);
   cr.stcak.push(mpz_get_ui(m));mpz_clear(m);};break;
case '!':
    FALL;mpz_t a,V;MPZ_POP(a);MPZ_POP(V);
   cr.arm[mpz_get_ui(a)]=mpz_get_ui(V);
   mpz_clear(a);mpz_clear(V);};
break;case '[':cond();
break;case '|':case ']':i++;return;
break;case '?':
break;default:
    printf("bad syntax. %s",
           "see --help output for more information.\n");
exit(-1);
};i++;}
int cleanup() {for (; i < n-1 && E[i];)rnc();
FALL;printf("%d\n", cr.stcak.top());};
}

int main(int argc, char* argv[]) {
    parseopt(argc, argv); v++;
    if (flgs.helpinfo)
        printf("lol no, just read the source code\n"), exit(-1);
    if (flgs.versions)
        printf("%s v6.9\n", argv[0]),                  exit(-1);
    stk = (struct Ss *)calloc(v, sizeof(struct Ss));
    stk[0] = Ss{};
    E = (char *)malloc(n=0);
    if (flgs.verb) exc(flgs.verb);
    if (flgs.sn)   exc(flgs.p);
    else {
        FILE* f = flgs.p ? fopen(flgs.p, "r") : stdin;
        while ((c = getc(f)) != EOF) exc((char *)&c);
    }
    if (flgs.post) exc(flgs.post);
    i=0;cleanup();
}

/* obstack.c - subroutines used implicitly by object stack macros
   Copyright (C) 1988-2024 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   This file is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as
   published by the Free Software Foundation, either version 3 of the
   License, or (at your option) any later version.

   This file is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */


#ifdef _LIBC
# include <obstack.h>
#else
//# include <config.h>
# include "obstack.h"
#endif

/* NOTE BEFORE MODIFYING THIS FILE IN GNU LIBC: _OBSTACK_INTERFACE_VERSION in
   gnu-versions.h must be incremented whenever callers compiled using an old
   obstack.h can no longer properly call the functions in this file.  */

/* If GCC, or if an oddball (testing?) host that #defines __alignof__,
   use the already-supplied __alignof__.  Otherwise, this must be Gnulib
   (as glibc assumes GCC); defer to Gnulib's alignof_type.  */
#if !defined __GNUC__ && !defined __alignof__
# include <alignof.h>
# define __alignof__(type) alignof_type (type)
#endif
#include <stdlib.h>
#include <stdint.h>

#ifndef MAX
# define MAX(a,b) ((a) > (b) ? (a) : (b))
#endif

/* Determine default alignment.  */

/* If malloc were really smart, it would round addresses to DEFAULT_ALIGNMENT.
   But in fact it might be less smart and round addresses to as much as
   DEFAULT_ROUNDING.  So we prepare for it to do that.

   DEFAULT_ALIGNMENT cannot be an enum constant; see gnulib's alignof.h.  */
#define DEFAULT_ALIGNMENT MAX (__alignof__ (long double),		      \
                               MAX (__alignof__ (uintmax_t),		      \
                                    __alignof__ (void *)))
#define DEFAULT_ROUNDING MAX (sizeof (long double),			      \
                               MAX (sizeof (uintmax_t),			      \
                                    sizeof (void *)))

/* Call functions with either the traditional malloc/free calling
   interface, or the mmalloc/mfree interface (that adds an extra first
   argument), based on the value of use_extra_arg.  */

static void *
call_chunkfun (struct obstack *h, size_t size)
{
  if (h->use_extra_arg)
    return h->chunkfun.extra (h->extra_arg, size);
  else
    return h->chunkfun.plain (size);
}

static void
call_freefun (struct obstack *h, void *old_chunk)
{
  if (h->use_extra_arg)
    h->freefun.extra (h->extra_arg, old_chunk);
  else
    h->freefun.plain (old_chunk);
}


/* Initialize an obstack H for use.  Specify chunk size SIZE (0 means default).
   Objects start on multiples of ALIGNMENT (0 means use default).

   Return nonzero if successful, calls obstack_alloc_failed_handler if
   allocation fails.  */

static int
_obstack_begin_worker (struct obstack *h,
                       _OBSTACK_SIZE_T size, _OBSTACK_SIZE_T alignment)
{
  struct _obstack_chunk *chunk; /* points to new chunk */

  if (alignment == 0)
    alignment = DEFAULT_ALIGNMENT;
  if (size == 0)
    /* Default size is what GNU malloc can fit in a 4096-byte block.  */
    {
      /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc.
         Use the values for range checking, because if range checking is off,
         the extra bytes won't be missed terribly, but if range checking is on
         and we used a larger request, a whole extra 4096 bytes would be
         allocated.

         These number are irrelevant to the new GNU malloc.  I suspect it is
         less sensitive to the size of the request.  */
      int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1))
                    + 4 + DEFAULT_ROUNDING - 1)
                   & ~(DEFAULT_ROUNDING - 1));
      size = 4096 - extra;
    }

  h->chunk_size = size;
  h->alignment_mask = alignment - 1;

  chunk = h->chunk = call_chunkfun (h, h->chunk_size);
  if (!chunk)
    (*obstack_alloc_failed_handler) ();
  h->next_free = h->object_base = __PTR_ALIGN ((char *) chunk, chunk->contents,
                                               alignment - 1);
  h->chunk_limit = chunk->limit = (char *) chunk + h->chunk_size;
  chunk->prev = 0;
  /* The initial chunk now contains no empty object.  */
  h->maybe_empty_object = 0;
  h->alloc_failed = 0;
  return 1;
}

int
_obstack_begin (struct obstack *h,
                _OBSTACK_SIZE_T size, _OBSTACK_SIZE_T alignment,
                void *(*chunkfun) (size_t),
                void (*freefun) (void *))
{
  h->chunkfun.plain = chunkfun;
  h->freefun.plain = freefun;
  h->use_extra_arg = 0;
  return _obstack_begin_worker (h, size, alignment);
}

int
_obstack_begin_1 (struct obstack *h,
                  _OBSTACK_SIZE_T size, _OBSTACK_SIZE_T alignment,
                  void *(*chunkfun) (void *, size_t),
                  void (*freefun) (void *, void *),
                  void *arg)
{
  h->chunkfun.extra = chunkfun;
  h->freefun.extra = freefun;
  h->extra_arg = arg;
  h->use_extra_arg = 1;
  return _obstack_begin_worker (h, size, alignment);
}

/* Allocate a new current chunk for the obstack *H
   on the assumption that LENGTH bytes need to be added
   to the current object, or a new object of length LENGTH allocated.
   Copies any partial object from the end of the old chunk
   to the beginning of the new one.  */

void
_obstack_newchunk (struct obstack *h, _OBSTACK_SIZE_T length)
{
  struct _obstack_chunk *old_chunk = h->chunk;
  struct _obstack_chunk *new_chunk = 0;
  size_t obj_size = h->next_free - h->object_base;
  char *object_base;

  /* Compute size for new chunk.  */
  size_t sum1 = obj_size + length;
  size_t sum2 = sum1 + h->alignment_mask;
  size_t new_size = sum2 + (obj_size >> 3) + 100;
  if (new_size < sum2)
    new_size = sum2;
  if (new_size < h->chunk_size)
    new_size = h->chunk_size;

  /* Allocate and initialize the new chunk.  */
  if (obj_size <= sum1 && sum1 <= sum2)
    new_chunk = call_chunkfun (h, new_size);
  if (!new_chunk)
    (*obstack_alloc_failed_handler)();
  h->chunk = new_chunk;
  new_chunk->prev = old_chunk;
  new_chunk->limit = h->chunk_limit = (char *) new_chunk + new_size;

  /* Compute an aligned object_base in the new chunk */
  object_base =
    __PTR_ALIGN ((char *) new_chunk, new_chunk->contents, h->alignment_mask);

  /* Move the existing object to the new chunk.  */
  memcpy (object_base, h->object_base, obj_size);

  /* If the object just copied was the only data in OLD_CHUNK,
     free that chunk and remove it from the chain.
     But not if that chunk might contain an empty object.  */
  if (!h->maybe_empty_object
      && (h->object_base
          == __PTR_ALIGN ((char *) old_chunk, old_chunk->contents,
                          h->alignment_mask)))
    {
      new_chunk->prev = old_chunk->prev;
      call_freefun (h, old_chunk);
    }

  h->object_base = object_base;
  h->next_free = h->object_base + obj_size;
  /* The new chunk certainly contains no empty object yet.  */
  h->maybe_empty_object = 0;
}

/* Return nonzero if object OBJ has been allocated from obstack H.
   This is here for debugging.
   If you use it in a program, you are probably losing.  */

/* Suppress -Wmissing-prototypes warning.  We don't want to declare this in
   obstack.h because it is just for debugging.  */
int _obstack_allocated_p (struct obstack *h, void *obj) __attribute_pure__;

int
_obstack_allocated_p (struct obstack *h, void *obj)
{
  struct _obstack_chunk *lp;    /* below addr of any objects in this chunk */
  struct _obstack_chunk *plp;   /* point to previous chunk if any */

  lp = (h)->chunk;
  /* We use >= rather than > since the object cannot be exactly at
     the beginning of the chunk but might be an empty object exactly
     at the end of an adjacent chunk.  */
  while (lp != 0 && ((void *) lp >= obj || (void *) (lp)->limit < obj))
    {
      plp = lp->prev;
      lp = plp;
    }
  return lp != 0;
}

/* Free objects in obstack H, including OBJ and everything allocate
   more recently than OBJ.  If OBJ is zero, free everything in H.  */

void
_obstack_free (struct obstack *h, void *obj)
{
  struct _obstack_chunk *lp;    /* below addr of any objects in this chunk */
  struct _obstack_chunk *plp;   /* point to previous chunk if any */

  lp = h->chunk;
  /* We use >= because there cannot be an object at the beginning of a chunk.
     But there can be an empty object at that address
     at the end of another chunk.  */
  while (lp != 0 && ((void *) lp >= obj || (void *) (lp)->limit < obj))
    {
      plp = lp->prev;
      call_freefun (h, lp);
      lp = plp;
      /* If we switch chunks, we can't tell whether the new current
         chunk contains an empty object, so assume that it may.  */
      h->maybe_empty_object = 1;
    }
  if (lp)
    {
      h->object_base = h->next_free = (char *) (obj);
      h->chunk_limit = lp->limit;
      h->chunk = lp;
    }
  else if (obj != 0)
    /* obj is not in any of the chunks! */
    abort ();
}

_OBSTACK_SIZE_T
_obstack_memory_used (struct obstack *h)
{
  struct _obstack_chunk *lp;
  _OBSTACK_SIZE_T nbytes = 0;

  for (lp = h->chunk; lp != 0; lp = lp->prev)
    {
      nbytes += lp->limit - (char *) lp;
    }
  return nbytes;
}

#ifndef _OBSTACK_NO_ERROR_HANDLER
/* Define the error handler.  */
# include <stdio.h>

/* Exit value used when 'print_and_abort' is used.  */
int obstack_exit_failure = EXIT_FAILURE;


static __attribute_noreturn__ void
print_and_abort (void)
{
  /* Don't change any of these strings.  Yes, it would be possible to add
     the newline to the string and use fputs or so.  But this must not
     happen because the "memory exhausted" message appears in other places
     like this and the translation should be reused instead of creating
     a very similar string which requires a separate translation.  */
  fprintf (stderr, "%s\n", "memory exhausted");
  exit (obstack_exit_failure);
}

/* The functions allocating more room by calling 'obstack_chunk_alloc'
   jump to the handler pointed to by 'obstack_alloc_failed_handler'.
   This can be set to a user defined function which should either
   abort gracefully or use longjump - but shouldn't return.  This
   variable by default points to the internal function
   'print_and_abort'.  */
__attribute_noreturn__ void (*obstack_alloc_failed_handler) (void)
  = print_and_abort;
#endif /* !_OBSTACK_NO_ERROR_HANDLER */