Olive's stats

entry=len

(*
  An implementation of a FALSE variant by OliveIsAWord in MiniML:
  https://github.com/pithlessly/miniml
  
  To run MiniML, please ask me or GnuRadioShows for an unvetted Scheme file
  with which to execute this program and/or bootstrap the compiler (or just
  adapt this code to the ML of your choice :3).
  
  This implementation is, by some metrics, performant. On my computer with an
  AMD Ryzen 7 5800X 8-Core Processor, the following program takes ~18 seconds
  to execute:
  ```false
  [$ 1 > [1- $ f;! \ 1- f;! +]?]f:
  33 f;! . {compute & print 33th fibonacci number}
  ```
  
  This program requires the files "olive.false" and "olive.stdin" in the cwd.
*)

let source_code_filepath = "olive.false"
let stdin_filepath = "olive.stdin"

let false_true = 0 - 1
let false_false = 0
let bit_width = 32

let index_of_var c: int = int_of_char c - int_of_char 'a'
let var_of_index i: char = char_of_int (i + int_of_char 'a')

let false_parse_error msg =
  prerr_endline ("FALSE parse error: " ^ msg);
  exit 1  

let false_eval_error msg =
  prerr_endline ("FALSE eval error: " ^ msg);
  exit 1

let internal_panic msg =
  prerr_endline ("internal error: " ^ msg);
  prerr_endline "ya girlie olive screwed up :pleading_face:";
  exit 1
  
let _todo () = internal_panic "todo"

let xor a b = match (a, b) with
| (true, true) | (false, false) -> false
| _ -> true

let (--) i j = 
    let rec aux n acc =
      if n < i then acc else aux (n-1) (n :: acc)
    in aux (j - 1) []
    
let rec list_find elem list = match list with
| [] -> false
| x :: xs -> if x = elem then true else list_find elem xs
 
let rec list_get list i = match list with
| [] -> false_eval_error "stack_underflow"
| x :: xs -> if i = 0 then x else list_get xs (i - 1)

let list_take list n =
  let rec aux list n acc = if n = 0 then (acc, list) else match list with
  | [] -> false_eval_error "stack_underflow"
  | x :: xs -> aux xs (n - 1) (x :: acc)
  in aux list n []

let get_or str i =
  if i < String.length str then Some (String.get str i) else None
  
let option_map_or f default x = match x with
| Some x -> f x
| None -> default

let option_unwrap_or_else f x = match x with
| Some x -> x
| None -> f ()
    
let rec do_n n f =
  if n > 0 then f (); do_n (n - 1) f else ()
  
let rec while condition body =
  if condition () then body (); while condition body else ()

let sign x = x < 0
let flip_sign_if b x = if b then 0 - x else x
let abs x = flip_sign_if (sign x) x

let mul x y =
  let product = ref 0 in
  let (a, b) = if abs x < abs y then (x, y) else (y, x) in
  do_n (abs a) (fun () -> product := (b + deref product));
  let mag = deref product in
  flip_sign_if (sign a) mag
  
let pow base power =
  let value = ref 1 in
  do_n power (fun () -> value := (mul base (deref value)));
  deref value

let div divisor dividend =
  if divisor = 0 then
   false_eval_error (
      "division by zero: " ^
      string_of_int dividend ^
      " / " ^
      string_of_int divisor)
  else ();
  let x = ref (abs dividend) in
  let y = abs divisor in
  let mag = ref 0 in
  while (fun () -> deref x >= y) (fun () ->
    x := (deref x - y);
    mag := (deref mag + 1)
  );
  flip_sign_if (xor (sign dividend) (sign divisor)) (deref mag)

let int_cap = pow 2 bit_width
let signed_cap = pow 2 (bit_width - 1)
  
let bits_of_int i: bool list = 
  let i = if i >= 0 then i else int_cap - i in
  snd (List.fold_right (fun bit (x, acc) ->
    let mask = pow 2 bit in
    let new_bit = x >= mask in
    let new_x = if new_bit then x - mask else x in
    (new_x, new_bit :: acc)
  ) (0 -- bit_width) (i, []))

