collected algol 68 productions

algol.txt

# 1.2.1. Metaproduction rules of modes
  (A) MODE :: PLAIN ; STOWED ; REF to MODE ; PROCEDURE ; UNITED ; MU definition of MODE ; MU application.
  (B) PLAIN :: INTREAL ; boolean ; character.
  (C) INTREAL :: SIZETY integral ; SIZETY real.
  (D) SIZETY :: long LONGSETY ; short SHORTSETY ; EMPTY.
  (E) LONGSETY :: long LONGSETY ; EMPTY.
  (F) SHORTSETY :: short SHORTSETY ; EMPTY.
  (G) EMPTY :: .
  (H) STOWED :: structured with FIELDS mode ; FLEXETY ROWS of MODE.
  (I) FIELDS :: FIELD ; FIELDS FIELD.
  (J) FIELD :: MODE field TAG{942A}.
  (K) FLEXETY :: flexible ; EMPTY.
  (L) ROWS :: row ; ROWS row.
  (M) REF :: reference ; transient reference.
  (N) PROCEDURE :: procedure PARAMETY yielding MOID.
  (O) PARAMETY :: with PARAMETERS ; EMPTY.
  (P) PARAMETERS :: PARAMETER ; PARAMETERS PARAMETER.
  (Q) PARAMETER :: MODE parameter.
  (R) MOID :: MODE ; void.
  (S) UNITED :: union of MOODS mode.
  (T) MOODS :: MOOD ; MOODS MOOD.
  (U) MOOD :: PLAIN ; STOWED ; reference to MODE ; PROCEDURE ; void.
  (V) MU :: muTALLY.
  (W) TALLY :: i ; TALLY i.

# 1.2.2. Metaproduction rules associated with phrases and coercion
  (A) ENCLOSED :: closed ; collateral ; parallel ; CHOICE{34A} ; loop.
  (B) SOME :: SORT MOID NEST.
  (C) SORT :: strong ; firm ; meek ; weak ; soft.

# 1.2.3. Metaproduction rules associated with nests
  (A) NEST :: LAYER ; NEST LAYER.
  (B) LAYER :: new DECSETY LABSETY.
  (C) DECSETY :: DECS ; EMPTY.
  (D) DECS :: DEC ; DECS DEC.
  (E) DEC :: MODE TAG{942A} ; priority PRIO TAD{942F} ; MOID TALLY TAB{942D} ; DUO TAD{942F} ; MONO TAM{942K}.
  (F) PRIO :: i ; ii ; iii ; iii i ; iii ii ; iii iii ; iii iii i ; iii iii ii ; iii iii iii.
  (G) MONO :: procedure with PARAMETER yielding MOID.
  (H) DUO :: procedure with PARAMETER1 PARAMETER2 yielding MOID.
  (I) LABSETY :: LABS ; EMPTY.
  (J) LABS :: LAB ; LABS LAB.
  (K) LAB :: label TAG{942A}.
  (A) NOTION :: ALPHA ; NOTION ALPHA.
  (B) ALPHA :: a ; b ; c ; d ; e ; f ; g ; h ; i ; j ; k ; l ; m ; n ; o ; p ; q ; r ; s ; t ; u ; v ; w ; x ; y ; z.
  (C) NOTETY :: NOTION ; EMPTY.
  (D) THING :: NOTION ; (NOTETY1) NOTETY2 ; THING (NOTETY1) NOTETY2.
  (E) WHETHER :: where ; unless.
  (a) where true : EMPTY.
  (b) unless false : EMPTY.
  (c) where THING1 and THING2 : where THING1, where THING2.
  (d) where THING1 or THING2 : where THING1 ; where THING2.
  (e) unless THING1 and THING2 : unless THING1 ; unless THING2.
  (f) unless THING1 or THING2 : unless THING1, unless THING2.
  (g) WHETHER (NOTETY1) is (NOTETY2) : WHETHER (NOTETY1) begins with (NOTETY2){h,i,j} and (NOTETY2) begins with (NOTETY1){h,i,j}.
  (h) WHETHER (EMPTY) begins with (NOTION){g,j} : WHETHER false{b,-}.
  (i) WHETHER (NOTETY) begins with (EMPTY){g,j} : WHETHER true{a,-}.
  (j) WHETHER (ALPHA1 NOTETY1) begins with (ALPHA2 NOTETY2){g,j,m} : WHETHER (ALPHA1) coincides with (ALPHA2) in (abcdefghijklmnopqrstuvwxyz){k,l,-} and (NOTETY1) begins with (NOTETY2){h,i,j}.
  (k) where (ALPHA) coincides with (ALPHA) in (NOTION){j} : where true{a}.
  (l) unless (ALPHA1) coincides with (ALPHA2) in (NOTION){j} : where (NOTION) contains (ALPHA1 NOTETY ALPHA2){m} or (NOTION) contains (ALPHA2 NOTETY ALPHA1){m}.
  (m) WHETHER (ALPHA NOTETY) contains (NOTION){l,m} : WHETHER (ALPHA NOTETY) begins with (NOTION){j} or (NOTETY) contains (NOTION){m,n}.
  (n) WHETHER (EMPTY) contains (NOTION){m} : WHETHER false{b,-}.

# 1.3.3. Syntax of general constructions
  (A) STYLE :: brief ; bold ; style TALLY.
  (a) NOTION option : NOTION ; EMPTY.
  (b) NOTION sequence{b} : NOTION ; NOTION, NOTION sequence{b}.
  (c) NOTION list{c} : NOTION ; NOTION, and also{94f} token, NOTION list{c}.
  (d) NOTETY STYLE pack : STYLE begin{94f,-} token, NOTETY, STYLE end{94f,-} token.
  (e) NOTION STYLE bracket : STYLE sub{94f,-} token, NOTION, STYLE bus{94f,-} token.
  (f) THING1 or alternatively THING2 : THING1 ; THING2.
  (a) program : strong void new closed clause{31a}.
  (a) *phrase : SOME unit{32d} ; NEST declaration of DECS{41a}.
  (b) *SORT MODE expression : SORT MODE NEST UNIT{5A}.
  (c) *statement : strong void NEST UNIT{5A}.
  (d) *MOID constant : MOID NEST DEFIED identifier with TAG{48a,b} ; MOID NEST denoter{80a}.
  (e) *MODE variable : reference to MODE NEST DEFIED identifier with TAG{48a,b}.
  (f) *NEST range : SOID NEST serial clause defining LAYER{32a} ; SOID NEST chooser CHOICE STYLE clause{34b} ; SOID NEST case part of choice using UNITED{34i} ; NEST STYLE repeating part with DEC{35e} ; NEST STYLE while do part{35f} ; PROCEDURE NEST routine text{541a,b}.
  (A) SOID :: SORT MOID.
  (B) PACK :: STYLE pack.
  (a) SOID NEST closed clause{22a,5D,551a,A341h,A349a} : SOID NEST serial clause defining LAYER{32a} PACK.

# 3.2.1. Syntax
  (a) SOID NEST serial clause defining new PROPSETY{31a,34f,l,35h} : SOID NEST new PROPSETY series with PROPSETY{b}.
  (b) SOID NEST series with PROPSETY{a,b,34c} : strong void NEST unit{d}, go on{94f} token, SOID NEST series with PROPSETY{b} ; where (PROPSETY) is (DECS DECSETY LABSETY), NEST declaration of DECS{41a}, go on{94f} token, SOID NEST series with DECSETY LABSETY{b} ; where (PROPSETY) is (LAB LABSETY), NEST label definition of LAB{c}, SOID NEST series with LABSETY{b} ; where (PROPSETY) is (LAB LABSETY) and SOID balances SOID1 and SOID2{e}, SOID1 NEST unit{d}, completion{94f} token, NEST label definition of LAB{c}, SOID2 NEST series with LABSETY{b} ; where (PROPSETY) is (EMPTY), SOID NEST unit{d}.
  (c) NEST label definition of label TAG{b} : label NEST defining identifier with TAG{48a}, label{94f} token.
  (d) SOME unit{b,33b,g,34i,35d,46m,n,521c,532e,541a,b,543c,A34Ab,c,d} : SOME UNIT{5A,-}.
  (e) WHETHER SORT MOID balances SORT1 MOID1 and SORT2 MOID2{b,33b,34d,h} : WHETHER SORT balances SORT1 and SORT2{f} and MOID balances MOID1 and MOID2{g}.
  (f) WHETHER SORT balances SORT1 and SORT2{e,522a} : where (SORT1) is (strong), WHETHER (SORT2) is (SORT) ; where (SORT2) is (strong), WHETHER (SORT1) is (SORT).
  (g) WHETHER MOID balances MOID1 and MOID2{e} : where (MOID1) is (MOID2), WHETHER (MOID) is (MOID1) ; where (MOID1) is (transient MOID2), WHETHER (MOID) is (MOID1) ; where (MOID2) is (transient MOID1), WHETHER (MOID) is (MOID2).
  (h) *SOID unitary clause : SOID NEST unit{d}.
  (i) *establishing clause : SOID NEST serial clause defining LAYER{32a} ; MODE NEST enquiry clause defining LAYER{34c}.

