+++
title = "4j: Parsing (Bases and Base Digits)"
weight = 37
template = "doc.html"
+++
### `++ab`

Primitive parser engine

A core containing numeric parser primitives.

#### Source

```
    ++  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.

#### Accepts

XX

#### Produces

A an atom. XX

#### Source

```
      ++  bix  (bass 16 (stun [2 2] six))
```

#### Examples

```
    > (scan "07" bix:ab)
    q=7
    > (scan "51" bix:ab)
    q=81
    > (scan "a3" bix:ab)
    q=163
```

------------------------------------------------------------------------

### `++hif:ab`

Parse phonetic pair

Parsing `++rule`. Parses an atom of odor `@pE`, a phrase of two bytes
encoded phonetically.

#### Accepts

XX

#### Produces

An atom.

#### Source

```
      ++  hif  (boss 256 ;~(plug tip tiq (easy ~)))
```

#### Examples

```
    > (scan "doznec" hif:ab)
    q=256
    > (scan "pittyp" hif:ab)
    q=48.626
```

------------------------------------------------------------------------

### `++huf:ab`

Parse two phonetic pairs

Parsing `++rule`. Parses and unscrambles an atom of odor @pF, a phrase
of two two-byte pairs that are encoded (and scrambled) phonetically.

#### Accepts

XX

#### Produces

An atom. XX

#### Source

```
      ++  huf  %+  cook
                   |=([a/@ b/@] (wred:un ~(zug mu ~(zag mu [a b]))))
                 ;~(plug hif ;~(pfix hep hif))
```

#### Examples

```
    > (scan "pittyp-pittyp" huf:ab)
    328.203.557
    > (scan "tasfyn-partyv" huf:ab)
    65.792
    > `@ux`(scan "tasfyn-partyv" huf:ab)
    0x1.0100
```

------------------------------------------------------------------------

### `++hyf:ab`

Parse 8 phonetic bytes

Parsing `++rule`. Parses an atom of odor @pG, a phrase of eight of
phonetic bytes.

#### Accepts

An atom of odor `@pG`

#### Produces

An atom. XX

#### Source

```
      ++  hyf  (bass 0x1.0000.0000 ;~(plug huf ;~(pfix hep huf) (easy ~)))
```

#### Examples

```
    > (scan "sondel-forsut-tillyn-nillyt" hyf:ab)
    q=365.637.097.828.335.095
    > `@u`~sondel-forsut-tillyn-nillyt
    365.637.097.828.335.095
```

------------------------------------------------------------------------

### `++pev:ab`

Parse \<= 5 base-32

Parsing `++rule`. Parses up to five base-32 digits without a leading zero.

#### Accepts

Up to five @uv (base 64) digits.

#### Produces

An atom.

#### Source

```
      ++  pev  (bass 32 ;~(plug sev (stun [0 4] siv)))
```

#### Examples

```
    > (scan "a" pev:ab)
    q=10
    > (scan "290j" pev:ab)
    q=74.771
    > (scan "123456" pev:ab)
    ! {1 6}
    ! exit
    > (scan "090j" pev:ab)
    ~ <syntax error at [1 11]>
```

------------------------------------------------------------------------

### `++pew:ab`

Parse \<= 5 base-64

Parsing `++rule`. Parses up to five base-64 digits without a leading zero.

#### Accepts

Up to five @uw (base 64) digits.

#### Produces



#### Source

```
      ++  pew  (bass 64 ;~(plug sew (stun [0 4] siw)))
```

#### Examples

```
    > (scan "Q" pew:ab)
    q=52
    > (scan "aQ~9" pew:ab)
    q=2.838.473
    > `@`0waQ~9
    2.838.473
    > (scan "123456" pew:ab)
    ! {1 6}
    ! exit
    > (scan "012345" pew:ab)
    ! {1 1}
    ! exit
```

------------------------------------------------------------------------

### `++piv:ab`

Parse 5 base-32

Parsing `++rule`. Parses exactly five base-32 digits.

#### Accepts

#### Produces

#### Source

```
      ++  piv  (bass 32 (stun [5 5] siv))