let int_of_bits bs: int =
  List.fold_right (fun bit n ->
    let bit = if bit then 1 else 0 in
    n + n + bit
  ) bs 0
  
let string_of_bits bs: string =
  String.concat "" (List.map (fun b -> if b then "1" else "0") bs)

let wrap_int i: int =
  let rec wrap_neg i = if i >= 0 then i else wrap_neg (i + int_cap) in
  let rec wrap_pos i = if i < signed_cap then i else wrap_pos (i - int_cap) in
  wrap_pos (wrap_neg i)
  
let string_of_char = String.make 1
  
let char_list_of_string str =
  let indices: int list = 0 -- String.length str in
  (List.map) (String.get str) indices
  
type token =
| PushInt of int
| PushChar of int
| PrintString of string
| PushQuote of token list
| PushVar of int
| Instruction of char

let rec string_of_token_partial token int_prev = match token with
| PushInt i -> (if int_prev then " " else "") ^ string_of_int i
| PushChar i -> "'" ^ string_of_char (char_of_int i)
| PrintString s -> "\"" ^ s ^ "\""
| PushQuote tokens -> string_of_quote tokens
| PushVar v -> string_of_char (var_of_index v)
| Instruction c -> string_of_char c
and string_of_token token = string_of_token_partial token false
and string_of_tokens tokens = 
  let rec aux acc int_prev tokens = match tokens with
  | [] -> acc
  | x :: xs ->
    let to_str = string_of_token_partial x int_prev in
    let is_int = match x with | PushInt _ -> true | _ -> false 
    in aux (to_str :: acc) is_int xs
  in String.concat "" (List.rev (aux [] false tokens))
and string_of_quote tokens = "[" ^ string_of_tokens tokens ^ "]"

type value =
| Int of int
| Ref of int
| Quote of token list

let string_of_value value = match value with
| Int i -> string_of_int i
| Ref v -> string_of_char (var_of_index v)
| Quote q -> string_of_quote q

let bad_type expected value = false_eval_error (
  "expected type " ^ 
  expected ^ 
  ", found " ^
  string_of_value value)

let read_to_string filepath =
  let f = In_channel.open_text filepath in
  let text = In_channel.input_all f in
  In_channel.close f;
  text

let src = read_to_string source_code_filepath
let stdin = ref (char_list_of_string (read_to_string stdin_filepath))
let stdout = ref []
let stack = ref []

let pop (* :flushed: *) () = match deref stack with
| [] -> false_eval_error "stack underflow"
| x :: xs -> stack := xs; x
let pop_int () = match pop () with
| Int a -> a
| x -> bad_type "int" x
let pop_ref () = match pop () with
| Ref a -> a
| x -> bad_type "variable reference" x
let pop_quote () = match pop () with
| Quote a -> a
| x -> bad_type "quote" x
let pop_bool () = pop_int () <> false_false

let push x = stack := (x :: deref stack)

let stack_debug () =
  let reprs = List.map string_of_value (deref stack) in
  let ordered = List.rev reprs in
  let pretty = "(" ^ String.concat ", " ordered ^ ")" in
  print_endline pretty

let stack_index i =
  if i < 0 then
   false_eval_error ("executed `O` with negative index" ^ string_of_int i)
  else ();
  list_get (deref stack) i

let stack_manip n map =
  let (top, rest): (value list * value list) = list_take (deref stack) n in
  let new_top = List.fold_left (fun acc i ->
    let index = n - 1 - (int_of_string (String.sub map i 1)) in
    let elem = list_get top index in
    elem :: acc
  ) [] (0 -- String.length map) in
  stack := (new_top @ rest)

let int1 f =
  let x = pop_int () in
  push (Int (wrap_int (f x)))

let int2 f =
  let rhs = pop_int () in
  let lhs = pop_int () in
  push (Int (wrap_int (f lhs rhs)))

let bitwise2 f =
  let rhs = bits_of_int (pop_int ()) in
  let lhs = bits_of_int (pop_int ()) in
  push (Int (int_of_bits (List.map2 f lhs rhs)))

let push_digits str = stack := (Int (int_of_string str) :: deref stack)

let false_print str = stdout := (str :: deref stdout)