# 3.3.1. Syntax
  (a) strong void NEST collateral clause{5D,551a} : strong void NEST joined portrait{b} PACK.
  (b) SOID NEST joined portrait{a,b,c,d,34g} : where SOID balances SOID1 and SOID2{32e}, SOID1 NEST unit{32d}, and also{94f} token, SOID2 NEST unit{32d} or alternatively SOID2 NEST joined portrait{b}.
  (c) strong void NEST parallel clause{5D,551a} : parallel{94f} token, strong void NEST joined portrait{b} PACK.
  (d) strong ROWS of MODE NEST collateral clause{5D,551a} : where (ROWS) is (row), strong MODE NEST joined portrait{b} PACK ; where (ROWS) is (row ROWS1), strong ROWS1 of MODE NEST joined portrait{b} PACK ; EMPTY PACK.
  (e) strong structured with FIELDS FIELD mode NEST collateral clause{5D,551a} : NEST FIELDS FIELD portrait{f} PACK.
  (f) NEST FIELDS FIELD portrait{e,f} : NEST FIELDS portrait{f,g}, and also{94f} token, NEST FIELD portrait{g}.
  (g) NEST MODE field TAG portrait{f} : strong MODE NEST unit{32d}.
  (h) *structure display : strong structured with FIELDS FIELD mode NEST collateral clause{e}.
  (i) *row display : strong ROWS of MODE NEST collateral clause{d}.
  (j) *display : strong STOWED NEST collateral clause{d,e}.
  (k) *vacuum : EMPTY PACK.

# 3.4.1. Syntax
  (A) CHOICE :: choice using boolean ; CASE.
  (B) CASE :: choice using integral ; choice using UNITED.
  (a) SOID NEST1 CHOICE clause{5D,551a,A341h,A349a} : CHOICE STYLE start{91a,-}, SOID NEST1 chooser CHOICE STYLE clause{b}, CHOICE STYLE finish{91e,-}.
  (b) SOID NEST1 chooser choice using MODE STYLE clause{a,l} : MODE NEST1 enquiry clause defining LAYER2{c,-}, SOID NEST1 LAYER2 alternate choice using MODE STYLE clause{d}.
  (c) MODE NEST1 enquiry clause defining new DECSETY2{b,35g} : meek MODE NEST1 new DECSETY2 series with DECSETY2{32b}.
  (d) SOID NEST2 alternate CHOICE STYLE clause{b} : SOID NEST2 in CHOICE STYLE clause{e} ; where SOID balances SOID1 and SOID2{32e}, SOID1 NEST2 in CHOICE STYLE clause{e}, SOID2 NEST2 out CHOICE STYLE clause{l}.
  (e) SOID NEST2 in CHOICE STYLE clause{d} : CHOICE STYLE in{91b,-}, SOID NEST2 in part of CHOICE{f,g,h}.
  (f) SOID NEST2 in part of choice using boolean{e} : SOID NEST2 serial clause defining LAYER3{32a}.
  (g) SOID NEST2 in part of choice using integral{e} : SOID NEST2 joined portrait{33b}.
  (h) SOID NEST2 in part of choice using UNITED{e,h} : SOID NEST2 case part of choice using UNITED{i} ; where SOID balances SOID1 and SOID2{32e}, SOID1 NEST2 case part of choice using UNITED{i}, and also{94f} token, SOID2 NEST2 in part of choice using UNITED{h}.
  (i) SOID NEST2 case part of choice using UNITED{H} : MOID NEST2 LAYER3 specification defining LAYER3{j,k,-}, where MOID unites to UNITED{64b}, SOID NEST2 LAYER3 unit{32d}.
  (j) MODE NEST3 specification defining new MODE TAG3{i} : NEST3 declarative defining new MODE TAG3{541e} brief pack, colon{94f} token.
  (k) MOID NEST3 specification defining new EMPTY{i} : formal MOID NEST3 declarer{46b} brief pack, colon{94f} token.
  (l) SOID NEST2 out CHOICE STYLE clause{d} : CHOICE STYLE out{91d,-}, SOID NEST2 serial clause defining LAYER3{32a} ; CHOICE STYLE again{91c,-}, SOID NEST2 chooser CHOICE2 STYLE clause{b}, where CHOICE2 may follow CHOICE{m}.
  (m) WHETHER choice using MODE2 may follow choice using MODE1{l} : where (MODE1) is (MOOD),#WHETHER (MODE2) is (MODE1) ; where (MODE1) begins with (union of), WHETHER (MODE2) begins with (union of).
  (n) *SOME choice clause : SOME CHOICE clause{a}.
  (o) *SOME conditional clause : SOME choice using boolean clause{a}.
  (p) *SOME case clause : SOME choice using integral clause{a}.
  (q) *SOME conformity clause : SOME choice using UNITED clause{a}.

# 3.5.1. Syntax
  (A) FROBYT :: from ; by ; to.
  (a) strong void NEST1 loop clause{5D,551a} : NEST1 STYLE for part defining new integral TAG2{b}, NEST1 STYLE intervals{c}, NEST1 STYLE repeating part with integral TAG2{e}.
  (b) NEST1 STYLE for part defining new integral TAG2{a} : STYLE for{94g,-} token, integral NEST1 new integral TAG2 defining identifier with TAG2{48a} ; where (TAG2) is (letter aleph), EMPTY.
  (c) NEST1 STYLE intervals{a} : NEST1 STYLE from part{d} option, NEST1 STYLE by part{d} option, NEST1 STYLE to part{d} option.
  (d) NEST1 STYLE FROBYT part{c} : STYLE FROBYT{94g,-} token, meek integral NEST1 unit{32d}.
  (e) NEST1 STYLE repeating part with DEC2{a} : NEST1 new DEC2 STYLE while do part{f} ; NEST1 new DEC2 STYLE do part{h}.
  (f) NEST2 STYLE while do part{e} : NEST2 STYLE while part defining LAYER3{g}, NEST2 LAYER3 STYLE do part{h}.
  (g) NEST2 STYLE while part defining LAYER3{f} : STYLE while{94g,-} token, boolean NEST2 enquiry clause defining LAYER3{34c,-}.
  (h) NEST3 STYLE do part{e,f} : STYLE do{94g,-} token, strong void NEST3 serial clause defining LAYER4{32a}, STYLE od{94g,-} token.

# 4.1.1. Syntax
  (A) COMMON :: mode ; priority ; MODINE identity ; reference to MODINE variable ; MODINE operation ; PARAMETER ; MODE FIELDS.
  (a) NEST declaration of DECS{a,32b} : NEST COMMON declaration of DECS{42a,43a,44a,e,45a,-} ; where (DECS) is (DECS1 DECS2), NEST COMMON declaration of DECS1{42a,43a,44a,e,45a,-}, and also{94f} token, NEST declaration of DECS2{a}.
  (b) NEST COMMON joined definition of PROPS PROP {b,42a,43a,44a,e,45a,46e,541e} : NEST COMMON joined definition of PROPS{b,c}, and also{94f} token, NEST COMMON joined definition of PROP{c}.
  (c) NEST COMMON joined definition of PROP {b,42a,43a,44a,e,45a,46e,541e} : NEST COMMON definition of PROP${42b,43b,44c,f,45c,46f,541f,-}.
  (d) *definition of PROP : NEST COMMON definition of PROP {42b,43b,44c,f,45c,46f,541f} ; NEST label definition of PROP{32c}.
  (a) NEST mode declaration of DECS{41a} : mode{94d} token, NEST mode joined definition of DECS{41b,c}.
  (b) NEST mode definition of MOID TALLY TAB{41c} : where (TAB) is (bold TAG) or (NEST) is (new LAYER), MOID TALLY NEST defining mode indication with TAB{48a}, is defined as{94d} token, actual MOID TALLY NEST declarer{c}.
  (c) actual MOID TALLY1 NEST declarer{b} : where (TALLY1) is (i), actual MOID NEST declarator{46c,d,g,h,o,s,-} ; where (TALLY1) is (TALLY2 i), MOID TALLY2 NEST applied mode indication with TAB2 {48b}.

