Symbol statements

The general format for a symbol statement is:

symbol,value remark

The general coding rules are as follows:

Columns 1 through 80 are scanned.
The symbol can start in column 1 or in any column after 1.
A remark is optional, but if specified, must be separated from the value by at least one blank. A remark is printed in SYMNOUT (if specified), but otherwise not processed.
A semicolon (;) can be used instead of a comma (,) between the symbol and the value.
Continuation is not allowed. Each symbol and value must be completely specified on one line.

The specific syntax for symbol statements is:


>>-symbol,-+-constant-----+------------------------------------><
           +-field--------+   
           '-parsed field-'

Symbol: A symbol can be 1 to 50 EBCDIC characters consisting of uppercase letters (A-Z), lowercase letters (a-z), numbers (0-9), the number sign (#), the dollar sign ($), the commercial at sign (@), the underscore(_) and the hyphen(-). The first character of a symbol must not be a number or a hyphen. Symbols are treated as case-sensitive: Frank, FRANK and frank are three different symbols.

The following DFSORT/ICETOOL reserved words (uppercase only as shown) are not allowed as symbols: A, AC, ADD, ADDDAYS, ADDMONS, ADDYEARS, ALL, AND, AQ, ASL, AST, BI, CH, CLO, COPY, COUNT, COUNT15, CSF, CSL, CST, CTO, D, DATE, DATEDIFF, DATE1, DATE1..., DATE2, DATE2..., DATE3, DATE3..., DATE4, DATE5, DC1, DC2, DC3, DC4, DE1, DE2, DE3, DE4, DIV, DT1, DT2, DT3, D1, D2, E, F, FI, FL, FS, H, HEX, LASTDAYM, LASTDAYQ, LASTDAYW, LASTDAYY, LC, LN, LS, MAX, MC, MIN, MN, MOD, MUL, Mn, Mnn, NEXTDday, NONE, NUM, OL, OR, OT, PAGE, PAGEHEAD, PD, PDC, PDF, PD0, PREVDday, SEQNUM, SFF, SS, SUB, SUBCOUNT, SUBCOUNT15, SUBDAYS, SUBMONS, SUBYEARS, TC1, TC2, TC3, TC4, TE1, TE2, TE3, TE4, TIME, TIME1, TIME1P, TIME2, TIME2P, TIME3, TIME3P, TM1, TM2, TM3, TM4, TS, UC, UFF, UN, VALCNT, VLEN, X, Y2x, Y2xx, Y4x, Z, ZD, ZDC, and ZDF, where n is 0-9, day is SUN, MON, TUE, WED, THU, FRI or SAT, and x is any character. Lower case and mixed case forms of these words, such as None and page, can be used as symbols.

POSITION, SKIP and ALIGN (uppercase only) are treated as keywords as discussed in Keyword statements and thus are not recognized as symbols. However, lowercase and mixed case forms of these words, such as Position and skip, can be used as symbols.

Some examples of valid symbols are: Account_Number, CON12, PHONE#, count, SORT-KEY, and _Invalid.

Some examples of invalid symbols are: 123_Account (starts with a number), COUNT (reserved word), DATE1-20 (reserved word), and -Invalid (starts with a hyphen).

Constant: A constant can be a character string, system symbol string, hexadecimal string, bit string, decimal number, or two-digit year date string.

A symbol for a constant value must be used only where such a constant is allowed and has the desired result. Otherwise, substitution of the constant for the symbol will result in an error message or unintended processing. For example, if the following SYMNAMES statement is specified:

SYMB,B'10110001'

SYMB can be used in this INCLUDE statement:

  INCLUDE COND=(12,1,BI,EQ,SYMB)

because a bit string can be compared to a binary field. However, SYMB will result in an error message if used in this INCLUDE statement:

  INCLUDE COND=(12,1,CH,EQ,SYMB)

because a bit string cannot be compared to a character field.

Make sure the constants that will be substituted for your symbols are appropriate. If in doubt, check the rules for constants given in the description of the relevant operand.

A symbol can represent one of the following types of constants:

A character string in the format 'xx...x', C'xx...x' or c'xx...x'.
The value x may be any EBCDIC character. You can specify up to 64 characters for the string. c'xx...x' will be treated like C'xx...x'.
Note: If you want to use system symbols (for example, &JOBNAME.) in your character strings, use a system symbol string (S'string' or s'string') as described later in this section instead of a character string.
If you want to include a single apostrophe in the character string, you must specify it as two single apostrophes (each pair of apostrophes counts as two characters towards the 64 character limit for the string). Thus:
```
Required:  O'Neill         Specify:  C'O''Neill'
```
Double-byte data may be used in a character string (each pair of shift-in/shift-out characters and each double-byte character counts as two characters towards the 64 character limit for the string). See INCLUDE control statement for details on double-byte data.

Some examples of valid character strings are: '+0.193', c'Title', C'O''Neil', C'J62,J82,M72' and ''.

Some examples of invalid character strings are: C'AB'' (apostrophes not paired), c'title (ending apostrophe missing) and C'O'NEIL' (one apostrophe after O instead of two).
You can use C'xx...x' and 'xx...x' interchangeably. 'xx...x' will be substituted for symbols where appropriate even if C'xx...x' is specified in SYMNAMES. Likewise, C'xx...x' will be substituted for symbols where appropriate even if 'xx...x' is specified in SYMNAMES. For example, if these SYMNAMES statements are specified:
```
My_Title,c'My Report'
My_Heading,C'January'
DEPT1,'J82'
DEPT2,c'M72'
```
the ICETOOL operator:
```
  DISPLAY TITLE(My_Title) HEADER(My_Heading) ...
```
will be transformed to:
```
  DISPLAY TITLE('My Report') HEADER('January') ...
```
and the INCLUDE statement:
```
  INCLUDE COND=(5,3,EQ,DEPT1,OR,5,3,EQ,DEPT2),FORMAT=CH
```
will be transformed to:
```
  INCLUDE COND=(5,3,EQ,C'J82',OR,5,3,EQ,C'M72'),FORMAT=CH
```
Although the rules for character strings used as symbols generally follow the rules for INCLUDE/OMIT character strings, keep in mind that the same rules do not apply for character strings in all DFSORT and ICETOOL operands, so use symbols representing character strings appropriately. For example, ICETOOL only allows up to 50 characters for a TITLE string, so TITLE(MYCON) would result in an error message if MYCON is a 64-character string, even though MYCON could be used without error in an INCLUDE statement. As another example, double-byte characters would be recognized in a character string substituted for a symbol in an INCLUDE statement, but would not be recognized in a character string substituted in an OUTREC statement.
A system symbol string in the format S'original_string' or s'original_string'
The original_string can contain any combination of EBCDIC characters and system symbols (&SYMBOL or &SYMBOL.) you want to use to form a character string. DFSORT will replace each system symbol in the system symbol string with its substitution text to create a character string in the format C'result_string'.
For example, you could specify the following symbol statement in SYMNAMES:
```
Rpt_hdr,S'  Job &JOBNAME. was run on Sysplex &SYSPLEX. on &LWDAY'
```
If you used this symbol statement in a job named TEST2 that you ran on sysplex MAS3 on a Thursday, DFSORT would transform it into the following symbol statement:
```
Rpt_hdr,C'  Job TEST2 was run on Sysplex MAS3 on THU'
```
&JOBNAME. was replaced with 'TEST2', &SYSPLEX. was replaced with 'MAS3' and &LWDAY was replaced with 'THU'.
If you used this same symbol statement in a job named BIGTEST that you ran on sysplex MAS2 on a Monday, DFSORT would transform it into the following symbol statement:
```
Rpt_hdr,C'  Job BIGTEST was run on Sysplex MAS2 on MON'
```
This time &JOBNAME. was replaced with 'BIGTEST', &SYSPLEX. was replaced with 'MAS2' and &LWDAY was replaced with 'MON'.
You could use the Rpt_hdr symbol in an OUTFIL statement like this:
```
  OUTFIL HEADER2=(Rpt_hdr,5X,'Page ',PAGE=(EDIT=(TTT)),/)
```
and get the heading you needed based on the setting of the system symbol values where and when the job was run.
The types of system symbols you can use in a system symbol string are:
- Dynamic system symbols like &YYMMDD, &LYYMMDD, &HHMMSS, &LHHMMSS, &DAY, &LDAY, &HR, &LHR, &JDAY, &LJDAY, &JOBNAME, &MIN, &LMIN, &MON, &LMON, &SEC, &LSEC, &WDAY, &LWDAY, &YR2, &LYR2, &YR4, and &LYR4.
- System-defined static system symbols like &SYSCLONE, &SYSNAME, &SYSPLEX, &SYSR1, and &SYSALVL.
- Installation-defined static system symbols specified by your installation in an IEASYMxx member of SYS1.PARMLIB.
Note: System symbols must be specified using all uppercase characters. Lowercase characters are not recognized as system symbols. For example, &JOBNAME is recognized as a system symbol, but &jobname and &Jobname are not.
You can use all three types of system symbols separately or in combination within a system symbol string. You can also use all of the system symbol string building facilities such as substring notation, concatenation, embedded blanks, and so on, in a system symbol string. Thus, system symbol strings can be very simple like this one:
```
  Sysname,s'&SYSNAME' 
```
Or more complex like this one:
```
  Dsn1,s'ACCT.&SYSNAME(3:2)..D&LJDAY' 
```
For more information on system symbols, see z/OS MVS Initialization and Tuning Reference.
Note: JCL symbols and IPCS symbols are not system symbols and will not be recognized or replaced in a system symbol string.

s'original_string' will be treated like S'original_string'.

If you want to include a single apostrophe in the system symbol string, you must specify it as two single apostrophes.
DFSORT uses the ASASYMBM service to transform S'original_string' into C'result_string'. If your system symbol string has errors involving symbol names, substring notation, and so on, ASASYMBM transforms the symbol system string to a character string according to its rules for substitution. For example, if you specify these symbol statements:
```
  Ok,S'&YR4(1:2).&SYSNAME.'
  Bad,S'&YR4(1.2).&SYSNAM.' 
```
where the valid substring notation 1:2 and the known system symbol &SYSNAME. (for example, 'ED53') are used for Ok, but the invalid substring notation 1.2 and the unknown system symbol &SYSNAM. are used for Bad, the resulting symbol statements are:
```
  Ok,C'20EDS3'
  Bad,C'2006(1.2).&SYSNAM.'
```
See z/OS MVS Programming: Assembler Services Reference ABE-HSP for complete details on the ASASYMBM service.

After a symbol statement containing a system symbol string (S'original_string') is transformed into a symbol statement containing the resulting character string (C'result_string'), it will be error checked and processed like any other symbol statement containing a character string. See the description of character string previously in this section for details.

If a SYMNOUT data set is specified, it will show the symbol statement containing the original system symbol string as well as the transformed symbol statement containing the resulting character string. This can be helpful for debugging "errors" or unexpected results in your system symbol strings.
A hexadecimal string in the format X'yy...yy' or x'yy...yy'.
The value yy represents any pair of hexadecimal digits. Each hexadecimal digit must be 0-9, A-F or a-f. You can specify up to 32 pairs of hexadecimal digits. x'yy...yy' will be treated like X'yy...yy'. a-f will be treated like A-F.

Some examples of valid hexadecimal strings are: X'F2C3', x'2fa71e', and X'07'.

Some examples of invalid hexadecimal strings are: X'F2G301' (G is not a valid hexadecimal digit), x'bf3' (unpaired hexadecimal digits) and X'' (no hexadecimal digits).
A bit string in the format B'bbbbbbbb...bbbbbbbb' or b'bbbbbbbb...bbbbbbbb'.
The value bbbbbbbb represents 8 bits that constitute a byte. Each bit must be 1, 0 or . (period). You can specify up to 8 groups of 8 bits. b'bbbbbbbb...bbbbbbbb' will be treated like B'bbbbbbbb...bbbbbbbb'.

Some examples of valid bit strings are: B'01100100', b'11..00..000..111' and B'11......'.

Some examples of invalid bit strings are: B'0101' (not a multiple of eight bits), b'00..11....' (not a multiple of eight bits), b'00000002' (2 is not a valid bit) and B'' (no bits).
A decimal number in the format n, +n or -n. You can specify from 1 to 31 significant digits.
Some examples of valid decimal numbers are: +270, 270, 000036, +0 and -2000000.

Some examples of invalid decimal numbers are: ++15 (too many plus signs), 280- (sign in wrong place) and 2.8 (period is not allowed).
A two-digit year date string in the format Y'string' or y'string'.
string can be:
- yy, yyx,yyxx, yyxxx or yyxxxx where y is a hexadecimal year digit (0-9) and x is a hexadecimal non-year digit (0-9).
- Uppercase, lowercase or mixed case forms of LOW, BLANKS, or HIGH.
- A two-digit year date string in the format Y'datex', Y'datex'+n or Y'datex'-n.
  - datex can be uppercase, lowercase or mixed case forms of DATE1, DATE2 or DATE3.
  - n is a decimal number representing the number of days for DATE1 and DATE3, or the number of months for DATE2.
Some examples of valid two-digit year date strings are: Y'99', y'00123', y'date2', Y'DATE1'+20, y'Date3'-1, and Y'Blanks'.

Some examples of invalid two-digit year date strings are: Y'9', y'AB123', Y'DATE2-3', and Y'blank'.

Field: A field can be specified as p,m,f (position, length and format), p,m (position and length) or p (position only).

A symbol for a field value must be used only where such a field is allowed and has the desired result. Otherwise, substitution of the field for the symbol will result in an error message or unintended processing. For example, if the following SYMNAMES statement is specified:

Field1,15,2,CH

Field1 can be used in a SORT statement such as:

  SORT FIELDS=(Field1,A)

because a character field is allowed in a SORT statement. However, Field1 will result in an error message if used in a SUM statement such as:

  SUM FIELDS=(Field1)

because a character field is not allowed in a SUM statement.

As another example, Field1: can be used in an INREC statement such as:

  OUTFIL OVERLAY=(Field1:C'AB')

to set the output column to 15, because column notation is allowed in the BUILD, OVERLAY or PUSH operand of an INREC or OUTREC statement and in the BUILD, OVERLAY, PUSH, TRLUPD, HEADERx, or TRAILERx operand of an OUTFIL statement. However, Field1: will result in an error message if used in any other operand, such as WHEN.

Make sure the fields that will be substituted for your symbols are appropriate. If in doubt, check the rules for p, m, f, and c: given in the description of the relevant operand.

You can specify p,m,f for your field symbols and then use them where p,m is required because DFSORT or ICETOOL will substitute just p,m when appropriate. You can specify p,m,f or p,m for your field symbols and then use them where c: is required because DFSORT will substitute just p: when appropriate. For example, if you specify the following in SYMNAMES:

First_Field,12,2,BI
Second_Field,18,6,CH
Third_Field,28,5,PD
Fourth_Field,36,3
Fifth_Field,52,4,PD
Max,200000
Outcol2,16

These DFSORT control statements:

  OMIT COND=(Fifth_Field,GT,Max)
  SORT FIELDS=(First_Field,A,Fourth_Field,A),FORMAT=CH
  SUM FIELDS=(Second_Field,ZD)
  OUTFIL OUTREC=(First_Field:First_Field,
     Outcol2:Third_Field,M11,
     Fourth_Field)

will be transformed to:

  OMIT COND=(52,4,PD,GT,200000)
  SORT FIELDS=(12,2,A,36,3,A),FORMAT=CH
  SUM FIELDS=(18,6,ZD)
  OUTFIL BUILD=(12:12,2,16:28,5,PD,M11,36,3)

Note that DFSORT did the following substitutions:

OMIT statement: p,m,f for Fifth_Field as required by COND without FORMAT.
SORT statement: p,m for First_Field and Fourth_Field as required by FIELDS with FORMAT.
SUM statement: p,m for Second_Field as required for symbol,f (that is, Second_Field,ZD).
OUTFIL statement: p: for First_Field: and Outcol2: as required by the OUTREC operand for an output column. p,m for First_Field and Fourth_Field as required by the OUTREC operand for an unedited field. p,m,f for Third_Field as required by the OUTREC operand for an edited field (that is, Third_Field,M11).

The general rules for using p, m and f in symbol statements are as follows:

p can be a number, an asterisk (*) or an equal sign (=). A number from 1 to 32752 is allowed in p,m or p,m,f. Because p (position only) cannot be distinguished from the constant n, 1 to 15 significant digits are allowed for p (position only).
An asterisk (*) can be used to assign the next position to p. Each time a symbol for p,m,f or p,m is read, the next position is set to p+m. Additionally, the next position can be modified by keyword statements (see Keyword statements). When * is specified for p, the next position is assigned to p. If the next position has not been set when * is used for p (for example, * is used in the first symbol), p is set to 1.

The symbol table printed in the SYMNOUT data set (if specified) will show you the actual positions assigned when you specify * for p.
As an example of how * can be used, if you specify the following SYMNAMES statements:
```
Sym1,*,5,ZD
Con1,27
Sym2,*,2,BI
Field1,8,13,CH
Field2,*,5,PD
Field3,*,2,FI

 
```
SYMNOUT will show the following symbol table:
```
Sym1,1,5,ZD
Con1,27
Sym2,6,2,BI
Field1,8,13,CH
Field2,21,5,PD
Field3,26,2,FI
```
By using * for p, you can map consecutive fields in your records without having to compute their actual positions. You can also map fields added between other fields without having to change the p values for the original or inserted fields. * is also useful for creating mappings of contiguous fields using concatenated symbol data sets. As a simple example, if you specify:
```
//SYMNAMES DD DSN=MY.SYMPDS(RDW),DISP=SHR
//         DD DSN=MY.SYMPDS(SECTION1),DISP=SHR
//         DD DSN=MY.SYMPDS(SECTION2),DISP=SHR
```
and the RDW member contains:
```
RDW,1,4,BI
```
the SECTION1 member contains:
```
Flag_Byte,*,1,BI
  Error1,X'80'
  Error2,X'40'
Count_of_Parts,*,5,ZD
```
and the SECTION2 member contains:
```
New_Parts,*,5,ZD
Old_Parts,*,5,ZD
Variable_Fields,*
```
SYMNOUT will show the following symbol table:
```
RDW,1,4,BI
Flag_Byte,5,1,BI
Error1,X'80'
Error2,X'40'
Count_of_Parts,6,5,ZD
New_Parts,11,5,ZD
Old_Parts,16,5,ZD
Variable_Fields,21
```
You might use these symbols in the following statements:
```
  OPTION COPY
  OUTFIL FNAMES=ERR1,INCLUDE=(Flag_Byte,EQ,Error1),
     OUTREC=(RDW,Count_of_Parts,Variable_Fields)
  OUTFIL FNAMES=ERR2,INCLUDE=(Flag_Byte,EQ,Error2),
     OUTREC=(RDW,New_Parts,Old_Parts,Variable_Fields)
```
An equal sign (=) can be used to assign the previous position to p. Each time a symbol for p,m,f or p,m is read, the previous position is set to p. Additionally, the previous position can be modified by a POSITION keyword statement (see later in this section). When = is specified for p, the previous position is assigned to p. If the previous position has not been set when = is used for p, an error message is issued.

The symbol table printed in the SYMNOUT data set (if specified) will show you the actual positions assigned when you specify = for p.
As an example of how = can be used for p, if you specify the following SYMNAMES statements:
```
Sym1,5,4,CH
  Sym2,=,2,CH
  Sym3,*,2,CH
```
SYMNOUT will show the following symbol table:
```
Sym1,5,4,CH
Sym2,5,2,CH
Sym3,7,2,CH
```
By using = and * for p, you can easily map fields onto other fields.
Whenever you use = for p, you must ensure that the previous position is the one you want. In particular, if you insert a new field symbol with the wrong position before a symbol that uses = for p, you will need to change = to the actual position you want.
m can be an equal sign (=) or a number from 1 to 32752. An equal sign (=) can be used to assign the previous length to m. Each time a symbol for p,m,f or p,m is read, the previous length is set to m. When = is specified for m, the previous length is assigned to m. If the previous length has not been set when = is used for m, an error message is issued.
The symbol table printed in the SYMNOUT data set (if specified) will show you the actual lengths assigned when you specify = for m.
As an example of how = can be used for m, if you specify the following SYMNAMES statements:
```
Flags1,5,1,BI
  Error1,X'08'
Flags2,15,=,BI
  Error2,X'04'
Flags3,22,=,BI
  Error3,X'23'
```
SYMNOUT will show the following symbol table:
```
Flags1,5,1,BI
Error1,X'08'
Flags2,15,1,BI
Error2,X'04'
Flags3,22,1,BI
Error3,X'23'
```
Whenever you use = for m, you must ensure that the previous length is the one you want. In particular, if you insert a new field symbol with the wrong length before a symbol that uses = for m, you will need to change = to the actual length you want.
f can be an equal sign (=) or one of the following formats: AC, AQ, ASL, AST, BI, CH, CLO, CSF, CSL, CST, CTO, DC1, DC2, DC3, DE1, DE2, DE3, DT1, DT2, DT3, D1, D2, FI, FL, FS, LS, OL, OT, PD, PD0, SFF, SS, TC1, TC2, TC3, TC4, TE1, TE2, TE3, TE4, TM1, TM2, TM3, TM4, TS, UFF, Y2B, Y2C, Y2D, Y2DP, Y2P, Y2PP, Y2S, Y2T, Y2TP, Y2U, Y2UP, Y2V, Y2VP, Y2W, Y2WP, Y2X, Y2XP, Y2Y, Y2YP, Y2Z, Y4T, Y4U, Y4V, Y4W, Y4X, Y4Y or ZD.
You can specify f using uppercase letters (for example, CH), lowercase letters (for example, ch) or mixed case letters (for example, Ch). f specified in any case will be treated like uppercase.

An equal sign (=) can be used to assign the previous format to f. Each time a symbol for p,m,f is read, the previous format is set to f. When = is specified for f, the previous format is assigned to f. If the previous format has not been set when = is used for f, an error message is issued.

The symbol table printed in the SYMNOUT data set (if specified) will show you the actual formats assigned when you specify = for f.
As an example of how = can be used for f, if you specify the following SYMNAMES statements:
```
Field1,5,8,CH
Field1a,=,3
Field2,*,12,=
Field3,*,20,=
```
SYMNOUT will show the following symbol table:
```
Field1,5,8,CH
Field1a,5,3
Field2,8,12,CH
Field3,20,20,CH
```
Whenever you use = for f, you must ensure that the previous format is the one you want. In particular, if you insert a new field symbol with the wrong format before a symbol that uses = for f, you will need to change = to the actual format you want.

Parsed field: A parsed field can be specified as %nnn with nnn as 000-999, %nn with nn as 00-99 or as %n with n as 0-9. %0n will be substituted for %n and %00n. %nn will be substitued for %0nn. A symbol for a parsed field must be used only where such a field is allowed and has the desired result. Otherwise, substitution of %nn for the symbol will result in an error message. For example, if the following SYMNAMES statement is specified:

Revenue,%03

Revenue can be used in an OUTREC statement such as:

  OUTREC PARSE=(Revenue=(STARTAT=C'+',FIXLEN=9)),
         OVERLAY=(31:Revenue,UFF,EDIT=(III,IIT,TTT))

because a parsed field is allowed in the PARSE operand and the OVERLAY operand. However, Revenue will result in an error message if used in a SORT statement such as:

    SORT FIELDS=(Revenue,UFF,A)

because a parsed field is not allowed in a SORT statement.

Make sure the parsed fields that will be substituted for your symbols are appropriate. If in doubt, check the rules for %nn given in the description of the relevant operand.

As an example of how parsed fields can be used, if you specify the following SYMNAMES statements:

branch,1,7
tab,X'05'
comma,','
first_name,%00
last_name,%1
date,%02
company,%03
city,%004
state,%305

SYMNOUT will show the following symbol table:

branch,1,7
tab,X'05'
comma,C','
first_name,%00
last_name,%01
date,%02
company,%03
city,%04
state,%305

This DFSORT control statement:

  INREC PARSE=(first_name=(ABSPOS=9,FIXLEN=12,ENDBEFR=comma),
            last_name=(FIXLEN=15,ENDBEFR=comma),
            %=(ENDBEFR=tab),
            date=(FIXLEN=10,ENDBEFR=tab),
            company=(FIXLEN=31,ENDBEFR=tab),
            city=(FIXLEN=14,ENDBEFR=tab),
            state=(FIXLEN=12)),
       BUILD=(branch,9:first_name,22:last_name,
              38:date,JFY=(SHIFT=RIGHT),
              49:company,83:city,98:state)

will be transformed to:

  INREC PARSE=(%00=(ABSPOS=9,FIXLEN=12,ENDBEFR=C','),%01=(FIXLEN=15,ENDB*
                EFR=C','),%=(ENDBEFR=X'05'),%02=(FIXLEN=10,ENDBEFR=X'05'*
                ),%03=(FIXLEN=31,ENDBEFR=X'05'),%04=(FIXLEN=14,ENDBEFR=X*
                '05'),%05=(FIXLEN=12)),BUILD=(1,7,9:%00,22:%01,38:%02,JF*
                Y=(SHIFT=RIGHT),49:%03,83:%04,98:%305)