```

#### Examples

```
    > (scan "10b3l" piv:ab)
    q=1.059.957
    > (scan "1" piv:ab)
    ! {1 2}
    ! exit
```

------------------------------------------------------------------------

### `++piw:ab`

Parse 5 base-64

Parsing `++rule`. Parses exactly five base-64 digits.

#### Accepts

#### Produces

#### Source

```
      ++  piw  (bass 64 (stun [5 5] siw))
```

#### Examples

```
    > (scan "2C-pZ" piw:ab)
    q=43.771.517
    > (scan "2" piv:ab)
    ! {1 2}
    ! exit
```


------------------------------------------------------------------------

### `++qeb:ab`

Parse \<= 4 binary

Parsing `++rule`. Parses a binary number of up to 4 digits in length without
a leading zero.

#### Accepts

#### Produces

#### Source

```
      ++  qeb  (bass 2 ;~(plug seb (stun [0 3] sib)))
```

#### Examples

```
    > (scan "1" qeb:ab)
    q=1
    > (scan "101" qeb:ab)
    q=5
    > (scan "1111" qeb:ab)
    q=15
    > (scan "11111" qeb:ab)
    ! {1 5}
    ! exit
    > (scan "01" qeb:ab)
    ! {1 1}
    ! exit
```

------------------------------------------------------------------------

### `++qex:ab`

Parse \<= 4 hex

Parsing `++rule`. Parses a hexadecimal number of up to 4 digits in length
without a leading zero.

#### Accepts

#### Produces

#### Source

```
      ++  qex  (bass 16 ;~(plug sex (stun [0 3] hit)))
```

#### Examples

```
    > (scan "ca" qex:ab)
    q=202
    > (scan "18ac" qex:ab)
    q=6.316
    > (scan "18acc" qex:ab)
    ! {1 5}
    ! exit
    > (scan "08ac" qex:ab)
    ! {1 1}
    ! exit
```

------------------------------------------------------------------------

### `++qib:ab`

Parse 4 binary

Parsing `++rule`. Parses exactly four binary digits.

#### Accepts

#### Produces

#### Source

```
      ++  qib  (bass 2 (stun [4 4] sib))
```

#### Examples

```
    > (scan "0001" qib:ab)
    q=1
    > (scan "0100" qib:ab)
    q=4
    > (scan "110" qib:ab)
    ! {1 4}
    ! exit
```

------------------------------------------------------------------------

### `++qix:ab`

Parse 4 hex

Parsing `++rule`. Parses exactly four hexadecimal digits.

#### Accepts

#### Produces

#### Source

```
      ++  qix  (bass 16 (stun [4 4] six))
```

#### Examples

```
    > (scan "0100" qix:ab)
    q=256
    > (scan "10ff" qix:ab)
    q=4.351
    > (scan "0" qix:ab)
    ! {1 2}
    ! exit
```

------------------------------------------------------------------------

### `++seb:ab`

Parse 1

Parsing `++rule`. Parses the number 1.

#### Accepts

#### Produces

#### Source

```
      ++  seb  (cold 1 (just '1'))
```

#### Examples

```
    > (scan "1" seb:ab)
    1
    > (scan "0" seb:ab)
    ! ~zod/try/~2014.10.23..22.34.21..bfdd/:<[1 1].[1 18]>
    ! {1 1}
    > (scan "2" seb:ab)
    ! ~zod/try/~2014.10.23..22.34.29..d399/:<[1 1].[1 18]>
    ! {1 1}
```

------------------------------------------------------------------------

### `++sed:ab`

Parse decimal

Parsing `++rule`. Parses a nonzero decimal digit.

#### Accepts

#### Produces

#### Source

```
      ++  sed  (cook |=(a/@ (sub a '0')) (shim '1' '9'))
```

#### Examples

```
    > (scan "5" sed:ab)
    5
    > (scan "0" sed:ab)
    ! {1 1}
    ! exit