# 4.4.1. Syntax
  (A) MODINE :: MODE ; routine.
  (B) LEAP :: local ; heap ; primal.
  (a) NEST MODINE identity declaration of DECS{41a} : formal MODINE NEST declarer{b,46b}, NEST MODINE identity joined definition of DECS{41b,c}.
  (b) VICTAL routine NEST declarer{a,523b} : procedure{94d} token.
  (c) NEST MODINE identity definition of MODE TAG{41c} : MODE NEST defining identifier with TAG{48a}, is defined as{94d} token, MODE NEST source for MODINE{d}.
  (d) MODE NEST source for MODINE{c,f,45c} : where (MODINE) is (MODE), MODE NEST source{521c} ; where (MODINE) is (routine), MODE NEST routine text{541a,b,-}.
  (e) NEST reference to MODINE variable declaration of DECS{41a} : reference to MODINE NEST LEAP sample generator{523b}, NEST reference to MODINE variable joined definition of DECS{41b,c}.
  (f) NEST reference to MODINE variable definition of reference to MODE TAG{41c} : reference to MODE NEST defining identifier with TAG{48a}, becomes{94c} token, MODE NEST source for MODINE{d} ; where (MODINE) is (MODE), reference to MODE NEST defining identifier with TAG{48a}.
  (g) *identifier declaration : NEST MODINE identity declaration of DECS{a} ; NEST reference to MODINE variable declaration of DECS{e}.

# 4.5.1. Syntax
  (A) PRAM :: DUO ; MONO.
  (B) TAO :: TAD ; TAM.
  (a) NEST MODINE operation declaration of DECS{41a} : operator{94d} token, formal MODINE NEST plan{b,46p,-}, NEST MODINE operation joined definition of DECS{41b,c}.
  (b) formal routine NEST plan{a} : EMPTY.
  (c) NEST MODINE operation definition of PRAM TAO{41c} : PRAM NEST defining operator with TAO{48a}, is defined as{94d} token, PRAM NEST source for MODINE{44d}.

# 4.6.1. Syntax
  (A) VICTAL :: VIRACT ; formal.
  (B) VIRACT :: virtual ; actual.
  (C) MOIDS :: MOID ; MOIDS MOID.
  (a) VIRACT MOID NEST declarer{c,e,g,h,523a,b} : VIRACT MOID NEST declarator{c,d,g,h,o,s,-} ; MOID TALLY NEST applied mode indication with TAB{48b,-}.
  (b) formal MOID NEST declarer{e,h,p,r,u,34k,44a,541a,b,e,551a} : where MOID deflexes to MOID{47a,b,c,-}, formal MOID NEST declarator{c,d,h,o,s,-} ; MOID1 TALLY NEST applied mode indication with TAB{48b,-}, where MOID1 deflexes to MOID{47a,b,c,-}.
  (c) VICTAL reference to MODE NEST declarator{a,b,42c} : reference to{94d} token, virtual MODE NEST declarer{a}.
  (d) VICTAL structured with FIELDS mode NEST declarator${a,b,42c} : structure{94d} token, VICTAL FIELDS NEST portrayer of FIELDS{e} brief pack.
  (e) VICTAL FIELDS NEST portrayer of FIELDS1{d,e} : VICTAL MODE NEST declarer{a,b}, NEST MODE FIELDS joined definition of FIELDS1{41b,c} ; where (FIELDS1) is (FIELDS2 FIELDS3), VICTAL MODE NEST declarer{a,b}, NEST MODE FIELDS joined definition of FIELDS2{41b,c}, and also{94f} token, VICTAL FIELDS NEST portrayer of FIELDS3{e}.
  (f) NEST MODE FIELDS definition of MODE field TAG{41c} : MODE field FIELDS defining field selector with TAG{48c}.
  (g) VIRACT flexible ROWS of MODE NEST declarator{a,42c} : flexible{94d} token, VIRACT ROWS of MODE NEST declarer{a}.
  (h) VICTAL ROWS of MODE NEST declarator{a,b,42c} : VICTAL ROWS NEST rower{i,j,k,l} STYLE bracket, VICTAL MODE NEST declarer{a,b}.
  (i) VICTAL row ROWS NEST rower{h,i} : VICTAL row NEST rower{j,k,l}, and also{94f} token, VICTAL ROWS NEST rower{i,j,k,l}.
  (j) actual row NEST rower{h,i} : NEST lower bound{m}, up to{94f} token, NEST upper bound{n} ; NEST upper bound{n}.
  (k) virtual row NEST rower{h,i} : up to{94f} token option.
  (l) formal row NEST rower{h,i} : up to{94f} token option.
  (m) NEST lower bound{j,532f,g} : meek integral NEST unit{32d}.
  (n) NEST upper bound{j,532f} : meek integral NEST unit{32d}.
  (o) VICTAL PROCEDURE NEST declarator{a,b,42c} : procedure{94d} token, formal PROCEDURE NEST plan{p}.
  (p) formal procedure PARAMETY yielding MOID NEST plan{o,45a} : where (PARAMETY) is (EMPTY), formal MOID NEST declarer{b} ; where (PARAMETY) is (with PARAMETERS), PARAMETERS NEST joined declarer{q,r} brief pack, formal MOID NEST declarer{b}.
  (q) PARAMETERS PARAMETER NEST joined declarer{p,q} : PARAMETERS NEST joined declarer{q,r}, and also{94f} token, PARAMETER NEST joined declarer{r}.
  (r) MODE parameter NEST joined declarer{p,q} :
 formal MODE NEST declarer{b}.
  (s) VICTAL union of MOODS1 MOOD1 mode NEST declarator{a,b,42c} : unless EMPTY with MOODS1 MOOD1 incestuous{47f}, union#of{94d}#token, MOIDS NEST joined declarer{t,u} brief pack, where MOIDS ravels to MOODS2{47g} and safe MOODS1 MOOD1 subset of safe MOODS2{73l} and safe MOODS2 subset of safe MOODS1 MOOD1{73l,m}.
  (t) MOIDS MOID NEST joined declarer{s,t} : MOIDS NEST joined declarer{t,u}, and also{94f} token, MOID NEST joined declarer{u}.
  (u) MOID NEST joined declarer{s,t} : formal MOID NEST declarer{b}.

# 4.7.1. Syntax
  (A) NONSTOWED :: PLAIN ; REF to MODE ; PROCEDURE ; UNITED ; void.
  (B) MOODSETY :: MOODS ; EMPTY.
  (C) MOIDSETY :: MOIDS ; EMPTY.
  (a) WHETHER NONSTOWED deflexes to NONSTOWED {b,e,46b,521c,62a,71n} : WHETHER true.
  (b) WHETHER FLEXETY ROWS of MODE1 deflexes to ROWS of MODE2${b,e,46b,521c,62a,71n} : WHETHER MODE1 deflexes to MODE2${a,b,c,-}.
  (c) WHETHER structured with FIELDS1 mode deflexes to structured with FIELDS2 mode{b,e,46b,521c,62a,71n} : WHETHER FIELDS1 deflexes to FIELDS2{d,e,-}.
  (d) WHETHER FIELDS1 FIELD1 deflexes to FIELDS2 FIELD2{c,d} : WHETHER FIELDS1 deflexes to FIELDS2{d,e,-} and FIELD1 deflexes to FIELD2{e,-}.
  (e) WHETHER MODE1 field TAG deflexes to MODE2 field TAG{c,d} : WHETHER MODE1 deflexes to MODE2{a,b,c,-}.
  (f) WHETHER MOODSETY1 with MOODSETY2 incestuous{f,46s} : where (MOODSETY2) is (MOOD MOODSETY3), WHETHER MOODSETY1 MOOD with MOODSETY3 incestuous{f} or MOOD is firm union of MOODSETY1 MOODSETY3 mode${71m} ; where (MOODSETY2) is (EMPTY), WHETHER false.
  (g) WHETHER MOIDS ravels to MOODS{g,46s} : where (MOIDS) is (MOODS), WHETHER true ; where (MOIDS) is (MOODSETY union of MOODS1 mode MOIDSETY), WHETHER MOODSETY MOODS1 MOIDSETY ravels to MOODS{g}.

# 4.8.1. Syntax
  (A) INDICATOR :: identifier ; mode indication ; operator.
  (B) DEFIED :: defining ; applied.
  (C) POPSETY :: PROPS ; EMPTY.
  (D) POPS :: PROP ; PROPS PROP.
  (E) PROP :: DEC ; LAB ; FIELD.
  (F) QUALITY :: MODE ; MOID TALLY ; DYADIC ; label ; MODE field.
  (G) TAX :: TAG ; TAB ; TAD ; TAM.
  (a) QUALITY NEST new PROPSETY1 QUALITY TAX PROPSETY2 defining INDICATOR with TAX${32c, 35b,42b,43b,44c,f,45c,541f} : where QUALITY TAX independent PROPSETY1 PROPSETY2 {71a,b,c}, TAX{942A,D,F,K} token.
  (b) QUALITY NEST applied INDICATOR with TAX {42c,46a,b,5D,542a,b,544a} : where QUALITY TAX identified in NEST{72a}, TAX{942A,D,F,K} token.
  (c) MODE field PROPSETY1 MODE field TAG PROPSETY2 defining field selector with TAG{46f} : where MODE field TAG independent PROPSETY1 PROPSETY2 {71a,b,c}, TAG {942A} token.
  (d) MODE field FIELDS applied field selector with TAG{531a} : where MODE field TAG resides in FIELDS{72b,c,-}, TAG{942A} token.
  (e) *QUALITY NEST DEFIED indicator with TAX : QUALITY NEST DEFIED INDICATOR with TAX{a,b}.
  (f) *MODE DEFIED field selector with TAG : MODE field FIELDS DEFIED field selector with TAG{c,d}.

