Urbit
  • Introduction
  • Development

    • Getting Started
    • Environment Setup
    • Grants Program
    • Project Repositories
    • Precepts
    • System Overview

      • Arvo
      • Hoon
      • Nock
      • Vere
      • Azimuth
      • Cryptography
      • Arvo

        • Overview
        • Reference

          • Cryptography
          • Filesystem Hierarchy
          • Ames

            • Overview
            • Cryptography
            • API Reference
            • Behn

              • Overview
              • API Reference
              • Clay

                • Overview
                • Architecture
                • Using Clay
                • Data Types
                • Scry Reference
                • API Reference
                • Examples
                • Dill

                  • Overview
                  • API Reference
                  • Eyre

                    • Overview
                    • External API Reference
                    • Internal API Reference
                    • Scry Reference
                    • Data Types
                    • Examples
                    • Ford

                      • Overview
                      • Gall

                        • Overview
                        • Iris

                          • API Reference
                          • Jael

                            • API Reference
                            • Concepts

                              • Subscriptions
                              • Tutorials

                                • Move Trace
                              • Userspace

                                • Overview
                                • Gall

                                  • Overview
                                  • Tutorial
                                  • API Reference
                                  • Graph Store

                                    • Graph Store Overview
                                    • Data Structure Overview
                                    • Validator Walkthrough
                                    • Advanced Info
                                    • Threads

                                      • Overview
                                      • HTTP API
                                      • Reference
                                      • Basics

                                        • Fundamentals
                                        • Bind
                                        • Input
                                        • Output
                                        • Summary
                                        • Gall

                                          • Start Thread
                                          • Take Result
                                          • Take Facts
                                          • Stop Thread
                                          • Poke Thread
                                          • Examples

                                            • Fetch JSON
                                            • Child Thread
                                            • Main-loop
                                            • Poke Agent
                                            • Scry
                                            • Take Fact
                                          • Landscape

                                            • Overview
                                            • API Reference

                                              • Graph Store
                                          • Hoon

                                            • Overview
                                            • Hoon School

                                              • 1.1 Setup
                                              • 1.1.1 Walkthrough: List of Numbers
                                              • 1.2 Nouns
                                              • 1.3 Hoon Syntax
                                              • 1.3.1 Walkthrough: Conditionals
                                              • 1.4 Gates (Hoon Functions)
                                              • 1.4.1 Walkthrough: Recursion
                                              • 1.5 Lists
                                              • 1.5.1 Walkthrough: Fibonacci Sequence
                                              • 1.6 The Subject and Its Legs
                                              • 1.6.1 Walkthrough: Ackermann Function
                                              • 1.7 Arms and Cores
                                              • 1.7.1 Walkthrough: Caesar Cipher
                                              • 1.8 Doors
                                              • 1.8.1 Bank Account
                                              • 1.9 Generators
                                              • 2.1 Atoms, Auras, and Simple Cell Types
                                              • 2.2 Type Checking and Type Inference
                                              • 2.3 Structures and Complex Types
                                              • 2.3.1 Walkthrough: Libraries
                                              • 2.3.2 Molds
                                              • 2.4 Standard Library: Trees, Sets, and Maps
                                              • 2.5 Type Polymorphism
                                              • 2.5.1 Walkthrough: Iron Polymorphism and Wet Polymorphism
                                              • 2.5.2 Walkthrough: Lead Polymorphism
                                              • 2.6 Behn
                                              • 2.7 Gall
                                              • 2.7.1 Gall Walkthrough: Egg Timer
                                              • Guides

                                                • CLI apps
                                                • Parsing
                                                • Writing Aqua Tests
                                                • Reference

                                                  • Cheat Sheet
                                                  • Irregular forms
                                                  • Hoon Errors
                                                  • Hoon Style Guide
                                                  • Basic Types
                                                  • Advanced Types
                                                  • Auras
                                                  • Runes

                                                    • Atoms and strings
                                                    • Nock . ('dot')
                                                    • Wild ! ('zap')
                                                    • Change Subject = ('tis')
                                                    • Conditionals ? ('wut')
                                                    • Cores | ('bar')
                                                    • Arms + ('lus')
                                                    • Cells : ('col')
                                                    • Calls % ('cen')
                                                    • Casts ^ ('ket')
                                                    • Structures $ ('buc')
                                                    • Make ; ('mic')
                                                    • Hints ~ ('sig')
                                                    • Terminators -- and ==
                                                    • Limbs and wings

                                                      • Limbs
                                                      • Wings
                                                      • Standard library

                                                        • Table of Contents
                                                        • 1a: Basic Arithmetic
                                                        • 1b: Tree Addressing
                                                        • 1c: Molds and Mold-Builders
                                                        • 2a: Unit Logic
                                                        • 2b: List Logic
                                                        • 2c: Bit Arithmetic
                                                        • 2d: Bit Logic
                                                        • 2e: Insecure Hashing
                                                        • 2f: Noun Ordering
                                                        • 2g: Unsigned Powers
                                                        • 2h: Set Logic
                                                        • 2i: Map Logic
                                                        • 2j: Jar and Jug Logic
                                                        • 2k: Queue Logic
                                                        • 2l: Container from Container
                                                        • 2m: Container from Noun
                                                        • 2n: Functional Hacks
                                                        • 2o: Normalizing Containers
                                                        • 2p: Serialization
                                                        • 2q: Molds and Mold-Builders
                                                        • 3a: Modular and Signed Ints
                                                        • 3b: Floating Point
                                                        • 3c: Urbit Time
                                                        • 3d: SHA Hash Family
                                                        • 3e: AES encryption (Removed)
                                                        • 3f: Scrambling
                                                        • 3g: Molds and Mold-Builders
                                                        • 4a: Exotic Bases
                                                        • 4b: Text Processing
                                                        • 4c: Tank Printer
                                                        • 4d: Parsing (Tracing)
                                                        • 4e: Parsing (Combinators)
                                                        • 4f: Parsing (Rule-Builders)
                                                        • 4g: Parsing (Outside Caller)
                                                        • 4h: Parsing (ASCII Glyphs)
                                                        • 4i: Parsing (Useful Idioms)
                                                        • 4j: Parsing (Bases and Base Digits)
                                                        • 4k: Atom Printing
                                                        • 4l: Atom Parsing
                                                        • 4m: Formatting Functions
                                                        • 4n: Virtualization
                                                        • 4o: Molds
                                                        • 5a: Compiler Utilities
                                                        • 5b: Macro Expansion
                                                        • 5c: Compiler Backend & Prettyprinter
                                                        • 5d: Parser
                                                        • 5e: Caching Compiler
                                                        • 5f: Molds and Mold-Builders
                                                        • 5g: profiling support
                                                    • Nock

                                                      • Nock Definition
                                                      • Explanation
                                                      • Example
                                                      • Implementations
                                                      • Vere

                                                        • C Runtime System
                                                        • Land of Nouns
                                                        • API overview by prefix
                                                        • C in Urbit
                                                        • Writing Jets
                                                        • Cryptography
                                                        • Azimuth

                                                          • Overview
                                                          • Life and Rift
                                                          • Advanced Azimuth Tools
                                                          • Glossary

                                                            • Ames
                                                            • Aqua
                                                            • Arm
                                                            • Arvo
                                                            • Atom
                                                            • Azimuth
                                                            • Battery
                                                            • Behn
                                                            • Breach
                                                            • Bridge
                                                            • Censures
                                                            • Ceremony
                                                            • chat
                                                            • Claims
                                                            • Clay
                                                            • Comet
                                                            • Core
                                                            • Delegated Sending
                                                            • Desk
                                                            • Dill
                                                            • Document Proposal
                                                            • Dojo
                                                            • Door
                                                            • Ecliptic
                                                            • Event Log
                                                            • Eyre
                                                            • Ford
                                                            • Galaxy
                                                            • Gall
                                                            • Gate
                                                            • HD Wallet
                                                            • Hoon
                                                            • Invite Tree
                                                            • Iris
                                                            • Jael
                                                            • Jaque
                                                            • Keyfile
                                                            • Landscape
                                                            • Mark
                                                            • Moon
                                                            • Nock
                                                            • Noun
                                                            • OTA Updates
                                                            • Payload
                                                            • pH
                                                            • Pier
                                                            • Pill
                                                            • Planet
                                                            • Proxies
                                                            • Replay
                                                            • Sail/Udon
                                                            • Senate
                                                            • Ship
                                                            • ship.arvo.network
                                                            • Star
                                                            • |sync
                                                            • Trap
                                                            • Upgrade Proposal
                                                            • Vane
                                                            • Vere
                                                            • Voting
                                                            • Wallet-Generator
                                                            Urbit
                                                            • Introduction
                                                            • Development

                                                              • Getting Started
                                                              • Environment Setup
                                                              • Grants Program
                                                              • Project Repositories
                                                              • Precepts
                                                              • System Overview

                                                                • Arvo
                                                                • Hoon
                                                                • Nock
                                                                • Vere
                                                                • Azimuth
                                                                • Cryptography
                                                                • Arvo

                                                                  • Overview
                                                                  • Reference

                                                                    • Cryptography
                                                                    • Filesystem Hierarchy
                                                                    • Ames

                                                                      • Overview
                                                                      • Cryptography
                                                                      • API Reference
                                                                      • Behn

                                                                        • Overview
                                                                        • API Reference
                                                                        • Clay

                                                                          • Overview
                                                                          • Architecture
                                                                          • Using Clay
                                                                          • Data Types
                                                                          • Scry Reference
                                                                          • API Reference
                                                                          • Examples
                                                                          • Dill

                                                                            • Overview
                                                                            • API Reference
                                                                            • Eyre

                                                                              • Overview
                                                                              • External API Reference
                                                                              • Internal API Reference
                                                                              • Scry Reference
                                                                              • Data Types
                                                                              • Examples
                                                                              • Ford

                                                                                • Overview
                                                                                • Gall

                                                                                  • Overview
                                                                                  • Iris

                                                                                    • API Reference
                                                                                    • Jael

                                                                                      • API Reference
                                                                                      • Concepts

                                                                                        • Subscriptions
                                                                                        • Tutorials

                                                                                          • Move Trace
                                                                                        • Userspace

                                                                                          • Overview
                                                                                          • Gall

                                                                                            • Overview
                                                                                            • Tutorial
                                                                                            • API Reference
                                                                                            • Graph Store

                                                                                              • Graph Store Overview
                                                                                              • Data Structure Overview
                                                                                              • Validator Walkthrough
                                                                                              • Advanced Info
                                                                                              • Threads

                                                                                                • Overview
                                                                                                • HTTP API
                                                                                                • Reference
                                                                                                • Basics

                                                                                                  • Fundamentals
                                                                                                  • Bind
                                                                                                  • Input
                                                                                                  • Output
                                                                                                  • Summary
                                                                                                  • Gall

                                                                                                    • Start Thread
                                                                                                    • Take Result
                                                                                                    • Take Facts
                                                                                                    • Stop Thread
                                                                                                    • Poke Thread
                                                                                                    • Examples

                                                                                                      • Fetch JSON
                                                                                                      • Child Thread
                                                                                                      • Main-loop
                                                                                                      • Poke Agent
                                                                                                      • Scry
                                                                                                      • Take Fact
                                                                                                    • Landscape

                                                                                                      • Overview
                                                                                                      • API Reference

                                                                                                        • Graph Store
                                                                                                    • Hoon

                                                                                                      • Overview
                                                                                                      • Hoon School

                                                                                                        • 1.1 Setup
                                                                                                        • 1.1.1 Walkthrough: List of Numbers
                                                                                                        • 1.2 Nouns
                                                                                                        • 1.3 Hoon Syntax
                                                                                                        • 1.3.1 Walkthrough: Conditionals
                                                                                                        • 1.4 Gates (Hoon Functions)
                                                                                                        • 1.4.1 Walkthrough: Recursion
                                                                                                        • 1.5 Lists
                                                                                                        • 1.5.1 Walkthrough: Fibonacci Sequence
                                                                                                        • 1.6 The Subject and Its Legs
                                                                                                        • 1.6.1 Walkthrough: Ackermann Function
                                                                                                        • 1.7 Arms and Cores
                                                                                                        • 1.7.1 Walkthrough: Caesar Cipher
                                                                                                        • 1.8 Doors
                                                                                                        • 1.8.1 Bank Account
                                                                                                        • 1.9 Generators
                                                                                                        • 2.1 Atoms, Auras, and Simple Cell Types
                                                                                                        • 2.2 Type Checking and Type Inference
                                                                                                        • 2.3 Structures and Complex Types
                                                                                                        • 2.3.1 Walkthrough: Libraries
                                                                                                        • 2.3.2 Molds
                                                                                                        • 2.4 Standard Library: Trees, Sets, and Maps
                                                                                                        • 2.5 Type Polymorphism
                                                                                                        • 2.5.1 Walkthrough: Iron Polymorphism and Wet Polymorphism
                                                                                                        • 2.5.2 Walkthrough: Lead Polymorphism
                                                                                                        • 2.6 Behn
                                                                                                        • 2.7 Gall
                                                                                                        • 2.7.1 Gall Walkthrough: Egg Timer
                                                                                                        • Guides

                                                                                                          • CLI apps
                                                                                                          • Parsing
                                                                                                          • Writing Aqua Tests
                                                                                                          • Reference

                                                                                                            • Cheat Sheet
                                                                                                            • Irregular forms
                                                                                                            • Hoon Errors
                                                                                                            • Hoon Style Guide
                                                                                                            • Basic Types
                                                                                                            • Advanced Types
                                                                                                            • Auras
                                                                                                            • Runes

                                                                                                              • Atoms and strings
                                                                                                              • Nock . ('dot')
                                                                                                              • Wild ! ('zap')
                                                                                                              • Change Subject = ('tis')
                                                                                                              • Conditionals ? ('wut')
                                                                                                              • Cores | ('bar')
                                                                                                              • Arms + ('lus')
                                                                                                              • Cells : ('col')
                                                                                                              • Calls % ('cen')
                                                                                                              • Casts ^ ('ket')
                                                                                                              • Structures $ ('buc')
                                                                                                              • Make ; ('mic')
                                                                                                              • Hints ~ ('sig')
                                                                                                              • Terminators -- and ==
                                                                                                              • Limbs and wings

                                                                                                                • Limbs
                                                                                                                • Wings
                                                                                                                • Standard library

                                                                                                                  • Table of Contents
                                                                                                                  • 1a: Basic Arithmetic
                                                                                                                  • 1b: Tree Addressing
                                                                                                                  • 1c: Molds and Mold-Builders
                                                                                                                  • 2a: Unit Logic
                                                                                                                  • 2b: List Logic
                                                                                                                  • 2c: Bit Arithmetic
                                                                                                                  • 2d: Bit Logic
                                                                                                                  • 2e: Insecure Hashing
                                                                                                                  • 2f: Noun Ordering
                                                                                                                  • 2g: Unsigned Powers
                                                                                                                  • 2h: Set Logic
                                                                                                                  • 2i: Map Logic
                                                                                                                  • 2j: Jar and Jug Logic
                                                                                                                  • 2k: Queue Logic
                                                                                                                  • 2l: Container from Container
                                                                                                                  • 2m: Container from Noun
                                                                                                                  • 2n: Functional Hacks
                                                                                                                  • 2o: Normalizing Containers
                                                                                                                  • 2p: Serialization
                                                                                                                  • 2q: Molds and Mold-Builders
                                                                                                                  • 3a: Modular and Signed Ints
                                                                                                                  • 3b: Floating Point
                                                                                                                  • 3c: Urbit Time
                                                                                                                  • 3d: SHA Hash Family
                                                                                                                  • 3e: AES encryption (Removed)
                                                                                                                  • 3f: Scrambling
                                                                                                                  • 3g: Molds and Mold-Builders
                                                                                                                  • 4a: Exotic Bases
                                                                                                                  • 4b: Text Processing
                                                                                                                  • 4c: Tank Printer
                                                                                                                  • 4d: Parsing (Tracing)
                                                                                                                  • 4e: Parsing (Combinators)
                                                                                                                  • 4f: Parsing (Rule-Builders)
                                                                                                                  • 4g: Parsing (Outside Caller)
                                                                                                                  • 4h: Parsing (ASCII Glyphs)
                                                                                                                  • 4i: Parsing (Useful Idioms)
                                                                                                                  • 4j: Parsing (Bases and Base Digits)
                                                                                                                  • 4k: Atom Printing
                                                                                                                  • 4l: Atom Parsing
                                                                                                                  • 4m: Formatting Functions
                                                                                                                  • 4n: Virtualization
                                                                                                                  • 4o: Molds
                                                                                                                  • 5a: Compiler Utilities
                                                                                                                  • 5b: Macro Expansion
                                                                                                                  • 5c: Compiler Backend & Prettyprinter
                                                                                                                  • 5d: Parser
                                                                                                                  • 5e: Caching Compiler
                                                                                                                  • 5f: Molds and Mold-Builders
                                                                                                                  • 5g: profiling support
                                                                                                              • Nock

                                                                                                                • Nock Definition
                                                                                                                • Explanation
                                                                                                                • Example
                                                                                                                • Implementations
                                                                                                                • Vere

                                                                                                                  • C Runtime System
                                                                                                                  • Land of Nouns
                                                                                                                  • API overview by prefix
                                                                                                                  • C in Urbit
                                                                                                                  • Writing Jets
                                                                                                                  • Cryptography
                                                                                                                  • Azimuth

                                                                                                                    • Overview
                                                                                                                    • Life and Rift
                                                                                                                    • Advanced Azimuth Tools
                                                                                                                    • Glossary

                                                                                                                      • Ames
                                                                                                                      • Aqua
                                                                                                                      • Arm
                                                                                                                      • Arvo
                                                                                                                      • Atom
                                                                                                                      • Azimuth
                                                                                                                      • Battery
                                                                                                                      • Behn
                                                                                                                      • Breach
                                                                                                                      • Bridge
                                                                                                                      • Censures
                                                                                                                      • Ceremony
                                                                                                                      • chat
                                                                                                                      • Claims
                                                                                                                      • Clay
                                                                                                                      • Comet
                                                                                                                      • Core
                                                                                                                      • Delegated Sending
                                                                                                                      • Desk
                                                                                                                      • Dill
                                                                                                                      • Document Proposal
                                                                                                                      • Dojo
                                                                                                                      • Door
                                                                                                                      • Ecliptic
                                                                                                                      • Event Log
                                                                                                                      • Eyre
                                                                                                                      • Ford
                                                                                                                      • Galaxy
                                                                                                                      • Gall
                                                                                                                      • Gate
                                                                                                                      • HD Wallet
                                                                                                                      • Hoon
                                                                                                                      • Invite Tree
                                                                                                                      • Iris
                                                                                                                      • Jael
                                                                                                                      • Jaque
                                                                                                                      • Keyfile
                                                                                                                      • Landscape
                                                                                                                      • Mark
                                                                                                                      • Moon
                                                                                                                      • Nock
                                                                                                                      • Noun
                                                                                                                      • OTA Updates
                                                                                                                      • Payload
                                                                                                                      • pH
                                                                                                                      • Pier
                                                                                                                      • Pill
                                                                                                                      • Planet
                                                                                                                      • Proxies
                                                                                                                      • Replay
                                                                                                                      • Sail/Udon
                                                                                                                      • Senate
                                                                                                                      • Ship
                                                                                                                      • ship.arvo.network
                                                                                                                      • Star
                                                                                                                      • |sync
                                                                                                                      • Trap
                                                                                                                      • Upgrade Proposal
                                                                                                                      • Vane
                                                                                                                      • Vere
                                                                                                                      • Voting
                                                                                                                      • Wallet-Generator
                                                                                                                      Urbit/Documentation/Hoon/Reference/Standard library

                                                                                                                      4k: Atom Printing

                                                                                                                      ++co

                                                                                                                      Literal rendering engine

                                                                                                                      A door that contains arms that operate on the sample coin lot.

                                                                                                                      Accepts

                                                                                                                      Produces

                                                                                                                      lot is a ++coin.

                                                                                                                      Source

                                                                                                                      ++  co  !.
                                                                                                                            ~%  %co  ..co  ~
                                                                                                                            =<  |_  lot/coin
                                                                                                                      

                                                                                                                      Examples

                                                                                                                              > < 3.nta
                                                                                                                              { lot/{$many {$~ $ta @t} {$~ $ud @ud} $~}
                                                                                                                                <10.cfg 4.jjn {rep/"" <402.arm 110.jyx 1.ztu $151>}>
                                                                                                                              }
                                                                                                                              >

                                                                                                                      ++rear:co

                                                                                                                      Prepend & render as tape

                                                                                                                      Renders a coin lot as a tape prepended to the sample tape rom.

                                                                                                                      Accepts

                                                                                                                      Produces

                                                                                                                      rom is a pe

                                                                                                                      lot is a ++coin.

                                                                                                                      Source

                                                                                                                      ++  rear  |=(rom/tape =>(.(rex rom) rend))
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (~(rear co %$ %ux 200) "--ha")
                                                                                                                          "0xc8--ha"

                                                                                                                      ++rent:co

                                                                                                                      Render as span

                                                                                                                      Renders a coin lot as a span.

                                                                                                                      Accepts

                                                                                                                      Produces

                                                                                                                      lot is a ++coin.

                                                                                                                      Source

                                                                                                                      ++  rent  `@ta`(rap 3 rend)
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > ~(rent co %$ %ux 200)
                                                                                                                          ~.0xc8
                                                                                                                      
                                                                                                                          > `@t`~(rent co %$ %ux 200)
                                                                                                                          '0xc8'

                                                                                                                      ++rend:co

                                                                                                                      Render as tape

                                                                                                                      Renders a coin lot as a tape.

                                                                                                                      Accepts

                                                                                                                      Produces

                                                                                                                      lot is a ++coin.

                                                                                                                      Source

                                                                                                                      ++  rend
                                                                                                                              ^-  tape
                                                                                                                              ?:  ?=($blob -.lot)
                                                                                                                                ['~' '0' ((v-co 1) (jam p.lot))]
                                                                                                                              ?:  ?=($many -.lot)
                                                                                                                                :-  '.'
                                                                                                                                |-  ^-  tape
                                                                                                                                ?~   p.lot
                                                                                                                                  ['_' '_' rep]
                                                                                                                                ['_' (weld (trip (wack rent(lot i.p.lot))) $(p.lot t.p.lot))]
                                                                                                                              =+  [yed=(end 3 1 p.p.lot) hay=(cut 3 [1 1] p.p.lot)]
                                                                                                                              |-  ^-  tape
                                                                                                                              ?+    yed  (z-co q.p.lot)
                                                                                                                                  $c   ['~' '-' (weld (rip 3 (wood (tuft q.p.lot))) rep)]
                                                                                                                                  $d
                                                                                                                                ?+    hay  (z-co q.p.lot)
                                                                                                                                    $a
                                                                                                                                  =+  yod=(yore q.p.lot)
                                                                                                                                  =>  ^+(. .(rep ?~(f.t.yod rep ['.' (s-co f.t.yod)])))
                                                                                                                                  =>  ^+  .
                                                                                                                                      %=    .
                                                                                                                                          rep
                                                                                                                                        ?:  &(=(~ f.t.yod) =(0 h.t.yod) =(0 m.t.yod) =(0 s.t.yod))
                                                                                                                                          rep
                                                                                                                                        =>  .(rep ['.' (y-co s.t.yod)])
                                                                                                                                        =>  .(rep ['.' (y-co m.t.yod)])
                                                                                                                                        ['.' '.' (y-co h.t.yod)]
                                                                                                                                      ==
                                                                                                                                  =>  .(rep ['.' (a-co d.t.yod)])
                                                                                                                                  =>  .(rep ['.' (a-co m.yod)])
                                                                                                                                  =>  .(rep ?:(a.yod rep ['-' rep]))
                                                                                                                                  ['~' (a-co y.yod)]
                                                                                                                                ::
                                                                                                                                    $r
                                                                                                                                  =+  yug=(yell q.p.lot)
                                                                                                                                  =>  ^+(. .(rep ?~(f.yug rep ['.' (s-co f.yug)])))
                                                                                                                                  :-  '~'
                                                                                                                                  ?:  &(=(0 d.yug) =(0 m.yug) =(0 h.yug) =(0 s.yug))
                                                                                                                                    ['s' '0' rep]
                                                                                                                                  =>  ^+(. ?:(=(0 s.yug) . .(rep ['.' 's' (a-co s.yug)])))
                                                                                                                                  =>  ^+(. ?:(=(0 m.yug) . .(rep ['.' 'm' (a-co m.yug)])))
                                                                                                                                  =>  ^+(. ?:(=(0 h.yug) . .(rep ['.' 'h' (a-co h.yug)])))
                                                                                                                                  =>  ^+(. ?:(=(0 d.yug) . .(rep ['.' 'd' (a-co d.yug)])))
                                                                                                                                  +.rep
                                                                                                                                ==
                                                                                                                              ::
                                                                                                                                  $f
                                                                                                                                ?:  =(& q.p.lot)
                                                                                                                                  ['.' 'y' rep]
                                                                                                                                ?:(=(| q.p.lot) ['.' 'n' rep] (z-co q.p.lot))
                                                                                                                              ::
                                                                                                                                  $n   ['~' rep]
                                                                                                                                  $i
                                                                                                                                ?+  hay  (z-co q.p.lot)
                                                                                                                                  $f  ((ro-co [3 10 4] |=(a/@ ~(d ne a))) q.p.lot)
                                                                                                                                  $s  ((ro-co [4 16 8] |=(a/@ ~(x ne a))) q.p.lot)
                                                                                                                                ==
                                                                                                                              ::
                                                                                                                                  $p
                                                                                                                                =+  dyx=(met 3 q.p.lot)
                                                                                                                                :-  '~'
                                                                                                                                ?:  (lte dyx 1)
                                                                                                                                  (weld (trip (tod:po q.p.lot)) rep)
                                                                                                                                ?:  =(2 dyx)
                                                                                                                                  ;:  weld
                                                                                                                                    (trip (tos:po (end 3 1 q.p.lot)))
                                                                                                                                    (trip (tod:po (rsh 3 1 q.p.lot)))
                                                                                                                                    rep
                                                                                                                                  ==
                                                                                                                                =+  [dyz=(met 5 q.p.lot) fin=| dub=&]
                                                                                                                                |-  ^-  tape
                                                                                                                                ?:  =(0 dyz)
                                                                                                                                  rep
                                                                                                                                %=    $
                                                                                                                                    fin      &
                                                                                                                                    dub      !dub
                                                                                                                                    dyz      (dec dyz)
                                                                                                                                    q.p.lot  (rsh 5 1 q.p.lot)
                                                                                                                                    rep
                                                                                                                                  =+  syb=(wren:un (end 5 1 q.p.lot))
                                                                                                                                  =+  cog=~(zig mu [(rsh 4 1 syb) (end 4 1 syb)])
                                                                                                                                  ;:  weld
                                                                                                                                    (trip (tos:po (end 3 1 p.cog)))
                                                                                                                                    (trip (tod:po (rsh 3 1 p.cog)))
                                                                                                                                    `tape`['-' ~]
                                                                                                                                    (trip (tos:po (end 3 1 q.cog)))
                                                                                                                                    (trip (tod:po (rsh 3 1 q.cog)))
                                                                                                                                    `tape`?.(fin ~ ['-' ?.(dub ~ ['-' ~])])
                                                                                                                                    rep
                                                                                                                                  ==
                                                                                                                                ==
                                                                                                                              ::
                                                                                                                                  $r
                                                                                                                                ?+  hay  (z-co q.p.lot)
                                                                                                                                  $d  ['.' '~' (r-co (rlyd q.p.lot))]
                                                                                                                                  $h  ['.' '~' '~' (r-co (rlyh q.p.lot))]
                                                                                                                                  $q  ['.' '~' '~' '~' (r-co (rlyq q.p.lot))]
                                                                                                                                  $s  ['.' (r-co (rlys q.p.lot))]
                                                                                                                                ==
                                                                                                                              ::
                                                                                                                                  $u
                                                                                                                                ?:  ?=($c hay)
                                                                                                                                  %+  welp  ['0' 'c' (reap (pad:fa q.p.lot) '1')]
                                                                                                                                  (c-co (enc:fa q.p.lot))
                                                                                                                                =-  (weld p.gam ?:(=(0 q.p.lot) `tape`['0' ~] q.gam))
                                                                                                                                ^=  gam  ^-  {p/tape q/tape}
                                                                                                                                ?+  hay  [~ ((ox-co [10 3] |=(a/@ ~(d ne a))) q.p.lot)]
                                                                                                                                  $b  [['0' 'b' ~] ((ox-co [2 4] |=(a/@ ~(d ne a))) q.p.lot)]
                                                                                                                                  $i  [['0' 'i' ~] ((d-co 1) q.p.lot)]
                                                                                                                                  $x  [['0' 'x' ~] ((ox-co [16 4] |=(a/@ ~(x ne a))) q.p.lot)]
                                                                                                                                  $v  [['0' 'v' ~] ((ox-co [32 5] |=(a/@ ~(x ne a))) q.p.lot)]
                                                                                                                                  $w  [['0' 'w' ~] ((ox-co [64 5] |=(a/@ ~(w ne a))) q.p.lot)]
                                                                                                                                ==
                                                                                                                              ::
                                                                                                                                  $s
                                                                                                                                %+  weld
                                                                                                                                  ?:((syn:si q.p.lot) "--" "-")
                                                                                                                                $(yed 'u', q.p.lot (abs:si q.p.lot))
                                                                                                                              ::
                                                                                                                                  $t
                                                                                                                                ?:  =('a' hay)
                                                                                                                                  ?:  =('s' (cut 3 [2 1] p.p.lot))
                                                                                                                                    (weld (rip 3 q.p.lot) rep)
                                                                                                                                  ['~' '.' (weld (rip 3 q.p.lot) rep)]
                                                                                                                                ['~' '~' (weld (rip 3 (wood q.p.lot)) rep)]
                                                                                                                              ==
                                                                                                                            --
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > ~(rend co %$ %ux 200)
                                                                                                                          "0xc8"
                                                                                                                      
                                                                                                                          > ~(rend co %many ~[[%$ ux+200] [%$ p+40]])
                                                                                                                          "._0xc8_~~tem__"
                                                                                                                      
                                                                                                                          > ~(rend co %$ %p 32.819)
                                                                                                                          "~pillyt"
                                                                                                                      
                                                                                                                          > ~(rend co %$ %ux 18)
                                                                                                                          "0x12"
                                                                                                                      
                                                                                                                          > ~(rend co [%$ p=[p=%if q=0x7f00.0001]])
                                                                                                                          ".127.0.0.1"
                                                                                                                      
                                                                                                                          > `@ux`.127.0.0.1
                                                                                                                          2.130.706.433
                                                                                                                      
                                                                                                                          > ~(rend co %many ~[[%$ %ud 20] [%$ %uw 133] [%$ %tas 'sam']])
                                                                                                                          "._20_0w25_sam__"
                                                                                                                      
                                                                                                                          > ~(rend co %blob [1 1])
                                                                                                                          "~0ph"
                                                                                                                      
                                                                                                                          > ~0ph
                                                                                                                          [1 1]
                                                                                                                      
                                                                                                                          > `@uv`(jam [1 1])
                                                                                                                          0vph

                                                                                                                      <-

                                                                                                                      4j: Parsing (Bases and Base Digits)

                                                                                                                      4l: Atom Parsing

                                                                                                                      ->