let is_digit c = Char.('0' <= c && c <= '9')
let is_var c = Char.('a' <= c && c <= 'z')
let is_instruction c =
  let instructions = char_list_of_string (";:$%\\@O+-*/_&|~=>!?#^,.B" ^ "Q")
  in list_find c instructions 

let variable_map: value option ref list = List.map (fun _ -> ref None) (0 -- 26)
  
let get_var i = match deref (list_get variable_map i) with
| Some value -> value
| None -> false_eval_error (
  "accessed uninitialized variable " ^
  string_of_char (var_of_index i))
let set_var var v =
  let target = var in
  let i = ref (0 - 1) in
  List.iter
    (fun var_ref ->
      i := (deref i) + 1;
      if deref i = target then var_ref := Some v else ())
    variable_map
let lex str: token list =
  let rec lex_partial str: (token list) * (string option) =
    let rec aux acc str =
      let skip i = String.sub str i (String.length str - i) in
      if String.length str = 0 then
        (acc, None)
      else match String.get str 0 with
      | ' ' | '\n' | '\r' -> aux acc (skip 1)
      | '{' ->
        let i = ref 1 in
        while (fun () -> option_map_or
          (fun x -> x <> '}')
          false
          (get_or str (deref i)))
            (fun () -> i := (deref i + 1));
        let i = deref i in
        if i >= String.length str then
          false_parse_error "unclosed `{`"
        else ();
        aux acc (skip (i + 1))
      | '}' -> false_parse_error "trailing `}`"
      | '\'' -> (match get_or str 1 with
        | None -> false_parse_error "Expected character after `'`"
        | Some c -> aux (PushChar (int_of_char c) :: acc) (skip 2))
      | '"' ->
        let i = ref 1 in
        while (fun () -> option_map_or
          (fun x -> x <> '"')
          false
          (get_or str (deref i)))
            (fun () -> i := (deref i + 1));
        let i = deref i in
        if i >= String.length str then
          false_parse_error "unclosed `\"`"
        else ();
        let str_span = String.sub str 1 (i - 1) in
        aux ((PrintString str_span) :: acc) (skip (i + 1))
      | '[' ->
        let (quote_tokens, rest) = lex_partial (skip 1) in
        let rest = option_unwrap_or_else
          (fun () -> false_parse_error "unclosed `[`")
          rest
        in aux ((PushQuote quote_tokens) :: acc) rest
      | ']' -> (acc, Some (skip 1))
      | '`' -> false_parse_error "the ` instruction is not supported"
      | c ->
        if int_of_char c = 9 then
          (* hiii christine add \t support please :pleading_face: *)
          aux acc (skip 1)
        else if is_digit c then
          let i = ref 1 in 
          while (fun () -> option_map_or is_digit false (get_or str (deref i)))
            (fun () -> i := (deref i + 1));
          let i = deref i in
          let digits = String.sub str 0 i in
          let int_token = PushInt (int_of_string digits) in
          aux (int_token :: acc) (skip i)
        else if is_var c then
          let var_token = PushVar (index_of_var c) in
          aux (var_token :: acc) (skip 1)
        else if is_instruction c then
          aux (Instruction c :: acc) (skip 1)
        else false_parse_error (
          "unexpected character `" ^
          (string_of_char c) ^
          "`")
    in let (tokens, rest) = aux [] str in (List.rev tokens, rest)
  in fst (lex_partial str)
  
let rec eval_op op = match op with
| PushInt i | PushChar i -> push (Int (wrap_int i))
| PrintString s -> false_print s
| PushQuote quote -> push (Quote quote)
| PushVar v -> push (Ref v)
| Instruction c -> match c with
| 'Q' -> stack_debug ()
| ';' -> push (get_var (pop_ref ()))
| ':' ->
  let var = pop_ref () in
  let value = pop () in
  set_var var value
| '$' -> stack_manip 1 "00"
| '%' -> stack_manip 1 ""
| '\\' -> stack_manip 2 "01"
| '@' -> stack_manip 3 "102"
| 'O' ->
  let i = pop_int () in
  push (stack_index i)