# 5.1. Syntax
  (A) UNIT{32d} :: assignation{521a} coercee ; identity relation{522a} coercee ; routine text{541a,b} coercee ; jump{544a} ; skip{552a} ; TERTIARY{B}.
  (B) TERTIARY{A,521b,522a} :: ADIC formula{542a,b} coercee ; nihil{524a} ; SECONDARY{C}.
  (C) SECONDARY{B,531a,542c} :: LEAP generator{523a} coercee ; selection{531a} coercee ; PRIMARY{D}.
  (D) PRIMARY{C,532a,543a} :: slice{532a} coercee ; call{543a} coercee ; cast{551a} coercee ; denoter{80a} coercee ; format text{A341a} coercee ; applied identifier with TAG{48b} coercee ; ENCLOSED clause{31a,33a,c,d,e,34a,35a}.

# 5.2.1.1. Syntax
  (a) REF to MODE NEST assignation{5A} : REF to MODE NEST destination{b}, becomes{94c} token, MODE NEST source{c}.
  (b) REF to MODE NEST destination{a} : soft REF to MODE NEST TERTIARY{5B}.
  (c) MODE1 NEST source{a,44d} : strong MODE2 NEST unit{32d}, where MODE1 deflexes to MODE2{47a,b,c,-}.

# 5.2.2.1. Syntax
  (a) boolean NEST identity relation{5A} : where soft balances SORT1 and SORT2{32f}, SORT1 reference to MODE NEST TERTIARY1{5B}, identity relator{b}, SORT2 reference to MODE NEST TERTIARY2{5B}.
  (b) identity relator{a} : is{94f} token ; is not{94f} token.
  (a) reference to MODE NEST LEAP generator{5C} : LEAP{94d,-} token, actual MODE NEST declarer{46a}.
  (b) reference to MODINE NEST LEAP sample generator{44e} : LEAP{94d,-} token, actual MODINE NEST declarer{44b,46a} ; where (LEAP) is (local), actual MODINE NEST declarer{44b,46a}.

# 5.2.4.1. Syntax
  (a) strong reference to MODE NEST nihil{5B} : nil{94f} token.

# 5.3.1.1. Syntax
  (A) REFETY :: REF to ; EMPTY.
  (B) REFLEXETY :: REF to ; REF to flexible ; EMPTY.
  (a) REFETY MODE1 NEST selection{5C} : MODE1 field FIELDS applied field selector with TAG{48d}, of {94f} token, weak REFETY structured with FIELDS mode NEST SECONDARY{5C} ; where (MODE1) is (ROWS of MODE2), MODE2 field FIELDS applied field selector with TAG{48d}, of{94f} token, weak REFLEXETY ROWS of structured with FIELDS mode NEST SECONDARY{5C}, where (REFETY) is derived from (REFLEXETY){b,c,-}.
  (b) WHETHER (transient reference to) is derived from (REF to flexible){a,532a,66a} : WHETHER true.
  (c) WHETHER (REFETY) is derived from (REFETY){a,532a,66a} : WHETHER true.

# 5.3.2.1. Syntax
  (A) ROWSETY :: ROWS ; EMPTY.
  (a) REFETY MODE1 NEST slice{5D} : weak REFLEXETY ROWS1 of MODE1 NEST PRIMARY{5D}, ROWS1 leaving EMPTY NEST indexer{b,c,-} STYLE bracket, where (REFETY) is derived from (REFLEXETY){531b,c,-} ; where (MODE1) is (ROWS2 of MODE2), weak REFLEXETY ROWS1 of MODE2 NEST PRIMARY{5D}, ROWS1 leaving ROWS2 NEST indexer{b,d,-} STYLE bracket, where (REFETY) is derived from (REFLEXETY){531b,c,-}.
  (b) row ROWS leaving ROWSETY1 ROWSETY2 NEST indexer{a,b} : row leaving ROWSETY1 NEST indexer{c,d,-}, and also{94f} token, ROWS leaving ROWSETY2 NEST indexer{b,c,d,-}.
  (c) row leaving EMPTY NEST indexer{a,b} : NEST subscript{e}.
  (d) row leaving row NEST indexer{a,b} : NEST trimmer{f} ; NEST revised lower bound{g} option.
  (e) NEST subscript{c} : meek integral NEST unit{32d}.
  (f) NEST trimmer{d} : NEST lower bound{46m} option, up to{94f} token, NEST upper bound{46n} option, NEST revised lower bound{g} option.
  (g) NEST revised lower bound{d,f} : at{94f} token, NEST lower bound{46m}.
  (h) *trimscript : NEST subscript{e} ; NEST trimmer{f} ; NEST revised lower bound{g} option.
  (i) *indexer : ROWS leaving ROWSETY NEST indexer{b,c,d}.
  (j) *boundscript : NEST subscript{e} ; NEST lower bound{46m} ; NEST upper bound{46n} ; NEST revised lower bound{g}.

# 5.4.1.1. Syntax
  (a) procedure yielding MOID NEST1 routine text{44d,5A} : formal MOID NEST1 declarer{46b}, routine{94f} token, strong MOID NEST1 unit{32d}.
  (b) procedure with PARAMETERS yielding MOID NEST1 routine text{44d,5A} : NEST1 new DECS2 declarative defining new DECS2{e} brief pack, where DECS2 like PARAMETERS{c,d,-}, formal MOID NEST1 declarer{46b}, routine{94f} token, strong MOID NEST1 new DECS2 unit{32d}.
  (c) WHETHER DECS DEC like PARAMETERS PARAMETER{b,c} : WHETHER DECS like PARAMETERS{c,d,-} and DEC like PARAMETER{d,-}.
  (d) WHETHER MODE TAG like MODE parameter{b,c} : WHETHER true.
  (e) NEST2 declarative defining new DECS2{b,e,34j} : formal MODE NEST2 declarer{46b}, NEST2 MODE parameter joined definition of DECS2{41b,c} ; where (DECS2) is (DECS3 DECS4), formal MODE NEST2 declarer{46b}, NEST2 MODE parameter joined definition of DECS3{41b,c}, and also{94f} token, NEST2 declarative defining new DECS4{e}.
  (f) NEST2 MODE parameter definition of MODE TAG2{41c} : MODE NEST2 defining identifier with TAG2{48a}.
  (g) *formal MODE parameter : NEST MODE parameter definition of MODE TAG{f}.

# 5.4.2.1. Syntax
  (A) DYADIC :: priority PRIO.
  (B) MONADIC :: priority iii iii iii i.
  (C) ADIC :: DYADIC ; MONADIC.
  (D) TALLETY :: TALLY ; EMPTY.
  (a) MOID NEST DYADIC formula{c,5B} : MODE1 NEST DYADIC TALLETY operand{c,-}, procedure with MODE1 parameter MODE2 parameter yielding MOID NEST applied operator with TAD{48b}, where DYADIC TAD identified in NEST{72a}, MODE2 NEST DYADIC TALLY operand{c,-}.
  (b) MOID NEST MONADIC formula{c,5B} : procedure with MODE parameter yielding MOID NEST applied operator with TAM {48b}, MODE NEST MONADIC operand{c}.
  (c) MODE NEST ADIC operand{a,b} : firm MODE NEST ADIC formula{a,b} coercee{61b} ; where (ADIC) is (MONADIC), firm MODE NEST SECONDARY{5C}.
  (d) *MOID formula : MOID NEST ADIC formula{a,b}.
  (e) *DUO dyadic operator with TAD : DUO NEST DEFIED operator with TAD{48a,b}.
  (f) *MONO monadic operator with TAM : MONO NEST DEFIED operator with TAM{48a,b}.
  (g) *MODE operand : MODE NEST ADIC operand{c}.

# 5.4.3.1. Syntax
  (a) MOID NEST call{5D} : meek procedure with PARAMETERS yielding MOID NEST PRIMARY{5D}, actual NEST PARAMETERS{b,c} brief pack.
  (b) actual NEST PARAMETERS PARAMETER{a,b} : actual NEST PARAMETERS{b,c}, and also{94f} token, actual NEST PARAMETER{c}.
  (c) actual NEST MODE parameter{a,b} : strong MODE NEST unit{32d}.