```

------------------------------------------------------------------------

### `++sev:ab`

Parse base-32

Parsing `++rule`. Parses a nonzero base-32 digit

#### Accepts

#### Produces

#### Source

```
      ++  sev  ;~(pose sed sov)
```

#### Examples

```
    > (scan "c" sev:ab)
    12
    ~zod/socialnet=> (scan "0" sev:ab)
    ! {1 1}
    ! exit
```

------------------------------------------------------------------------

### `++sew:ab`

Parse base-64

Parsing `++rule`. Parses a nonzero base-64 digit

#### Accepts

#### Produces

#### Source

```
      ++  sew  ;~(pose sed sow)
```

#### Examples

```
    > (scan "M" sew:ab)
    48
    > (scan "0" sew:ab)
    ! {1 1}
    ! exit
```

------------------------------------------------------------------------

### `++sex:ab`

Parse hex

Parsing `++rule`. Parses a nonzero hexadecimal digit.

#### Accepts

#### Produces

#### Source

```
      ++  sex  ;~(pose sed sox)
```

#### Examples

```
    > (scan "e" sex:ab)
    14
    > (scan "0" sex:ab)
    ! {1 1}
    ! exit
```

------------------------------------------------------------------------

### `++sib:ab`

Parse binary

Parsing `++rule`. Parses a binary digit.

#### Accepts

#### Produces

#### Source

```
      ++  sib  (cook |=(a/@ (sub a '0')) (shim '0' '1'))
```

#### Examples

```
    > (scan "1" sib:ab)
    1
    ~zod/socialnet=> (scan "0" sib:ab)
    0
```

------------------------------------------------------------------------

### `++sid:ab`

Parse decimal

Parsing `++rule`. Parses a decimal digit.

#### Accepts

#### Produces

#### Source

```
      ++  sid  (cook |=(a/@ (sub a '0')) (shim '0' '9'))
```

#### Examples

```
    > (scan "5" sid:ab)
    5
```

------------------------------------------------------------------------

### `++siv:ab`

Parse base-32

Parsing `++rule`. Parses a base-32 digit.

#### Accepts

#### Produces

#### Source

```
      ++  siv  ;~(pose sid sov)
```

#### Examples

```
    > (scan "c" siv:ab)
    12
```

------------------------------------------------------------------------

### `++siw:ab`

Parse base-64

Parsing `++rule`. Parses a base-64 digit.

#### Accepts

#### Produces

#### Source

```
      ++  siw  ;~(pose sid sow)
```

#### Examples

```
    > (scan "M" siw:ab)
    48
```

------------------------------------------------------------------------

### `++six:ab`

Parse hex

Parsing `++rule`. Parses a hexadecimal digit.

#### Accepts

#### Produces

#### Source

```
      ++  six  ;~(pose sid sox)
```

#### Examples

```
    > (scan "e" six:ab)
    14
```

------------------------------------------------------------------------

### `++sov:ab`

Parse base-32

Parsing `++rule`. Parses a base-32 letter.

#### Accepts

#### Produces

#### Source

```
      ++  sov  (cook |=(a/@ (sub a 87)) (shim 'a' 'v'))
```

#### Examples

```
    > (scan "c" sov:ab)
    12
```
------------------------------------------------------------------------

### `++sow:ab`

Parse base-64

Parsing `++rule`. Parses a base-64 letter/symbol.

#### Accepts

#### Produces

#### Source

```
      ++  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

```
    > (scan "M" sow:ab)
    48
```

------------------------------------------------------------------------

### `++sox:ab`

Parse hex letter

Parsing `++rule`. Parses a hexadecimal letter.

#### Accepts

#### Produces

#### Source

```
      ++  sox  (cook |=(a/@ (sub a 87)) (shim 'a' 'f'))
```

#### Examples

```
    > (scan "e" sox:ab)
    14
```

------------------------------------------------------------------------

### `++ted:ab`

Parse \<= 3 decimal

