|:: push to $x :value: $y| :stacks: $x $y
|:: push $x to $y| :stacks: $y $x

|:: pop from $x :stacks: $x $y|
    :value: $y
    :: reset stacks
|:: pop from $x? :stacks: $z $y|
    :seen: $z $y
|:: pop from $x :default symbol: $y?|
    :value: $y
    :: reset stacks
|:: pop from $x|
    :: stop execution :error: pop from an empty or nonexistent stack $x

|:: reset stacks? :seen: $x $y|
    :stacks: $x $y
|:: reset stacks|

|:: move $direction :@math: $x|
    :stack: $x
|:: move left :stack: 1 :number of stacks: $x?|
    :stack: $x
|:: move left? :stack: $x|
    :@math: subtract $x 1
|:: move right :stack: $x :number of stacks: $x?|
    :stack: 1
|:: move right? :stack: $x|
    :@math: add $x 1
|:: move $direction?|
    :stack: 1

|:: compare and branch :value: ($x $x)|
|:: compare and branch :value: ($x $y)|
    :: seek forward :depth:

|:: seek forward? :code: [|
    :executed: [
    :depth:
|:: seek forward? :code: ] :depth: :depth:|
    :executed: ]
|:: seek forward :code: ] :depth:|
    :executed: ]
|:: seek forward? :code: $x|
    :executed: $x
|:: seek forward|

|:: seek backward? :executed: ]|
    :code: ]
    :depth:
|:: seek backward? :executed: [ :depth: :depth:|
    :code: [
|:: seek backward :executed: [ :depth:|
    :code: [
|:: seek backward? :executed: $x|
    :code: $x
|:: seek backward|

|:: step :code: <|
    :executed: <
    :: move left
|:: step :code: >|
    :executed: >
    :: move right
|:: step :code: 0|
    :executed: 0
    :: push 0 to 1
|:: step :code: 1|
    :executed: 1
    :: push 1 to 1
|:: step :code: ^ :stack: $x?|
    :executed: ^
    :: pop from 1
    :: push to $x
|:: step :code: v :stack: $x?|
    :executed: v
    :: pop from $x
    :: push to 1
|:: step :code: [ :stack: $x?|
    :executed: [
    :: pop from 1
    :: pop from $x
    :: compare and branch
|:: step :code: ]|
    :executed: ]
    :: seek backward
|:: step :code: $x|
|:: step| :halt:

|:: run :halt:|
    :: clean up
|:: run?|
    :: step

|:: clean up? :executed: $x|
|:: clean up? :code: $x|
|:: clean up|

|:: parse? :text: '<'| :parsed: <
|:: parse? :text: '>'| :parsed: >
|:: parse? :text: '0'| :parsed: 0
|:: parse? :text: '1'| :parsed: 1
|:: parse? :text: '^'| :parsed: ^
|:: parse? :text: 'v'| :parsed: v
|:: parse? :text: '['| :parsed: [
|:: parse? :text: ']'| :parsed: ]
|:: parse? :text: $x |
|:: parse? :parsed: $x| :code: $x
|:: parse|

||:stack: 1

|:: evaluate|
    :: parse
    :: run

||:: evaluate :text: "0 1111 1111 1111 1^[>1^1^]"
  :number of stacks: 50