# 5.4.4.1. Syntax
  (a) strong MOID NEST jump{5A} : go to{b} option, label NEST applied identifier with TAG{48b}.
  (b) go to{a} : STYLE go to{94f,-} token ; STYLE go{94f,-} token, STYLE to symbol{94g,-}.

# 5.5.1.1. Syntax
  (a) MOID NEST cast{5D} : formal MOID NEST declarer{46b}, strong MOID NEST ENCLOSED clause{31a,33a,c,d,e,34a,35a,-}.

# 5.5.2.1. Syntax
  (a) strong MOID NEST skip{5A} : skip{94f} token.

# 6.1.1. Syntax
  (A) STRONG{a,66a} :: FIRM{B} ; widened to{65a,b,c,d} ; rowed to{66a} ; voided to{67a,b}.
  (B) FIRM{A,b} :: MEEK{C} ; united to{64a}.
  (C) MEEK{B,c,d,62a,63a,64a,65a,b,c,d} :: unchanged from{f} ; dereferenced to{62a} ; deprocedured to{63a}.
  (D) SOFT{e,63b} :: unchanged from{f} ; softly deprocedured to{63b}.
  (E) FORM :: MORF ; COMORF.
  (F) MORF :: NEST selection ; NEST slice ; NEST routine text ; NEST ADIC formula ; NEST call ; NEST applied identifier with TAG.
  (G) COMORF :: NEST assignation ; NEST identity relation ; NEST LEAP generator ; NEST cast ; NEST denoter ; NEST format text.
  (a) strong MOID FORM coercee{5A,B,C,D,A341i} : where (FORM) is (MORF), STRONG{A} MOID MORF ; where (FORM) is (COMORF), STRONG{A} MOID COMORF, unless (STRONG MOID) is (deprocedured to void).
  (b) firm MODE FORM coercee{5A,B,C,D,542c} : FIRM{B} MODE FORM.
  (c) meek MOID FORM coercee{5A,B,C,D} : MEEK{C} MOID FORM.
  (d) weak REFETY STOWED FORM coercee{5A,B,C,D} : MEEK{C} REFETY STOWED FORM, unless (MEEK) is (dereferenced to) and (REFETY) is (EMPTY).
  (e) soft MODE FORM coercee{5A,B,C,D} : SOFT{D} MODE FORM.
  (f) unchanged from MOID FORM{C,D,67a,b} : MOID FORM.
  (g) *SORT MOID coercee : SORT MOID FORM coercee{a,b,c,d,e}.
  (h) *MOID coercend : MOID FORM.

# 6.2.1. Syntax
  (a) dereferenced to{61C} MODE1 FORM : MEEK{61C} REF to MODE2 FORM, where MODE2 deflexes to MODE1{47a,b,c,-}.

# 6.3.1. Syntax
  (a) deprocedured to{61C,67a} MOID FORM : MEEK{61C} procedure yielding MOID FORM.
  (b) softly deprocedured to{61D} MODE FORM : SOFT{61D} procedure yielding MODE FORM.

# 6.4.1. Syntax
  (a) united to{61B} UNITED FORM : MEEK{61C} MOID FORM, where MOID unites to UNITED{b}.
  (b) WHETHER MOID1 unites to MOID2{a,34i,71m} : where MOID1 equivalent MOID2{73a}, WHETHER false ; unless MOID1 equivalent MOID2{73a}, WHETHER safe MOODS1 subset of safe MOODS2{73l,m,n}, where (MOODS1) is (MOID1) or (union of MOODS1 mode) is (MOID1), where (MOODS2) is (MOID2) or (union of MOODS2 mode) is (MOID2).

# 6.5.1. Syntax
  (A) BITS :: structured with row of boolean field SITHETY letter aleph mode.
  (B) BYTES :: structured with row of character field SITHETY letter aleph mode.
  (C) SITHETY :: LENGTH LENGTHETY ; SHORTH SHORTHETY ; EMPTY.
  (D) LENGTH :: letter l letter o letter n letter g.
  (E) SHORTH :: letter s letter h letter o letter r letter t.
  (F) LENGTHETY :: LENGTH LENGTHETY ; EMPTY.
  (G) SHORTHETY :: SHORTH SHORTHETY ; EMPTY.
  (a) widened to{b,61A} SIZETY real FORM : MEEK{61C} SIZETY integral FORM.
  (b) widened to{61A} structured with SIZETY real field letter r letter e SIZETY real field letter i letter m mode FORM : MEEK{61C} SIZETY real FORM ; widened to{a} SIZETY real FORM.
  (c) widened to{61A} row of boolean FORM : MEEK{61C} BITS FORM.
  (d) widened to{61A} row of character FORM : MEEK{61C} BYTES FORM.

# 6.6.1. Syntax
  (a) rowed to{61A} REFETY ROWS1 of MODE FORM : where (ROWS1) is (row), STRONG{61A} REFLEXETY MODE FORM, where (REFETY) is derived from (REFLEXETY){531b,c,-} ; where (ROWS1) is (row ROWS2), STRONG{61A} REFLEXETY ROWS2 of MODE FORM, where (REFETY) is derived from (REFLEXETY){531b,c,-}.

# 6.7.1. Syntax
  (A) NONPROC :: PLAIN ; STOWED ; REF to NONPROC ; procedure with PARAMETERS yielding MOID ; UNITED.
  (a) voided to{61A} void MORF : deprocedured to{63a} NONPROC MORF ; unchanged from{61f} NONPROC MORF.
  (b) voided to{61A} void COMORF : unchanged from{61f} MODE COMORF.

# 7.1.1. Syntax
  (A) PREF :: procedure yielding ; REF to.
  (B) NONPREF :: PLAIN ; STOWED ; procedure with PARAMETERS yielding MOID ; UNITED ; void.
  (C) *PREFSETY :: PREF PREFSETY ; EMPTY.
  (a) WHETHER PROP1 independent PROPS2 PROP2{a,48a,c,72a} : WHETHER PROP1 independent PROPS2{a,c} and PROP1 independent PROP2{c}.
  (b) WHETHER PROP independent EMPTY{48a,c,72a} : WHETHER true.
  (c) WHETHER QUALITY1 TAX1 independent QUALITY2 TAX2{a,48a,c,72a} : unless (TAX1) is (TAX2), WHETHER true ; where (TAX1) is (TAX2) and (TAX1) is (TAO), WHETHER QUALITY1 independent QUALITY2{d}.
  (d) WHETHER QUALITY1 independent QUALITY2{c} : where QUALITY1 related QUALITY2{e,f,g,h,i,j,-}, WHETHER false ; unless QUALITY1 related QUALITY2{e,f,g,h,i,j,-}, WHETHER true.
  (e) WHETHER MONO related DUO{d} : WHETHER false.
  (f) WHETHER DUO related MONO{d} : WHETHER false.
  (g) WHETHER PRAM related DYADIC{d} : WHETHER false.
  (h) WHETHER DYADIC related PRAM{d} : WHETHER false.
  (i) WHETHER procedure with MODE1 parameter MODE2 parameter yielding MOID1 related procedure with MODE3 parameter MODE4 parameter yielding MOID2{d} : WHETHER MODE1 firmly related MODE3{k} and MODE2 firmly related MODE4{k}.
  (j) WHETHER procedure with MODE1 parameter yielding MOID1 related procedure with MODE2 parameter yielding MOID2{d} : WHETHER MODE1 firmly related MODE2{k}.
  (k) WHETHER MOID1 firmly related MOID2{i,j} : WHETHER MOODS1 is firm MOID2{l,m} or MOODS2 is firm MOID1{l,m}, where (MOODS1) is (MOID1) or (union of MOODS1 mode) is (MOID1), where (MOODS2) is (MOID2) or (union of MOODS2 mode) is (MOID2).
  (l) WHETHER MOODS MOOD is firm MOID{k,l} : WHETHER MOODS is firm MOID{l,m} or MOOD is firm MOID{m}.
  (m) WHETHER MOID1 is firm MOID2{k,l,n,47f} : WHETHER MOID1 equivalent MOID2{73a} or MOID1 unites to MOID2{64b} or MOID1 deprefs to firm MOID2{n}.
  (n) WHETHER MOID1 deprefs to firm MOID2{m} : where (MOID1) is (PREF MOID3), WHETHER MOID5 is firm MOID2{m}, where MOID3 deflexes to MOID5{47a,b,c} ; where (MOID1) is (NONPREF), WHETHER false.