Parsing `++rule`. Parses a decimal number of up to 3 digits without a
leading zero.

#### Accepts

#### Produces

#### Source

```
      ++  ted  (bass 10 ;~(plug sed (stun [0 2] sid)))
```

#### Examples

```
    > (scan "21" ted:ab)
    q=21
    > (scan "214" ted:ab)
    q=214
    > (scan "2140" ted:ab)
    {1 4}
    > (scan "0" ted:ab)
    ! {1 1}
    ! exit
```

------------------------------------------------------------------------

### `++tip:ab`

Leading phonetic byte

Parsing `++rule`. Parses the leading phonetic byte, which represents a
syllable.

#### Accepts

#### Produces

#### Source

```
      ++  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.

#### Accepts

#### Produces

#### Source

```
      ++  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.

#### Accepts

#### Produces

#### Source

```
      ++  tid  (bass 10 (stun [3 3] sid))
```

#### Examples

```
    > (scan "013" tid:ab)
    q=13
    > (scan "01" tid:ab)
    ! {1 3}
    ! exit
```

------------------------------------------------------------------------

### `++til:ab`

Parse 3 lowercase

Parsing `++rule`. Parses exactly three lowercase letters.

#### Accepts

#### Produces

#### Source

```
      ++  til  (boss 256 (stun [3 3] low))
```

#### Examples

```
    > (scan "mer" til:ab)
    q=7.497.069
    > `@t`(scan "mer" til:ab)
    'mer'
    > (scan "me" til:ab)
    ! {1 3}
    ! exit
```

------------------------------------------------------------------------

### `++urs:ab`

Parse span characters

Parsing rule. Parses characters from an atom of the span odor `@ta`.

#### Accepts

#### Produces

#### Source

```
      ++  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
    > `@t`(scan "asa-lom_tak" urs:ab)
    'asa-lom_tak'
```

------------------------------------------------------------------------

### `++urt:ab`

Parse non-`_` span

Parsing rule. Parses all characters of the span odor `@ta` except
for cab, `_`.

#### Accepts

#### Produces

#### Source

```
      ++  urt  %+  cook
                 |=(a/tape (rap 3 ^-((list @) a)))
               (star ;~(pose nud low hep dot sig))
```

#### Examples

```
    > `@t`(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
byte.

#### Accepts

#### Produces

#### Source

```
      ++  voy  ;~(pfix bas ;~(pose bas soq bix))
```

#### Examples

```
    > (scan "\\0a" voy:ab)
    q=10
    > (scan "\\'" voy:ab)
    q=39
```

------------------------------------------------------------------------

### `++ag`

Top-level atom parser engine

A core containing top-level atom parsers.

#### Accepts

#### Produces

#### Source

```
    ++  ag
      |%
```

#### Examples

```
    > ag
    <14.vpu 414.mof 100.xkc 1.ypj %164>
```

------------------------------------------------------------------------

### `++ape:ag`

Parse 0 or rule

Parser modifier. Parses 0 or the sample rule `fel`.

#### Accepts

#### Produces

`fel` is a `rule`.

#### Source

```
      ++  ape  |*(fel/rule ;~(pose (cold 0 (just '0')) fel))
```

#### Examples

```
    > (scan "202" (star (ape:ag (cold 2 (just '2')))))
    ~[2 0 2]
```

------------------------------------------------------------------------

### `++bay:ag`

Parses binary number

Parsing rule. Parses a binary number without a leading zero.

#### Accepts

#### Produces

#### Source

```
      ++  bay  (ape (bass 16 ;~(plug qeb:ab (star ;~(pfix dog qib:ab)))))
```

#### Examples

```
    > (scan "10.0110" bay:ag)
    q=38
```

------------------------------------------------------------------------

### `++bip:ag`

Parse IPv6

Parsing rule. Parses a `@is`, an IPv6 address.

#### Accepts

#### Produces

#### Source

```
      ++  bip  =+  tod=(ape qex:ab)
               (bass 0x1.0000 ;~(plug tod (stun [7 7] ;~(pfix dog tod))))
