# 4j: Parsing (Bases and Base Digits)
## `+ab`
Primitive parser engine.
A core containing numeric parser primitives.
#### Source
```hoon
++ ab
|%
```
#### Examples
```
> ab
<36.ecc 414.gly 100.xkc 1.ypj %164>
```
***
### `+bix:ab`
Parse hex pair.
Parsing `$rule`. Parses a pair of base-16 digits. Used in escapes.
#### Source
```hoon
++ bix (bass 16 (stun [2 2] six))
```
#### Examples
```
> (scan "07" bix:ab)
7
```
```
> (scan "51" bix:ab)
81
```
```
> (scan "a3" bix:ab)
163
```
***
### `+fem:ab`
Parse base58check char.
Parse a single base58check character.
#### Source
```hoon
++ fem (sear |=(a=@ (cha:fa a)) aln)
```
#### Examples
```
> (scan "6" fem:ab)
5
```
```
> (scan "Z" fem:ab)
32
```
```
> (scan "j" fem:ab)
42
```
***
### `+haf:ab`
Parse non-doz phonetic pair.
Parsing `$rule`. Parses an `$atom` of aura `@pE`, a phrase of two bytes encoded phonetically. If the leading syllable is `.z` (`0`), parsing will fail.
#### Source
```hoon
++ haf (bass 256 ;~(plug tep tiq (easy ~)))
```
#### Examples
```
> `@p`(scan "sampel" haf:ab)
~sampel
```
```
> `@p`(scan "dozpel" haf:ab)
{1 4}
syntax error
```
***
### `+hef:ab`
Parse non-dozzod phonetic pair.
Parsing `$rule`. Parses an `$atom` of aura `@pE` without leading `~` or `.~`, a phrase of two bytes encoded phonetically. If it's `dozzod`, parsing will fail.
#### Source
```hoon
++ hef %+ sear |=(a=@ ?:(=(a 0) ~ (some a)))
%+ bass 256
;~(plug tip tiq (easy ~))
```
#### Examples
```
> `@p`(scan "sampel" hef:ab)
~sampel
```
```
> `@p`(scan "dozpel" hef:ab)
~pel
```
```
> `@p`(scan "dozzod" hef:ab)
{1 7}
syntax error
```
***
### `+hif:ab`
Parse phonetic pair.
Parsing `$rule`. Parses an `$atom` of aura `@pE`, without leading `~` or `.~`. A phrase of two bytes encoded phonetically.
#### Source
```hoon
++ hif (boss 256 ;~(plug tip tiq (easy ~)))
```
#### Examples
```
> `@p`(scan "doznec" hif:ab)
~nec
```
```
> `@p`(scan "pittyp" hif:ab)
~pittyp
```
***
### `+hof:ab`
Parse 2-4 `@q` phonetic pairs.
Parsing `$rule`. Parses an `$atom` of aura `@q` (non-scrambled `@p`), without leading `~` or `.~`, of between two and four phrases.
#### Source
```hoon
++ hof (bass 0x1.0000 ;~(plug hef (stun [1 3] ;~(pfix hep hif))))
```
#### Example
```
> `@q`(scan "sampel-palnet" hof:ab)
.~sampel-palnet
```
```
> `@q`(scan "sampel-sampel-palnet" hof:ab)
.~sampel-sampel-palnet
```
```
> `@q`(scan "sampel-sampel-sampel-palnet" hof:ab)
.~sampel-sampel-sampel-palnet
```
***
### `+huf:ab`
Parse 1-4 `@q` phonetic pairs.
Parsing `$rule`. Parses an `$atom` of aura `@q` (non-scrambled `@p`), without leading `~` or `.~`, of between one and four phrases.
#### Source
```hoon
++ huf (bass 0x1.0000 ;~(plug hef (stun [0 3] ;~(pfix hep hif))))
```
#### Examples
```
> `@q`(scan "sampel" huf:ab)
.~sampel
```
```
> `@q`(scan "sampel-palnet" huf:ab)
.~sampel-palnet
```
```
> `@q`(scan "sampel-sampel-palnet" huf:ab)
.~sampel-sampel-palnet
```
```
> `@q`(scan "sampel-sampel-sampel-palnet" huf:ab)
.~sampel-sampel-sampel-palnet
```
***
### `+hyf:ab`
Parse four `@q` phonetic pairs.
Parsing `$rule`. Parses an `$atom` of aura `@q` (non-scrambled `@p`), without leading `~` or `.~`, of exactly four phrases.
#### Source
```hoon
++ hyf (bass 0x1.0000 ;~(plug hif (stun [3 3] ;~(pfix hep hif))))
```
#### Examples
```
> `@q`(scan "sampel-sampel-sampel-palnet" hyf:ab)
.~sampel-sampel-sampel-palnet
```
***
### `+pev:ab`
Parse 1-5 `@uv` base-32 chars.
Parsing `$rule`. Parses one to five `@uv` base-32 digits without the leading `0v` or leading zeros.
#### Source
```hoon
++ pev (bass 32 ;~(plug sev (stun [0 4] siv)))
```
#### Examples
```
> `@uv`(scan "du3ja" pev:ab)
0vdu3ja
```
```
> `@uv`(scan "3ja" pev:ab)
0v3ja
```
```
> `@uv`(scan "a" pev:ab)
0va
```
***
### `+pew:ab`
Parse 1-5 `@uw` base-64 chars.
Parsing `$rule`. Parses one to five `@uw` base-64 digits without the leading `0w` or leading zeros.
#### Source
```hoon
++ pew (bass 64 ;~(plug sew (stun [0 4] siw)))
```
#### Examples
```
> `@uw`(scan "6U0gP" pew:ab)
0w6U0gP
```
```
> `@uw`(scan "gP" pew:ab)
0wgP
```
```
> `@uw`(scan "P" pew:ab)
0wP
```
***
### `+piv:ab`
Parse 5 `@uv` base-32 chars.
Parsing `$rule`. Parses exactly five `@uv` base-32 digits without the leading `0v` or leading zeros.
#### Source
```hoon
++ piv (bass 32 (stun [5 5] siv))
```
#### Examples
```
> `@uv`(scan "du3ja" piv:ab)
0vdu3ja
```
```
> `@uv`(scan "u3ja" piv:ab)
{1 5}
syntax error
```
***
### `+piw:ab`
Parse 5 `@uw` base-64 chars.
Parsing `$rule`. Parses exactly five `@uw` base-64 digits without the leading `0w` or leading zeros.
#### Source
```hoon
++ piw (bass 64 (stun [5 5] siw))
```
#### Examples
```
> `@uw`(scan "6U0gP" piw:ab)
0w6U0gP
```
```
> `@uw`(scan "U0gP" piw:ab)
{1 5}
syntax error
```
***
### `+qeb:ab`
Parse 1-4 binary digits.
Parsing `$rule`. Parses a binary number of up to 4 digits in length without a leading zero.
#### Source
```hoon
++ qeb (bass 2 ;~(plug seb (stun [0 3] sib)))
```
#### Examples
```
> `@ub`(scan "1010" qeb:ab)
0b1010
```
```
> `@ub`(scan "10" qeb:ab)
0b10
```
```
> `@ub`(scan "1" qeb:ab)
0b1
```
```
> `@ub`(scan "0" qeb:ab)
{1 1}
syntax error
```
***
### `+qex:ab`
Parse 1-4 hex digits.
Parsing `$rule`. Parses a hexadecimal number of up to 4 digits in length without a leading zero.
#### Source
```hoon
++ qex (bass 16 ;~(plug sex (stun [0 3] hit)))
```
#### Examples
```
> `@ux`(scan "beef" qex:ab)
0xbeef
```
```
> `@ux`(scan "ef" qex:ab)
0xef
```
```
> `@ux`(scan "f" qex:ab)
0xf
```
***
### `+qib:ab`
Parse 4 binary.
Parsing `$rule`. Parses exactly four binary digits - may have leading zeros.
#### Source
```hoon
++ qib (bass 2 (stun [4 4] sib))
```
#### Examples
```
> `@ub`(scan "0001" qib:ab)
0b1
```
```
> `@ub`(scan "1001" qib:ab)
0b1001
```
```
> `@ub`(scan "1" qib:ab)
{1 2}
syntax error
```
***
### `+qix:ab`
Parse 4 hex.
Parsing `$rule`. Parses exactly four hexadecimal digits - may have leading zeros.
#### Source
```hoon
++ qix (bass 16 (stun [4 4] six))
```
#### Examples
```
> `@ux`(scan "beef" qix:ab)
0xbeef
```
```
> `@ux`(scan "0000" qix:ab)
0x0
```
```
> `@ux`(scan "ef" qix:ab)
{1 3}
syntax error
```
***
### `+seb:ab`
Parse 1.
Parsing `$rule`. Parses the number 1.
#### Source
```hoon
++ seb (cold 1 (just '1'))
```
#### Examples
```
> (scan "1" seb:ab)
1
```
```
> (scan "2" seb:ab)
{1 1}
syntax error
```
***
### `+sed:ab`
Parse decimal.
Parsing `$rule`. Parses a nonzero decimal digit.
#### Source
```hoon
++ sed (cook |=(a=@ (sub a '0')) (shim '1' '9'))
```
#### Examples
```
> (scan "5" sed:ab)
5
```
```
> (scan "0" sed:ab)
{1 1}
syntax error
```
***
### `+sev:ab`
Parse base-32.
Parsing `$rule`. Parses a nonzero base-32 digit.
#### Source
```hoon
++ sev ;~(pose sed sov)
```
#### Examples
```
> `@uv`(scan "2" sev:ab)
0v2
```
```
> `@uv`(scan "j" sev:ab)
0vj
```
```
> `@uv`(scan "0" sev:ab)
{1 1}
syntax error
```
***
### `+sew:ab`
Parse base-64.
Parsing `$rule`. Parses a nonzero base-64 digit.
#### Source
```hoon
++ sew ;~(pose sed sow)
```
#### Examples
```
> `@uw`(scan "I" sew:ab)
0wI
```
```
> `@uw`(scan "2" sew:ab)
0w2
```
```
> `@uw`(scan "0" sew:ab)
{1 1}
syntax error
```
***
### `+sex:ab`
Parse hex.
Parsing `$rule`. Parses a non-zero hexadecimal digit.
#### Source
```hoon
++ sex ;~(pose sed sox)
```
#### Examples
```
> `@ux`(scan "a" sex:ab)
0xa
```
```
> `@ux`(scan "2" sex:ab)
0x2
```
```
> `@ux`(scan "0" sex:ab)
{1 1}
syntax error
```
***
### `+sib:ab`
Parse binary.
Parsing `$rule`. Parses a binary digit.
#### Source
```hoon
++ sib (cook |=(a=@ (sub a '0')) (shim '0' '1'))
```
#### Examples
```
> `@ub`(scan "1" sib:ab)
0b1
```
```
> `@ub`(scan "0" sib:ab)
0b0
```
***
### `+sid:ab`
Parse decimal.
Parsing `$rule`. Parses a decimal digit.
#### Source
```hoon
++ sid (cook |=(a=@ (sub a '0')) (shim '0' '9'))
```
#### Examples
```
> (scan "5" sid:ab)
5
```
```
> (scan "0" sid:ab)
0
```
***
### `+siv:ab`
Parse base-32.
Parsing `$rule`. Parses a base-32 digit.
#### Source
```hoon
++ siv ;~(pose sid sov)
```
#### Examples
```
> `@uv`(scan "r" siv:ab)
0vr
```
```
> `@uv`(scan "5" siv:ab)
0v5
```
```
> `@uv`(scan "0" siv:ab)
0v0
```
***
### `+siw:ab`
Parse base-64.
Parsing `$rule`. Parses a base-64 digit.
#### Source
```hoon
++ siw ;~(pose sid sow)
```
#### Examples
```
> `@uw`(scan "M" siw:ab)
0wM
```
```
> `@uw`(scan "0" siw:ab)
0w0
```
```
> `@uw`(scan "c" siw:ab)
0wc
```
***
### `+six:ab`
Parse hex.
Parsing `$rule`. Parses a hexadecimal digit.
#### Source
```hoon
++ six ;~(pose sid sox)
```
#### Examples
```
> `@ux`(scan "e" six:ab)
0xe
```
```
> `@ux`(scan "0" six:ab)
0x0
```
***
### `+sov:ab`
Parse `@uv` base-32 letter.
Parsing `$rule`. Parses a `@uv` base-32 letter (but not a number).
#### Source
```hoon
++ sov (cook |=(a=@ (sub a 87)) (shim 'a' 'v'))
```
#### Examples
```
> `@uv`(scan "c" sov:ab)
0vc
```
```
> `@uv`(scan "j" sov:ab)
0vj
```
```
> `@uv`(scan "5" sov:ab)
{1 1}
syntax error
```
***
### `+sow:ab`
Parse `@uw` base-64 letter/symbol.
Parsing `$rule`. Parses a base-64 letter/symbol (but not number).
#### Source
```hoon
++ sow ;~ pose
(cook |=(a=@ (sub a 87)) (shim 'a' 'z'))
(cook |=(a=@ (sub a 29)) (shim 'A' 'Z'))
(cold 62 (just '-'))
(cold 63 (just '~'))
==
```
#### Examples
```
> `@uw`(scan "M" sow:ab)
0wM
```
```
> `@uw`(scan "5" sow:ab)
{1 1}
syntax error
```
***
### `+sox:ab`
Parse hex letter.
Parsing `$rule`. Parses a hexadecimal letter (but not number).
#### Source
```hoon
++ sox (cook |=(a=@ (sub a 87)) (shim 'a' 'f'))
```
#### Examples
```
> `@ux`(scan "e" sox:ab)
0xe
```
```
> `@ux`(scan "5" sox:ab)
{1 1}
syntax error
```
***
### `+ted:ab`
Parse 1-999 decimal.
Parsing `$rule`. Parses a decimal number of up to 3 digits without a leading zero.
#### Source
```hoon
++ ted (bass 10 ;~(plug sed (stun [0 2] sid)))
```
#### Examples
```
> (scan "214" ted:ab)
214
```
```
> (scan "2" ted:ab)
2
```
```
> (scan "2161" ted:ab)
{1 4}
syntax error
```
***
### `+tep:ab`
Parse non-doz leading phonetic byte.
Parsing `$rule`. Parses the leading phonetic byte , which represents a syllable. Fails if it is `.doz`.
#### Source
```hoon
++ tep (sear |=(a=@ ?:(=(a 'doz') ~ (ins:po a))) til)
```
#### Examples
```
> (scan "sam" tep:ab)
4
```
```
> (scan "wic" tep:ab)
99
```
***
### `+tip:ab`
Leading phonetic byte.
Parsing `$rule`. Parses the leading phonetic byte, which represents a syllable.
#### Source
```hoon
++ tip (sear |=(a=@ (ins:po a)) til)
```
#### Examples
```
> (scan "doz" tip:ab)
0
```
```
> (scan "pit" tip:ab)
242
```
***
### `+tiq:ab`
Trailing phonetic syllable.
Parsing `$rule`. Parses the trailing phonetic byte, which represents a syllable.
#### Source
```hoon
++ tiq (sear |=(a=@ (ind:po a)) til)
```
#### Examples
```
> (scan "zod" tiq:ab)
0
```
```
> (scan "nec" tiq:ab)
1
```
***
### `+tid:ab`
Parse 3 decimal digits.
Parsing `$rule`. Parses exactly three decimal digits.
#### Source
```hoon
++ tid (bass 10 (stun [3 3] sid))
```
#### Examples
```
> (scan "013" tid:ab)
13
```
```
> (scan "999" tid:ab)
999
```
```
> (scan "99" tid:ab)
{1 3}
syntax error
```
***
### `+til:ab`
Parse 3 lowercase.
Parsing `$rule`. Parses exactly three lowercase letters.
#### Source
```hoon
++ til (boss 256 (stun [3 3] low))
```
#### Examples
```
> `@t`(scan "mer" til:ab)
'mer'
```
```
> `@t`(scan "me" til:ab)
{1 3}
syntax error
```
***
### `+urs:ab`
Parse knot characters.
Parsing `$rule`. Parses characters from an `$atom` of the knot aura `@ta`.
#### Source
```hoon
++ urs %+ cook
|=(a=tape (rap 3 ^-((list @) a)))
(star ;~(pose nud low hep dot sig cab))
```
#### Examples
```
> `@ta`(scan "asa-lom_tak" urs:ab)
~.asa-lom_tak
```
***
### `+urt:ab`
Parse knot without underscores.
Parsing `$rule`. Parses all characters of the knot aura `@ta` except for cab, `_`.
#### Source
```hoon
++ urt %+ cook
|=(a=tape (rap 3 ^-((list @) a)))
(star ;~(pose nud low hep dot sig))
```
#### Examples
```
> `@ta`(scan "asa-lom.t0k" urt:ab)
~.asa-lom.t0k
```
***
### `+voy:ab`
Parse `bas`, `soq`, or `bix`.
Parsing `$rule`. Parses an escaped backslash `\\`, single quote `\'`, or hex pair `\0a` byte.
#### Source
```hoon
++ voy ;~(pfix bas ;~(pose bas soq bix))
```
#### Examples
```
> (scan "\\\\" voy:ab)
'\\'
```
```
> (scan "\\'" voy:ab)
'\''
```
```
> (scan "\\0a" voy:ab)
'\0a'
```
***
## `+ag`
Top-level `$atom` parser engine.
A core containing top-level `$atom` parsers.
#### Source
```hoon
++ ag
|%
```
***
### `+ape:ag`
Parse `0` or `$rule`.
Parser modifier. Parses `0` or the sample `$rule` `.fel`.
#### Accepts
`.l` is a `$rule`.
#### Produces
A `$rule`.
#### Source
```hoon
++ ape |*(fel=rule ;~(pose (cold 0 (just '0')) fel))
```
#### Examples
```
> (scan "0" (ape:ag (cold 2 (just '2'))))
0
```
```
> (scan "2" (ape:ag (cold 2 (just '2'))))
2
```
```
> (scan "3" (ape:ag (cold 2 (just '2'))))
{1 1}
syntax error
```
***
### `+bay:ag`
Parses binary number.
Parsing `$rule`. Parses a binary number without a leading zero.
#### Source
```hoon
++ bay (ape (bass 16 ;~(plug qeb:ab (star ;~(pfix dog qib:ab)))))
```
#### Examples
```
> `@ub`(scan "101.1100.0011.1010" bay:ag)
0b101.1100.0011.1010
```
***
### `+bip:ag`
Parse IPv6.
Parsing `$rule`. Parses a `@is`, an IPv6 address.
#### Source
```hoon
++ bip =+ tod=(ape qex:ab)
(bass 0x1.0000 ;~(plug tod (stun [7 7] ;~(pfix dog tod))))
```
#### Examples
```
> `@is`(scan "0.0.ea.3e6c.0.0.0.0" bip:ag)
.0.0.ea.3e6c.0.0.0.0
```
***
### `+dem:ag`
Parse decimal with dots.
Parsing `$rule`. Parses a decimal number that includes dot separators.
#### Source
```hoon
++ dem (ape (bass 1.000 ;~(plug ted:ab (star ;~(pfix dog tid:ab)))))
```
#### Examples
```
> (scan "52" dem:ag)
52
```
```
> (scan "13.507" dem:ag)
13.507
```
***
### `+dim:ag`
Parse decimal number.
Parsing `$rule`. Parses a decimal number without a leading zero.
#### Source
```hoon
++ dim (ape dip)
```
#### Examples
```
> (scan "52" dim:ag)
52
```
```
> (scan "0" dim:ag)
0
```
```
> (scan "13507" dim:ag)
13.507
```
```
> (scan "013507" dim:ag)
{1 2}
syntax error
```
***
### `+dum:ag`
Parse decimal with leading `0`.
Parsing `$rule`. Parses a decmial number with leading zeroes.
#### Source
```hoon
++ dum (bass 10 (plus sid:ab))
```
#### Examples
```
> (scan "52" dum:ag)
52
```
```
> (scan "0000052" dum:ag)
52
```
```
> (scan "13507" dim:ag)
13.507
```
***
### `+fed:ag`
Parse phonetic base.
Parsing `$rule`. Parses an `$atom` of aura `@p`, the phonetic base.
#### Source
```hoon
++ fed %+ cook fynd:ob
;~ pose
%+ bass 0x1.0000.0000.0000.0000 :: oversized
;~ plug
huf:ab
(plus ;~(pfix doh hyf:ab))
==
hof:ab :: planet or moon
haf:ab :: star
tiq:ab :: galaxy
==
```
#### Examples
```
> `@p`(scan "zod" fed:ag)
~zod
```
```
> `@p`(scan "sampel" fed:ag)
~sampel
```
```
> `@p`(scan "sampel-palnet" fed:ag)
~sampel-palnet
```
```
> `@p`(scan "sampel-palnet-sampel-palnet" fed:ag)
~sampel-palnet-sampel-palnet
```
```
> `@p`(scan "tillyn-nillyt-tasfyn-partyv--novweb-talrud-talmud-sonfyr" fed:ag)
~tillyn-nillyt-tasfyn-partyv--novweb-talrud-talmud-sonfyr
```
***
### `+feq:ag`
Parse `@q` phonetic base.
Parsing `$rule`. Parses an `$atom` of aura `@q` (an unscrambled `@p`).
#### Source
```hoon
++ feq %+ cook |=(a=(list @) (rep 4 (flop a)))
;~ plug
;~(pose hif:ab tiq:ab)
(star ;~(pfix dof hif:ab))
==
```
#### Examples
```
> `@q`(scan "sampel" feq:ag)
.~sampel
```
```
> `@q`(scan "sampel-palnet" feq:ag)
.~sampel-palnet
```
```
> `@q`(scan "sampel-sampel-palnet" feq:ag)
.~sampel-sampel-palnet
```
```
> `@q`(scan "sampel-palnet-sampel-palnet" feq:ag)
.~sampel-palnet-sampel-palnet
```
```
> `@q`(scan "sampel-sampel-sampel-sampel-palnet-sampel-palnet" feq:ag)
.~sampel-sampel-sampel-sampel-palnet-sampel-palnet
```
***
### `+fim:ag`
Parse base58check.
Parse a base58check value, check checksum, and return decoded value sans-checksum. If the checksum check fails, parsing will fail.
#### Source
```hoon
++ fim (sear den:fa (bass 58 (plus fem:ab)))
```
#### Examples
With valid checksum:
```
> (enc:fa 0xdead.beef)
0xdead.beef.938b.8b0c
```
```
> (c-co:co 0xdead.beef.938b.8b0c)
"eFGDJSVvRHd"
```
```
> `@ux`(scan "eFGDJSVvRHd" fim:ag)
0xdead.beef
```
With invalid checksum:
```
> (c-co:co 0xdead.beef.ffff)
"2utUWE41U"
> `@ux`(scan "2utUWE41U" fim:ag)
{1 10}
syntax error
```
***
### `+hex:ag`
Parse hex.
Parsing `$rule`. Parses a hexadecimal number
#### Source
```hoon
++ hex (ape (bass 0x1.0000 ;~(plug qex:ab (star ;~(pfix dog qix:ab)))))
```
#### Examples
```
> `@ux`(scan "4" hex:ag)
0x4
```
```
> `@ux`(scan "1a" hex:ag)
0x1a
```
```
> `@ux`(scan "3.ac8d" hex:ag)
0x3.ac8d
```
***
### `+lip:ag`
Parse IPv4 address.
Parsing `$rule`. Parses an IPv4 address.
#### Source
```hoon
++ lip =+ tod=(ape ted:ab)
(bass 256 ;~(plug tod (stun [3 3] ;~(pfix dog tod))))
```
#### Examples
```
> `@if`(scan "127.0.0.1" lip:ag)
.127.0.0.1
```
***
### `+mot:ag`
Parse numerical month.
Parse a numerical month (1-12).
#### Source
```hoon
++ mot ;~ pose
;~ pfix
(just '1')
(cook |=(a=@ (add 10 (sub a '0'))) (shim '0' '2'))
==
sed:ab
==
```
#### Examples
```
> (scan "0" mot:ag)
{1 1}
syntax error
```
```
> (scan "1" mot:ag)
1
```
```
> (scan "6" mot:ag)
6
```
```
> (scan "12" mot:ag)
12
```
```
> (scan "13" mot:ag)
{1 2}
syntax error
```
***
### `+viz:ag`
Parse Base-32 with dots.
Parsing `$rule`. Parses a Base-32 number with dot separators.
#### Source
```hoon
++ viz (ape (bass 0x200.0000 ;~(plug pev:ab (star ;~(pfix dog piv:ab)))))
```
#### Examples
```
> `@uv`(scan "e2.ol4pm" viz:ag)
0ve2.ol4pm
```
***
### `+vum:ag`
Parse base-32 string.
Parsing `$rule`. Parses a raw base-32 string (without dots).
#### Source
```hoon
++ vum (bass 32 (plus siv:ab))
```
#### Examples
```
> `@uv`(scan "e2ol4pm" vum:ag)
0ve2.ol4pm
```
***
### `+wiz:ag`
Parse base-64.
Parsing `$rule`. Parses a base-64 number.
#### Source
```hoon
++ wiz (ape (bass 0x4000.0000 ;~(plug pew:ab (star ;~(pfix dog piw:ab)))))
```
#### Examples
```
> `@uw`(scan "e2O.l4Xpm" wiz:ag)
0we2O.l4Xpm
```
***
## `+mu`
Core used to scramble 16-bit `$atom`s.
A door that contains arms that are used to scramble two `$atom`s, `.p` and `.bot`. Used especially in the phonetic base to disguise the relationship between a planet and its star.
#### Accepts
`.p` is an `$atom`.
`.t` is an `$atom`.
#### Source
```hoon
++ mu
|_ [top=@ bot=@]
```
***
### `+zag:mu`
Add bottom into top.
Produces the cell of `.p` and `.t` with `.p` scrambled to the result of adding `.t` to `.p` modulo 16. Used to scramble the name of a planet.
#### Accepts
`.p` & `.t` are `$atom`s, and are the sample of `+mu`.
#### Produces
A `(pair @ @)`.
#### Source
```hoon
++ zag [p=(end 4 (add top bot)) q=bot]
```
#### Examples
```
> `[@ux @ux]`~(zag mu 0x20e0 0x201)
[0x22e1 0x201]
```
***
### `+zig:mu`
Subtract bottom from top.
The inverse of [`+zag`](#zagmu). Produces the cell of `.p` and `.t` with `.p` unscrambled. The unscrambled `.p` is the sum of the sample `.p` and the 16-bit complement of `.bot`. Used to unscramble the name of the planet.
#### Accepts
`.p` & `.t` are `$atom`s, and are the sample of `+mu`.
#### Produces
A `(pair @ @)`.
#### Source
```hoon
++ zig [p=(end 4 (add top (sub 0x1.0000 bot))) q=bot]
```
#### Examples
```
> `[@ux @ux]`~(zig mu 0x22e1 0x201)
[0x20e0 0x201]
```
***
### `+zug:mu`
Concatenate into `$atom`.
Produces the concatenation of `.p` and `.bot`. Used to assemble a planet name.
#### Accepts
`.p` & `.t` are `$atom`s, and are the sample of `+mu`.
#### Produces
An `$atom`.
#### Source
```hoon
++ zug (mix (lsh 4 top) bot)
```
#### Examples
```
> `@ux`~(zug mu 0x22e1 0x201)
0x22e1.0201
```
***
## `+ne`
Digit rendering engine.
A door containing arms that render digits at bases 10, 16, 32, and 64.
#### Accepts
`.g` is an `$atom`.
#### Source
```hoon
++ ne
|_ tig=@
```
***
### `+c:ne`
Render base58check.
Render a single base58check character.
#### Accepts
`.g` is an `$atom`, and is the sample of `+ne`.
#### Produces
An `$atom`.
#### Source
```hoon
++ c (cut 3 [tig 1] key:fa)
```
#### Examples
```
> `@t`~(c ne 7)
'8'
```
```
> `@t`~(c ne 27)
'U'
```
```
> `@t`~(c ne 57)
'z'
```
```
> `@t`~(c ne 58)
''
```
***
### `+d:ne`
Render decimal.
Renders a decimal digit as an `$atom` of an ACII byte value.
#### Accepts
`.g` is an `$atom`, and is the sample of `+ne`.
#### Produces
An `$atom`.
#### Source
```hoon
++ d (add tig '0')
```
#### Examples
```
> `@t`~(d ne 7)
'7'
```
***
### `+x:ne`
Render hex.
Renders a hexadecimal digit as an `$atom` of an ASCII byte value.
#### Accepts
`.g` is an `$atom`, and is the sample of `+ne`.
#### Produces
An `$atom`.
#### Source
```hoon
++ x ?:((gte tig 10) (add tig 87) d)
```
#### Examples
```
> `@t`~(x ne 7)
'7'
```
```
> `@t`~(x ne 14)
'e'
```
***
### `+v:ne`
Render base-32.
Renders a base-32 digit as an `$atom` of an ASCII byte value.
#### Accepts
`.g` is an `$atom`, and is the sample of `+ne`.
#### Produces
An `$atom`.
#### Source
```hoon
++ v ?:((gte tig 10) (add tig 87) d)
```
#### Examples
```
> `@t`~(v ne 7)
'7'
```
```
> `@t`~(v ne 14)
'e'
```
```
> `@t`~(v ne 25)
'p'
```
***
### `+w:ne`
Render base-64.
Renders a base-64 digit as an `$atom` of an ASCII byte value.
#### Accepts
`.g` is an `$atom`, and is the sample of `+ne`.
#### Produces
An `$atom`.
#### Source
```hoon
++ w ?:(=(tig 63) '~' ?:(=(tig 62) '-' ?:((gte tig 36) (add tig 29) x)))
```
#### Examples
```
> `@t`~(w ne 7)
'7'
```
```
> `@t`~(w ne 14)
'e'
```
```
> `@t`~(w ne 25)
'p'
```
```
> `@t`~(w ne 52)
'Q'
```
```
> `@t`~(w ne 61)
'Z'
```
```
> `@t`~(w ne 63)
'~'
```
```
> `@t`~(w ne 62)
'-'
```
***