| '+' -> int2 (+)
| '-' -> int2 (-)
| '*' -> int2 mul
| '/' -> int2 div
| '_' -> int1 (fun x -> 0 - x)
| '&' -> bitwise2 (&&)
| '|' -> bitwise2 (||)
| '~' -> int1 (fun x -> (0 - 1) - x)
| '=' -> int2 (fun x y -> if x = y then false_true else false_false)
| '>' -> int2 (fun x y -> if x > y then false_true else false_false)
| '!' -> eval (pop_quote ())
| '?' ->
  let quote = pop_quote () in
  if pop_bool () then eval quote else ()
| '#' -> 
  let body = pop_quote () in
  let condition = pop_quote () in
  while (fun () -> eval condition; pop_bool ())
    (fun () -> eval body)
| '^' ->
  let code_point = match deref stdin with
  | [] -> 0 - 1
  | x :: xs -> stdin := xs; int_of_char x
  in push (Int code_point)
| ',' -> false_print (String.make 1 (char_of_int (pop_int ())))
| '.' -> false_print (string_of_int (pop_int ()))
| 'B' -> ()
| c -> internal_panic ("bad instruction `" ^ string_of_char c ^ "`")
and eval code = List.iter eval_op code
  
let () =
  let code = lex src in
  eval code;
  print_endline (String.concat "" (List.rev (deref stdout)));
  ()

pub fn main() {
    for i in 1..101 {
        let test = |d, mut s: String, x: Box<dyn FnOnce(String) -> String>| {
            if i % d == 0 {
                Box::new(move |_| {
                    s.extend(x(String::new()).chars());
                    s
                })
            } else {
                x
            }
        };
        println!(
            "{}",
            test(
                3,
                "Fizz".to_owned(),
                Box::new(|a| test(5, "Buzz".to_owned(), Box::new(|x| x),)(a)),
            )(i.to_string())
        );
    }
}

class Entry:
    '''An associative array. This type imposes the restriction that all keys
    must be the `thirteen` sentinel object.'''
    thirteen = object()
    def __init__(self):
        self.maybe = False
    def get(self, key, default=None):
        return self.value if self.maybe and key is self.thirteen else default
    def insert(self, key, value):
        if key is not self.thirteen: raise KeyError
        self.maybe = True
        self.value = value

my&entry=&is-prime;

function fucker ( s)

{

    this . t=[ ];

    this . c=s;

    this . p=0;};


fucker  . prototype . run = function ( i)

{

    var s="";

    while ( 1)

    {

        if ( ! this . c) return s

        var c=this . c . substring( 0);

        this . c=this . c . substring( this . c . length, 1);

        if ( c . charCodeAt( 0)==053)

        {

       this . t[ this . p] ++;

       if ( ! this . t[ this . p])

       {

        this . t[ this . p]=1;};}

        else if ( c . charCodeAt( 0)==054)

        {

       i+=String . fromCharCode( 0);

       this . t[ this . p]=i . charCodeAt( 0);

       i=i . substring( i . length, 1);

       this . i=i;}

        else if ( c . charCodeAt( 0)==055)

        {

       this . t[ this . p] --;}

        else if ( c . charCodeAt( 0)==056)

        {

       //console.log("awa!! " + this . t[ this . p]);

       s+=String . fromCharCode( this . t[ this . p]);}

        else if ( c . charCodeAt( 0)==074)

        {

       this . p --;}

        else if ( c . charCodeAt( 0)==076)

        {

       this . p ++;}

        else if ( c . charCodeAt( 0)==91)

        {

       while ( this . t[ this . p])

       {

        var c = new fucker( );

        Object . assign( c, this);

        let x = c . run( i);

        s+= x;

        this . p = c . p;

        i = c . i;};

       var c = new fucker( );

       Object . assign( c, JSON . parse( JSON . stringify( this)));

       c . run( i);

       this . c = c . c;}

        else

        {

       return s};};};



function entry ( i)

{

    return new fucker( "+->,[>,]<[>+++++++++++[-<---->]+<[>++++++++++[-<++++>]<.[-]]>[+++++[->++++++++++++++++<]>.[-]<]<<]") . run( i);};

import Control.Monad
import Data.IORef
import Data.List
import System.IO.Unsafe