```

#### Examples

```
    > (scan "0.0.ea.3e6c.0.0.0.0" bip:ag)
    q=283.183.420.760.121.105.516.068.864
    > `@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.

#### Accepts

#### Produces

#### Source

```
      ++  dem  (ape (bass 1.000 ;~(plug ted:ab (star ;~(pfix dog tid:ab)))))
```

#### Examples

```
    > (scan "52" dem:ag)
    q=52
    > (scan "13.507" dem:ag)
    q=13.507
```

------------------------------------------------------------------------

### `++dim:ag`

Parse decimal number

Parsing rule. Parses a decimal number without a leading zero.

#### Accepts

#### Produces

#### Source

```
      ++  dim  (ape (bass 10 ;~(plug sed:ab (star sid:ab))))
```

#### Examples

```
    > (scan "52" dim:ag)
    q=52
    > (scan "013507" dim:ag)
    ! {1 2}
    ! exit
```

------------------------------------------------------------------------

### `++dum:ag`

Parse decimal with leading `0`

Parsing rule. Parses a decmial number with leading zeroes.

#### Accepts

#### Produces

#### Source

```
      ++  dum  (bass 10 (plus sid:ab))
```

#### Examples

```
    > (scan "52" dum:ag)
    q=52
    > (scan "0000052" dum:ag)
    q=52
    > (scan "13507" dim:ag)
    q=13.507
```

------------------------------------------------------------------------

### `++fed:ag`

Parse phonetic base

Parsing rule. Parses an atom of odor `@p`, the phonetic base.

#### Accepts

#### Produces

#### Source

```
      ++  fed  ;~  pose
                 (bass 0x1.0000.0000.0000.0000 (most doh hyf:ab))
                 huf:ab
                 hif:ab
                 tiq:ab
               ==
```

#### Examples

```
    > (scan "zod" fed:ag)
    0
    > (scan "nec" fed:ag)
    1
    > (scan "sondel" fed:ag)
    9.636
    > ~tillyn-nillyt
    ~tillyn-nillyt
    > (scan "tillyn-nillyt" fed:ag)
    3.569.565.175
    > (scan "tillyn-nillyt-tasfyn-partyv" fed:ag)
    15.331.165.687.565.582.592
    > (scan "tillyn-nillyt-tasfyn-partyv--novweb-talrud-talmud-sonfyr" fed:ag)
    282.810.089.790.159.633.869.501.053.313.363.681.181
```

------------------------------------------------------------------------

### `++hex:ag`

Parse hex

Parsing rule. Parses a hexadecimal number

#### Accepts

#### Produces

#### Source

```
      ++  hex  (ape (bass 0x1.0000 ;~(plug qex:ab (star ;~(pfix dog qix:ab)))))
```

#### Examples

```
    > (scan "4" hex:ag)
    q=4
    > (scan "1a" hex:ag)
    q=26
    > (scan "3.ac8d" hex:ag)
    q=240.781
    > `@ux`(scan "3.ac8d" hex:ag)
    0x3.ac8d
```

------------------------------------------------------------------------

### `++lip:ag`

Parse IPv4 address

Parsing rule. Parses an IPv4 address.

#### Accepts

#### Produces

#### Source

```
      ++  lip  =+  tod=(ape ted:ab)
               (bass 256 ;~(plug tod (stun [3 3] ;~(pfix dog tod))))
```

#### Examples

```
    > (scan "127.0.0.1" lip:ag)
    q=2.130.706.433
    > `@if`(scan "127.0.0.1" lip:ag)
    .127.0.0.1
    > `@if`(scan "8.8.8.8" lip:ag)
    .8.8.8.8
```

------------------------------------------------------------------------

### `++viz:ag`

Parse Base-32 with dots

Parsing rule. Parses a Base-32 number with dot separators.

#### Accepts

#### Produces

#### Source

```
      ++  viz  (ape (bass 0x200.0000 ;~(plug pev:ab (star ;~(pfix dog piv:ab)))))