# 7.2.1. Syntax
  (a) WHETHER PROP identified in NEST new PROPSETY{a,48b,542a} : where PROP resides in PROPSETY{b,c,-}, WHETHER true ; where PROP independent PROPSETY{71a,b,c}, WHETHER PROP identified in NEST{a,-}.
  (b) WHETHER PROP1 resides in PROPS2 PROP2{a,b,48d} : WHETHER PROP1 resides in PROP2{c,-} or PROP1 resides in PROPS2{b,c,-}.
  (c) WHETHER QUALITY1 TAX resides in QUALITY2 TAX{a,b,48d} : where (QUALITY1) is (label) or (QUALITY1) is (DYADIC) or (QUALITY1) is (MODE field), WHETHER (QUALITY1) is (QUALITY2) ; where (QUALITY1) is (MOID1 TALLETY) and (QUALITY2) is (MOID2 TALLETY), WHETHER MOID1 equivalent MOID2{73a}.

# 7.3.1. Syntax
  (A) SAFE :: safe ; MU has MODE SAFE ; yin SAFE ; yang SAFE ; remember MOID1 MOID2 SAFE.
  (B) HEAD :: PLAIN ; PREF{71A} ; structured with ; FLEXETY ROWS of ; procedure with ; union of ; void.
  (C) TAILETY :: MOID ; FIELDS mode ; PARAMETERS yielding MOID ; MOODS mode ; EMPTY.
  (D) PARTS :: PART ; PARTS PART.
  (E) PART :: FIELD ; PARAMETER.
  (a) WHETHER MOID1 equivalent MOID2{64b,71m,72c} : WHETHER safe MOID1 equivalent safe MOID2{b}.
  (b) WHETHER SAFE1 MOID1 equivalent SAFE2 MOID2{a,b,e,i,j,n} : where (SAFE1) contains (remember MOID1 MOID2) or (SAFE2) contains (remember MOID2 MOID1), WHETHER true ; unless (SAFE1) contains (remember MOID1 MOID2) or (SAFE2) contains (remember MOID2 MOID1), WHETHER (HEAD3) is (HEAD4) and remember MOID1 MOID2 SAFE3 TAILETY3 equivalent SAFE4 TAILETY4{b,d,e,k,q,-}, where SAFE3 HEAD3 TAILETY3 develops from SAFE1 MOID1{c} and SAFE4 HEAD4 TAILETY4 develops from SAFE2 MOID2{c}.
  (c) WHETHER SAFE2 HEAD TAILETY develops from SAFE1 MOID{b,c} : where (MOID) is (HEAD TAILETY), WHETHER (HEAD) shields SAFE1 to SAFE2{74a,b,c,d,-} ; where (MOID) is (MU definition of MODE), unless (SAFE1) contains (MU has), WHETHER SAFE2 HEAD TAILETY develops from MU has MODE SAFE1 MODE{c} ; where (MOID) is (MU application) and (SAFE1) is (NOTION MU has MODE SAFE3) and (NOTION) contains (yin) and (NOTION) contains (yang), WHETHER SAFE2 HEAD TAILETY develops from SAFE1 MODE{c}.
  (d) WHETHER SAFE1 FIELDS1 mode equivalent SAFE2 FIELDS2 mode{b} : WHETHER SAFE1 FIELDS1 equivalent SAFE2 FIELDS2{f,g,h,i}.
  (e) WHETHER SAFE1 PARAMETERS1 yielding MOID1 equivalent SAFE2 PARAMETERS2 yielding MOID2{b} : WHETHER SAFE1 PARAMETERS1 equivalent SAFE2 PARAMETERS2{f,g,h,j} and SAFE1 MOID1 equivalent SAFE2 MOID2{b}.
  (f) WHETHER SAFE1 PARTS1 PART1 equivalent SAFE2 PARTS2 PART2{d,e,f} : WHETHER SAFE1 PARTS1 equivalent SAFE2 PARTS2{f,g,h,i,j} and SAFE1 PART1 equivalent SAFE2 PART2{i,j}.
  (g) WHETHER SAFE1 PARTS1 PART1 equivalent SAFE2 PART2{d,e,f} : WHETHER false.
  (h) WHETHER SAFE1 PART1 equivalent SAFE2 PARTS2 PART2{d,e,f} : WHETHER false.
  (i) WHETHER SAFE1 MODE1 field TAG1 equivalent SAFE2 MODE2 field TAG2{d,f} : WHETHER (TAG1) is (TAG2) and SAFE1 MODE1 equivalent SAFE2 MODE2{b}.
  (j) WHETHER SAFE1 MODE1 parameter equivalent SAFE2 MODE2 parameter{e,f} : WHETHER SAFE1 MODE1 equivalent SAFE2 MODE2{b}.
  (k) WHETHER SAFE1 MOODS1 mode equivalent SAFE2 MOODS2 mode{b} : WHETHER SAFE1 MOODS1 subset of SAFE2 MOODS2{l,m,n} and SAFE2 MOODS2 subset of SAFE1 MOODS1{l,m,n} and MOODS1 number equals MOODS2 number{o,p}.
  (l) WHETHER SAFE1 MOODS1 MOOD1 subset of SAFE2 MOODS2{k,l,46s,64b} : WHETHER SAFE1 MOODS1 subset of SAFE2 MOODS2{l,m,n} and SAFE1 MOOD1 subset of SAFE2 MOODS2{m,n}.
  (m) WHETHER SAFE1 MOOD1 subset of SAFE2 MOODS2 MOOD2{k,l,m,46s,64b} : WHETHER SAFE1 MOOD1 subset of SAFE2 MOODS2{m,n} or SAFE1 MOOD1 subset of SAFE2 MOOD2{n}.
  (n) WHETHER SAFE1 MOOD1 subset of SAFE2 MOOD2{k,l,m,64b} : WHETHER SAFE1 MOOD1 equivalent SAFE2 MOOD2{b}.
  (o) WHETHER MOODS1 MOOD1 number equals MOODS2 MOOD2 number{k,o} : WHETHER MOODS1 number equals MOODS2 number{o,p,-}.
  (p) WHETHER MOOD1 number equals MOOD2 number{k,o} : WHETHER true.
  (q) WHETHER SAFE1 EMPTY equivalent SAFE2 EMPTY{b} : WHETHER true.

# 7.4.1. Syntax
  (a) WHETHER (NOTION) shields SAFE to SAFE{73c} : where (NOTION) is (PLAIN) or (NOTION) is (FLEXETY ROWS of) or (NOTION) is (union of) or (NOTION) is (void), WHETHER true.
  (b) WHETHER (PREF) shields SAFE to yin SAFE{73c} : WHETHER true.
  (c) WHETHER (structured with) shields SAFE to yang SAFE{73c} : WHETHER true.
  (d) WHETHER (procedure with) shields SAFE to yin yang SAFE{73c} : WHETHER true.

# 8.0.1. Syntax
  (a) MOID NEST denoter{5D,A341i} : #pragment{92a} sequence option, MOID denotation{810a,811a,812a,813a,814a,815a,82a,b,c,83a,-}.

# 8.1.0.1. Syntax
  (A) SIZE :: long ; short.
  (B) *NUMERAL :: fixed point numeral ; variable point numeral ; floating point numeral.
  (a) SIZE INTREAL denotation{a,80a} : SIZE symbol{94d}, INTREAL denotation{a,811a,812a}.
  (b) *plain denotation : PLAIN denotation{a,811a,812a,813a,814a} ; void denotation{815a}.

# 8.1.1.1. Syntax
  (a) integral denotation{80a,810a} : fixed point numeral{b}.
  (b) fixed point numeral{a,812c,d,f,i,A341h} : digit cypher{c} sequence.
  (c) digit cypher{b} : DIGIT symbol{94b}.

# 8.1.2.1. Syntax
  (a) real denotation{80a,810a} : variable point numeral{b} ; floating point numeral{e}.
  (b) variable point numeral{a,f} : integral part{c} option, fractional part{d}.
  (c) integral part{b} : fixed point numeral{811b}.
  (d) fractional part{b} : point symbol{94b}, fixed point numeral{811b}.
  (e) floating point numeral{a} : stagnant part{f}, exponent part{g}.
  (f) stagnant part{e} : fixed point numeral{811b} ; variable point numeral{b}.
  (g) exponent part{e} : times ten to the power choice{h}, power of ten{i}.
  (h) times ten to the power choice{g} : times ten to the power symbol{94b} ; letter e symbol{94a}.
  (i) power of ten{g} : plusminus{j} option, fixed point numeral{811b}.
  (j) plusminus{i} : plus symbol{94c} ; minus symbol{94c}.

# 8.1.3.1. Syntax
  (a) boolean denotation{80a} : true{94b} symbol ; false{94b} symbol.