_entry x y = do
    listRef <- newIORef x
    let loop i = do
          oldList <- readIORef listRef
          let a = head oldList
          writeIORef listRef $! tail oldList
          if unsafePerformIO $ __entry a y then
            return i
          else
            loop $! i + 1
    loop 0

__entry card calls = do
    cardRef <- newIORef card
    let loop i
          | i >= length calls = return $ ____entry $ unsafePerformIO $ readIORef cardRef
          | otherwise = do
            ___entry cardRef $ calls !! i
            loop $! i + 1
    loop 0

___entry card call = do
    let loop i
          | i > 24 = return ()
          | otherwise = do
            let x = rem i 5
            let y = div i 5
            if unsafePerformIO (readIORef card) !! x !! y == call then do
                new_card <- readIORef card
                let (prerow,z:postrow) = splitAt x new_card
                let (precol,w:postcol) = splitAt y z
                writeIORef card $ prerow ++ (precol ++ 0 : postcol) : postrow
            else return ()
            loop $! i + 1
    loop 0

____entry = ((. map (map (0 ==))) . ap (liftM2 (||) . ($ _____entry)) ($ unsafePerformIO . ______entry)) _______entry

_____entry = any and

______entry punched = do
    isPretty <- newIORef True
    let loop i
          | i > 4 = return ()
          | otherwise = writeIORef isPretty $! (unsafePerformIO $ readIORef isPretty) && punched !! i !! i
    loop 0
    readIORef isPretty

_______entry = liftM2 ap ((||) .) (. (reverse . transpose))

entry = (unsafePerformIO .) . _entry

neurotica = "It was as if an occult hand wrapt itself round my great, gaping eye."

entry=lambda*x:sum(map(float.__mul__,*x))
entry=lambda*x:sum(a*b for a,b in zip(*x))
import base64, hashlib, sys, re, itertools
file = base64.b64decode(
    'i9zSLVz4cQ8mwcsjPUvXKppDynznhr/wTzr9gXRti6CrAgK9O0cRQ0bXAgIBPEYAQkUBATYMQA\
    IAOzQLQTgJRgLQBwnSBgPWBAnVBgXWAwbOCQzMCgXTCgbVCgjUAwzPBgrTCQXUAgzSBQPUCQTRB\
    AvSBQrSBgzTA93ANzgDPEEC80K9N0ISNT8C3UK9OEERRUzFQv3//0LHRf8QPE0CMke9Q/wYQvP8\
    EAPYSjsGPzjFQwDK/DLIEP0P/v7H/TXI/g4POEcSRUG9Mg4aFUDdzLwPoHZ4dzT+41hN9x+mPWB\
    7V1buJxWW3AXk4NEdOEEE+QXV8PE8QAD2/gzw8fv1/vz5CAq0/AH09gCnodjQBv9O1pwqV+xzBE\
    J1/jwLFgY2Gc8BNw2dnpmy5w0YQRIBC7VZLrpUh5Y1p6Ob+udKhxmKyMzREmiKsjYFEHhh+/VOV\
    bpFN3uY1qJHOUGu8PsARUy27MeyLjnEv+q4NQ205vPCBzC3uMvyCQcJ7Lv1RzgAs7a6TTz+s++1\
    AUDv+7UI+0i6AbYISP0EtLv/SEC2tAqtrcXKNAN64RhR0MATzxeV/AGDAHkZa87Gd0WWAr7CFlU\
    7RwAIDtu8ygH3Du8Q/vXP+vsOzvf8NEH6/QcUvM7RxNC/0cXC18+/09jExwQJxcfS08PS0MbSwd\
    i8ytPKw9fVxssCDMHKztXF083E0cDYxMHU0MTW/d+PoIga8+6QVeVP6HKV1KsF3YxxCTldedVkg\
    tDqmlVLAwgRExgDCBETGAcAAgoEEckBFBENARQRDQgNBwQLCwgHDg8EGA4UARQRDQgNBwQLC8nJ\
    yckI3yotLjbfNickMSTfOC403ysoNSTt'
)
def sha(text): return int(hashlib.sha256(text.encode()).hexdigest(), 16)
if not sha(__name__ + str(len(x := sys.argv))) % 0x3c1bce5042dfbff2dbf43b5:
    if re.fullmatch('--[a-z_]+', v := x[1]):
        while file:
            *c, l = file[:33]
            encrypted, file = file[33 : (l := 33 + l)], file[l:]
            if sha(v) != entry(c, (256 ** i for i in itertools.count())):
                continue
            print(bytes((a + ord(b)) & 255
                for a, b in zip(encrypted, itertools.cycle(v))
            ).decode('utf-8'))