```

#### Examples

```
    > (scan "e2.ol4pm" viz:ag)
    q=15.125.353.270
```

------------------------------------------------------------------------

### `++vum:ag`

Parse base-32 string

Parsing rule. Parses a raw base-32 string.

#### Accepts

#### Produces

#### Source

```
      ++  vum  (bass 32 (plus siv:ab))
```

#### Examples

```
    > (scan "e2ol4pm" vum:ag)
    q=15.125.353.270
```

------------------------------------------------------------------------

### `++wiz:ag`

Parse base-64

Parsing rule. Parses a base-64 number.

#### Accepts

#### Produces

#### Source

```
      ++  wiz  (ape (bass 0x4000.0000 ;~(plug pew:ab (star ;~(pfix dog piw:ab)))))
      --
    ::
```

#### Examples

```
    > (scan "e2O.l4Xpm" wiz:ag)
    q=61.764.130.813.526
```

---
### `++mu`

Core used to scramble 16-bit atoms

A door that contains arms that are used to scramble two atoms, `top`
and `bot`. Used especially in the phonetic base to disguise the
relationship between a destroyer and its cruiser.

#### Accepts

#### Produces

`bot` is an atom.

`top` is an atom.

#### Source

```
    ++  mu
      |_  [top/@ bot/@]
```

#### Examples

```
    > ~(. mu 0x20e5 0x5901)
    <3.sjm [[@ux @ux] <414.hhh 100.xkc 1.ypj %164>]>
```

------------------------------------------------------------------------

### `++zag:mu`

Add bottom into top

Produces the cell of `top` and `bot` with `top` scrambled to the result
of adding `bot` to `top` modulo 16. Used to scramble the name of a
destroyer.

#### Accepts

#### Produces

`bot` is an atom.

`top` is an atom.

#### Source

```
      ++  zag  [p=(end 4 1 (add top bot)) q=bot]
```

#### Examples

```
    > `[@ux @ux]`~(zag mu 0x20e0 0x201)
    [0x22e1 0x201]
```

------------------------------------------------------------------------

### `++zig:mu`

Subtract bottom from top

The inverse of `++zag`. Produces the cell of `top` and `bot` with
`top` unscrambled. The unscrambled `top` is the sum of the sample `top`
and the 16-bit complement of `bot`. Used to unscramble the name of the
destroyer.

#### Accepts

#### Produces

`bot` is an atom.

`top` is an atom.

#### Source

```
      ++  zig  [p=(end 4 1 (add top (sub 0x1.0000 bot))) q=bot]
```

#### Examples

```
    > `[@ux @ux]`~(zig mu 0x2f46 0x1042)
    [0x1f04 0x1042]
```

------------------------------------------------------------------------

### `++zug:mu`

Concatenate into atom

Produces the concatenation of `top` and `bot`. Used to assemble a
destroyer name.

#### Accepts

#### Produces

`bot` is an atom.

`top` is an atom.

#### Source

```
      ++  zug  (mix (lsh 4 1 top) bot)
```

#### Examples

```
    > `@ux`~(zug mu 0x10e1 0xfa)
    0x10e1.00fa
```


---
### `++ne`

Digit rendering engine

A door containing arms that render digits at bases 10, 16, 32, and
64.

#### Accepts

#### Produces

`tig` is an `atom`.

#### Source

```
    ++  ne
      |_  tig/@
```

#### Examples

```
    > ~(. ne 20)
    <4.gut [@ud <414.hhh 100.xkc 1.ypj %164>]>
```

------------------------------------------------------------------------

### `++d:ne`

Render decimal

Renders a decimal digit as an atom of an ACII byte value.

#### Accepts

#### Produces

`tig` is an `atom`.

#### Source

```
      ++  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

#### Produces

`tig` is an `atom`.

#### Source

```
      ++  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

#### Produces

#### Source

```
      ++  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

#### Produces

`tig` is an `atom`.

#### Source

```
      ++  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)
    '-'
```


---