# 8.1.4.1. Syntax
  (a) character denotation{80a} : quote{94b} symbol, string item{b}, quote symbol{94b}.
  (b) string item{a,83b} : character glyph{c} ; quote image symbol{94b} ; other string item{d}.
  (c) character glyph{b,92c} : LETTER symbol{94a} ; DIGIT symbol{94b} ; point symbol{94b} ; open symbol{94f} ; close symbol{94f} ; comma symbol{94b} ; space symbol{94b} ; plus symbol{94c} ; minus symbol{94c}.

# 8.1.5.1. Syntax
  (a) void denotation{80a} : empty{94b} symbol.

# 8.2.1. Syntax
  (A) RADIX :: radix two ; radix four ; radix eight ; radix sixteen.
  (a) structured with row of boolean field LENGTH LENGTHETY letter aleph mode denotation{a,80a} : long{94d} symbol, structured with row of boolean field LENGTHETY letter aleph mode denotation {a,c}.
  (b) structured with row of boolean field SHORTH SHORTHETY letter aleph mode denotation{b,80a} : short{94d} symbol, structured with row of boolean field SHORTHETY letter aleph#mode denotation{b,c}.
  (c) structured with row of boolean field letter aleph mode denotation{a,b,80a} : RADIX{d,e,f,g}, letter r symbol{94a}, RADIX digit{h,i,j,k} sequence.
  (d) radix two{c,A347b} : digit two{94b} symbol.
  (e) radix four{c,A347b} : digit four{94b} symbol.
  (f) radix eight{c,A347b} : digit eight{94b} symbol.
  (g) radix sixteen{c,A347b} : digit one symbol{94b}, digit six symbol{94b}.
  (h) radix two digit{c,i} : digit zero symbol{94b} ; digit one symbol{94b}.
  (i) radix four digit{c,j} : radix two digit{h} ; digit two symbol{94b} ; digit three symbol{94b}.
  (j) radix eight digit{c,k} : radix four digit{i} ; digit four symbol{94b} ; digit five symbol{94b} ; digit six symbol{94b} ; digit seven symbol{94b}.
  (k) radix sixteen digit{c} : radix eight digit{j} ; digit eight symbol{94b} ; digit nine symbol{94b} ; letter a symbol{94a} ; letter b symbol{94a} ; letter c symbol{94a} ; letter d symbol{94a} ; letter e symbol{94a} ; letter f symbol{94a}.
  (l) *bits denotation : BITS denotation{a,b,c}.
  (m) *radix digit : RADIX digit{h,i,j,k}.

# 8.3.1. Syntax
  (a) row of character denotation{80a} : quote{94b} symbol, string{b} option, quote symbol{94b}.
  (b) string{a} : string item{814b}, string item{814b} sequence.
  (c) *string denotation : row of character denotation{a}.

# 9.1.1. Syntax
  (a) CHOICE STYLE start{34a} : where (CHOICE) is (choice using boolean), STYLE if{94f,-} token ; where (CHOICE) is (CASE), STYLE case{94f,-} token.
  (b) CHOICE STYLE in{34e} : where (CHOICE) is (choice using boolean), STYLE then{94f,-} token ; where (CHOICE) is (CASE), STYLE in{94f,-} token.
  (c) CHOICE STYLE again{34l} : where (CHOICE) is (choice using boolean), STYLE else if{94f,-} token ; where (CHOICE) is (CASE), STYLE ouse{94f,-} token.
  (d) CHOICE STYLE out{34l} : where (CHOICE) is (choice using boolean), STYLE else{94f,-} token ; where (CHOICE) is (CASE), STYLE out{94f,-} token.
  (e) CHOICE STYLE finish{34a} : where (CHOICE) is (choice using boolean), STYLE fi{94f,-} token ; where (CHOICE) is (CASE), STYLE esac{94f,-} token.
  (f) NOTION token : pragment{92a} sequence option, NOTION symbol{94a,b,c,d,e,f,g,h}.
  (g) *token : NOTION token{f}.
  (h) *symbol : NOTION symbol{94a,b,c,d,e,f,g,h}.

# 9.2.1. Syntax
  (A) PRAGMENT :: pragmat ; comment.
  (a) pragment{80a,91f,A341b,h,A348a,b,c,A349a,A34Ab} : PRAGMENT{b}.
  (b) PRAGMENT{a} : STYLE PRAGMENT symbol{94h,-}, STYLE PRAGMENT item{c} sequence option, STYLE PRAGMENT symbol{94h,-}.
  (c) STYLE PRAGMENT item{b} : character glyph{814c} ; STYLE other PRAGMENT item{d}.

# 9.4.2.1. MetaSyntax
  (A) TAG{D,F,K,48a,b,c,d} :: LETTER{B} ; TAG LETTER{B} ; TAG DIGIT{C}.
  (B) LETTER{A} :: letter ABC{94a} ; letter aleph{-} ; style TALLY letter ABC{-}.
  (C) DIGIT{A} :: digit zero{94b} ; digit one{94b} ; digit two{94b} ; digit three{94b} ; digit four{94b} ; digit five{94b} ; digit six{94b} ; digit seven{94b} ; digit eight{94b} ; digit nine{94b}.
  (D) TAB{48a,b} :: bold TAG{A,-} ; SIZETY STANDARD{E}.
  (E) STANDARD{D} :: integral{94e} ; real{94e} ; boolean{94e} ; character{94e} ; format{94e} ; void{94e} ; complex{94e} ; bits{94e} ; bytes{94e} ; string{94e} ; sema{94e} ; file{94e} ; channel{94e}.
  (F) TAD{48a,b} :: bold TAG{A,-} ; DYAD{G} BECOMESETY{J} ; DYAD{G} cum NOMAD{I} BECOMESETY{J}.
  (G) DYAD{F} :: MONAD{h} ; NOMAD{I}.
  (H) MONAD{G,K} :: or{94c} ; and{94c} ; ampersand{94c} ; differs from{94c} ; is at most{94c} ; is at least{94c} ; over{94c} ; percent{94c} ; window{94c} ; floor{94c} ; ceiling{94c} ; plus i times{94c} ; not{94c} ; tilde{94c} ; down{94c} ; up{94c} ; plus{94c} ; minus{94c} ; style TALLY monad{-}.
  (I) NOMAD{F,G,K} :: is less than{94c} ; is greater than{94c} ; divided by{94c} ; equals{94c} ; times{94c} ; asterisk{94c}.
  (J) BECOMESETY{F,K} :: cum becomes{94c} ; cum assigns to{94c} ; EMPTY.
  (K) TAM{48a,b} :: bold TAG{A,-} ; MONAD{h} BECOMESETY{J} ; MONAD{h} cum{9422e} NOMAD{I} BECOMESETY{J}.
  (L) ABC{B} :: a ; b ; c ; d ; e ; f ; g ; h ; i ; j ; k ; l ; m ; n ; o ; p ; q ; r ; s ; t ; u ; v ; w ; x ; y ; z.
  (M) *DOP :: DYAD{G} ; DYAD{G} cum NOMAD{I}.

# 10.1.1. Syntax
  (A) EXTERNAL :: standard ; library ; system ; particular.
  (B) STOP :: label letter s letter t letter o letter p.
  (a) program text : STYLE begin{94f} token, new LAYER1 preludes{b}, parallel{94f} token, new LAYER1 tasks{d} PACK, STYLE end{94f} token.
  (b) NEST1 preludes{a} : NEST1 standard prelude with DECS1{c}, NEST1 library prelude with DECSETY2{c}, NEST1 system prelude with DECSETY3{c}, where (NEST1) is (new EMPTY new DECS1 DECSETY2 DECSETY3).
  (c) NEST1 EXTERNAL prelude with DECSETY1{b,f} : strong void NEST1 series with DECSETY1{32b}, go on{94f} token ; where (DECSETY1) is (EMPTY), EMPTY.
  (d) NEST1 tasks{a} : NEST1 system task{e} list, and also{94f} token, NEST1 user task{f} PACK list.
  (e) NEST1 system task{d} : strong void NEST1 unit{32d}.
  (f) NEST1 user task{d} : NEST2 particular prelude with DECS{c}, NEST2 particular program{g} PACK, go on{94f} token, NEST2 particular postlude{i}, where (NEST2) is (NEST1 new DECS STOP).
  (g) NEST2 particular program{f} : NEST2 new LABSETY3 joined label definition of LABSETY3{h}, strong void NEST2 new LABSETY3 ENCLOSED clause{31a,33a,c,34a,35a}.
  (h) NEST joined label definition of LABSETY{g,h} : where (LABSETY) is (EMPTY), EMPTY ; where (LABSETY) is (LAB1 LABSETY1), NEST label definition of LAB1{32c}, NEST joined label definition of LABSETY1{h}.
  (i) NEST2 particular postlude{f} : strong void NEST2 series with STOP{32b}.