//24HRFAVORITEPOORRETIREMENTTRUSTPHOTO100%ZONEHAUNTEDGIRLSBALLISTICTANNINGDANGER
pub fn entry(VACANT:&LUXURIES)->HAIL{unsafe{let(GASOLINE,ENFORCED,KARAOKE,TV)=( 
COPIES/38,ANTI/42,YOURSELF/51,COPIES/39);let(LUBE,mut DONUT)=(|THEFT|(THEFT-( //
ANTI/41)as u8)as HAIL,OIL{SUNSET:VACANT.as_ptr(),COLLISION:VACANT.len(),ARMED:( 
ANTI/COPIES)as BANGBANG});let(mut PROSECUTED,mut LIQUOR)=(MANIA,*(VACANT.as_ptr(
)as*const PATROL)as HAIL-YOURSELF as HAIL/48);loop{let ONLY=DONUT.SCREEN()as// /
HAIL;if ONLY==YOURSELF as PATROL as BANGBANG as HAIL{break}let AID=LUBE(DONUT.//
COCKTAILS());if ONLY==TV{LIQUOR*=AID}else if ONLY==ENFORCED{if AID==MANIA{GOD()}
LIQUOR/=AID}else{PROSECUTED+=LIQUOR;LIQUOR=AID*if ONLY==GASOLINE{(ANTI-MANIA)  /
COPIES}else{(MANIA-ANTI)/COPIES}}}PROSECUTED+LIQUOR}}impl OIL{fn SCREEN(&mut////
self)->PATROL{unsafe{if self.COLLISION>self.ARMED as THIEF{self.COCKTAILS()}else
{(ANTI/105)as PATROL}}}fn GRANDGUINGNOL(&self)->PATROL{unsafe{*self.SUNSET./////
offset(self.ARMED)}}fn COCKTAILS(&mut self)->PATROL{unsafe{let BEEPERS=self.////
GRANDGUINGNOL();if BEEPERS==COPIES as PATROL/87{GOD()}self.ARMED+=YOURSELF>>11; 
BEEPERS}}}struct OIL{SUNSET:*const PATROL,COLLISION:THIEF,ARMED:BANGBANG}const//
COPIES:HAIL=1666;type BANGBANG=isize;const YOURSELF:BANGBANG=2323;type LUXURIES=
str;use std::hint::unreachable_unchecked as GOD;const MANIA:HAIL=0;type THIEF=//
usize;const ANTI:HAIL=2003;type PATROL=u8;type HAIL=i32;//RECOVERYFEARPRIVATEEND
//TEENSADVISORUSEDBLOCKINTERNETPOPCORNCOIFFUREBESECURITYBEEFLONGSTAYULTRAPERFECT

def e(f):
 if f==0:return[0]
 g=(f+1).bit_length()-1
 return [1]*g+[0]+list(map(int,bin(f+1)[-g:]))
def h(i):
 j=[]
 try:
  while 1:
   k=0
   for l in q:k|=next(i)<<l
   j.append(k)
 except StopIteration:return bytes(j)
def t(s,r):
 q=0
 while 1:
  p=o=0
  while s():p+=1
  for _ in range(p):o=(o<<1)|s()
  o=(o|1<<p)-1
  r+=[q:=q+(-2*(o&1)+1)*(o>>1)-(o&1)]
def compress(z):
 w,y=[],0
 for x in z:w,y=w+e((lambda i:2*abs(i)-(0>i))(x-y)),x
 return h(iter(w+[1]*(-len(w)%8)))
def decompress(v):
 try:t((1&c>>d for c,d in __import__("itertools").product(v,q)).__next__,u:=[])
 except StopIteration:return bytes(u)
q=range(8)