# 10.3.4.1.1. Syntax
  (A) FORMAT :: structured with row of PIECE field letter aleph mode.
  (B) PIECE :: structured with integral field letter c letter p integral field letter c letter o letter u letter n letter t integral field letter b letter p row of COLLECTION field letter c mode.
  (C) COLLECTION :: union of PICTURE COLLITEM mode.
  (D) COLLITEM :: structured with INSERTION field letter i digit one procedure yielding integral field letter r letter e letter p integral field letter p INSERTION field letter i digit two mode.
  (E) INSERTION :: #row of structured with procedure yielding integral field letter r letter e letter p union of row of character character mode field letter s letter a mode.
  (F) PICTURE :: structured with union of PATTERN CPATTERN FPATTERN GPATTERN void mode field letter p INSERTION field letter i mode.
  (G) PATTERN :: structured with integral field letter t letter y letter p letter e row of FRAME field letter f letter r letter a letter m letter e letter s mode.
  (H) FRAME :: structured with INSERTION field letter i procedure yielding integral field letter r letter e letter p boolean field letter s letter u letter p letter p character field letter m letter a letter r letter k letter e letter r mode.
  (I) CPATTERN :: structured with INSERTION field letter i integral field letter t letter y letter p letter e row of INSERTION field letter c mode.
  (J) FPATTERN :: structured with INSERTION field letter i procedure yielding FIVMAT field letter p letter f mode.
  (K) GPATTERN :: structured with INSERTION field letter i row of procedure yielding integral field letter s letter p letter e letter c mode.
  (L) FIVMAT :: mui definition of structured with row of structured with integral field letter c letter p integral field letter c letter o letter u letter n letter t  integral field letter b letter p row of union of structured with union of PATTERN CPATTERN structured with INSERTION field letter i procedure yielding mui application field letter p letter f mode GPATTERN void mode field letter p INSERTION field letter i mode COLLITEM mode field letter c mode field letter aleph mode.
  (M) MARK :: sign ; point ; exponent ; complex ; boolean.
  (N) COMARK :: zero ; digit ; character.
  (O) UNSUPPRESSETY :: unsuppressible ; EMPTY.
  (P) TYPE :: integral ; real ; boolean ; complex ; string ; bits ; integral choice ; boolean choice ; format ; general.
  (a) FORMAT NEST format text{5D} : formatter{94f} token, NEST collection{b} list, formatter{94f} token.
  (b) NEST collection{a,b} : pragment{92a} sequence option, NEST picture{c} ; pragment{92a} sequence option, NEST insertion{d}, NEST replicator{g}, NEST collection{b} list brief pack, pragment{92a} sequence option, NEST insertion{d}.
  (c) NEST picture{b} : NEST TYPE pattern{A342a, A343a, A344a, A345a, A346a, A347a, A348a, b, A349a, A34Aa} option, NEST insertion{d}.
  (d) NEST insertion{b,c,j,k,A347b,A348a,b,A349a,A34Aa} : NEST literal{i} option, NEST alignment{e} sequence option.
  (e) NEST alignment{d} : NEST replicator{g}, alignment code{f}, NEST literal{i} option.
  (f) alignment code{e} : letter k{94a} symbol ; letter x{94a} symbol ; letter y{94a} symbol ; letter l{94a} symbol ; letter p{94a} symbol ; letter q{94a} symbol.
  (g) NEST replicator{b,e,i,k} : NEST unsuppressible replicator{h} option.
  (h) NEST unsuppressible replicator{g,i} : fixed point numeral{811b} ; letter n{94a} symbol, meek integral NEST ENCLOSED clause{31a,34a,-}, pragment{92a} sequence option.
  (i) NEST UNSUPPRESSETY literal{d,e,i,A348c} : NEST UNSUPPRESSETY replicator{g,h}, strong row of character NEST denoter{80a} coercee{61a}, NEST unsuppressible literal{i} option.
  (j) NEST UNSUPPRESSETY MARK frame{A342c,A343b,c,A344a,A345a} : NEST insertion{d}, UNSUPPRESSETY suppression{l}, MARK marker{A342e,A343d,e,A344b,A345b}.
  (k) NEST UNSUPPRESSETY COMARK frame{A342b,c,A346a} : NEST insertion{d}, NEST replicator{g}, UNSUPPRESSETY suppression{l}, COMARK marker{A342d,f,A346b}.
  (l) UNSUPPRESSETY suppression{j,k,A347b} : where (UNSUPPRESSETY) is (unsuppressible), EMPTY ; where (UNSUPPRESSETY) is (EMPTY), letter s{94a} symbol option.
  (m) *frame : NEST UNSUPPRESSETY MARK frame{j} ; NEST UNSUPPRESSETY COMARK frame{k} ; NEST RADIX frame{A347b}.
  (n) *marker : MARK marker{A342e,A343d,e,A344b,A345b} ; COMARK marker{A342d,f,A346b} ; radix marker{A347c}.
  (o) *pattern : NEST TYPE pattern{A342a, A343a, A344a, A345a, A346a, A347a, A348a, b, A349a, A34Aa}.

# 10.3.4.2.1. Syntax
  (a) NEST integral pattern{A341c,A343c} : NEST sign mould{c} option, NEST integral mould{b}.
  (b) NEST integral mould{a,A343b,c,A347a} : NEST digit frame{A341k} sequence.
  (c) NEST sign mould{a,A343a} : NEST unsuppressible zero frame{A341k} sequence option, NEST unsuppressible sign frame{A341j}.
  (d) zero marker{f,A341k} : letter z{94a} symbol.
  (e) sign marker{A341j} : plus{94c} symbol ; minus{94c} symbol.
  (f) digit marker{A341k} : letter d{94a} symbol ; zero marker{d}.

# 10.3.4.3.1. Syntax
  (a) NEST real pattern{A341c,A345a} : NEST sign mould{A342c} option, NEST variable point mould{b} or alternatively NEST floating point mould{c}.
  (b) NEST variable point mould{a,c} : NEST integral mould{A342b}, NEST point frame{A341j}, NEST integral mould{A342b} option ; NEST point frame{A341j}, NEST integral mould{A342b}.
  (c) NEST floating point mould{a} : NEST variable point mould{b} or alternatively NEST integral mould{A342b}, NEST exponent frame{A341j}, NEST integral pattern{A342a}.
  (d) point marker{A341j} : point{94b} symbol.
  (e) exponent marker{A341j} : letter e{94a} symbol.

# 10.3.4.4.1. Syntax
  (a) NEST boolean pattern{A341c} : NEST unsuppressible boolean frame{A341j}.
  (b) boolean marker{A341j,A348b} : letter b{94a} symbol.

# 10.3.4.5.1. Syntax
  (a) NEST complex pattern{A341c} : NEST real pattern{A343a}, NEST complex frame{A341j}, NEST real pattern{A343a}.
  (b) complex marker{A341j} : letter i{94a} symbol.

# 10.3.4.6.1. Syntax
  (a) NEST string pattern{A341c} : NEST character frame{A341k} sequence.
  (b) character marker{A341k} : letter a{94a} symbol.

# 10.3.4.7.1. Syntax
  (a) NEST bits pattern{A341c} : NEST RADIX frame{b}, NEST integral mould{A342b}.
  (b) NEST RADIX frame{a} : NEST insertion{A341d}, RADIX{82d,e,f,g}, unsuppressible suppression{A341l}, radix marker{c}.
  (c) radix marker{b} : letter r{94a} symbol.

# 10.3.4.8.1. Syntax
  (a) NEST integral choice pattern{A341c} : NEST insertion{A341d}, letter c{94a} symbol, NEST praglit{c} list brief pack, pragment{92a} sequence option.
  (b) NEST boolean choice pattern{A341c} : NEST insertion{A341d}, boolean marker{A344b}, brief begin{94f} token, NEST praglit{c}, and also{94f} token, NEST praglit{c}, brief end{94f} token, pragment{92a} sequence option.
  (c) NEST praglit{a,b} : pragment{92a} sequence option, NEST literal{A341i}.

# 10.3.4.9.1. Syntax
  (a) NEST format pattern{A341c} : NEST insertion{A341d}, letter f{94a} symbol, meek FORMAT NEST ENCLOSED clause{31a,34a}, pragment{92a} sequence option.

# 10.3.4.10.1. Syntax
  (a) NEST general pattern{A341c} : NEST insertion{A341d}, letter g{94a} symbol, NEST width specification{b} option.
  (b) NEST width specification{a} : brief begin{94f} token, meek integral NEST unit{32d}, NEST after specification{c} option, brief end{94f} token, pragment{92a} sequence option.
  (c) NEST after specification{b} : and also{94f} token, meek integral NEST unit{32d}, NEST exponent specification{d} option.
  (d) NEST exponent specification{c} : and also{94f} token, meek integral NEST unit{32d}.