10020: Builtin <function> takes at least <number> arguments

10030: Builtin <function> takes at least <number> arguments 
and at most <number>

10040: Built-in <function> cannot be passed as a parameter

10050: argv takes two arguments

10060: argv's first argument must be an integer, not <type>

10070: argv's second argument must be a string, not <type>

10080: Argument to card must be a set, not <type>

10090: flush takes at most one argument

10100: flush's argument must be a file, not <type>

10110: Not enough arguments to <function>

10120: Too many arguments to <function>

10130: Actual argument cannot be conformant array

10140: Actual argument is incompatible with formal var 
parameter <identifier> of <function>

10150: Actual argument is incompatible with formal 
<paramtype> parameter <identifier> of <function>

10160: Actual argument to NONPASCAL procedure cannot be 
conformant array

10170: Extra arguments to ADDR ignored

10180: Argument to <function> must be of type <type>, not 
<type>

10190: Second argument to <function> must be of type <type>, 
not <type>

10200: First argument to <function> must be of type <type>, 
not <type>

10210: Illegal argument to IN_RANGE

10220: Type clash in argument to IN_RANGE

10230: Illegal argument to ADDR

10240: Third argument to <function> must be of type <type>, 
not <type>

10250: Argument to ADDR is a dynamically allocated variable 
<identifier>

10260: Argument to ADDR is an internal variable <identifier>

10270: Argument to ADDR is a nested function <function>

10280: Argument to ADDR is an internal procedure <function>

10290: Fourth argument to <function> must be of type <type>, 
not <type>

10300: First argument to <function> cannot be a univ_ptr

10310: <number> argument to <function> must be of type <type>, 
not <type>

10320: <number> argument to <function> must be unpacked

10330: <number> argument to <function> must be packed

10340: <function> (line <number>) has <number> arguments

10350: Transfer functions take exactly one argument

10360: sizeof takes at least 1 argument

10370: Formal arguments should be given only in forward 
declaration

10380: Types must be specified for arguments

10390: Each procedure/function argument must be declared 
separately

10400: <function> takes no arguments

10410: <function> takes either zero or one argument

10420: <function> takes exactly one argument

10430: <function>'s argument must be integer or real, not 
<type>

10440: seed's argument must be an integer, not <type>

10450: <function>'s argument must be a real, not <type>

10460: <function>'s argument must be an integer or real, not 
<type>

10470: ord's argument must be of scalar type, not <type>

10480: <function>'s argument must be of scalar type, not 
<type>

10490: odd's argument must be an integer, not <type>

10500: chr's argument must be an integer, not <type>

10510: Argument to eoln must be a text file, not <type>

10520: Argument to eof must be file, not <type>

10530: Transfer functions take only one argument

10540: Arguments to <function> must be variables, not 
expressions

10550: Read requires an argument

10560: Write requires an argument

10570: Message requires an argument

10580: null takes no arguments

10590: <function> expects one argument

10600: Argument to <function> must be a file, not <type>

10610: <function> expects one or two arguments

10620: First argument to <function> must be a file, not <type>

10630: Second argument to <function> must be a string, not 
<type>

10640: <function> expects at least one argument

10650: (First) argument to <function> must be a pointer, not 
<type>

10660: Second and successive arguments to <function> must be 
constants

10670: Argument to <function> must be a alfa, not <type>

10680: halt takes no arguments

10690: stlimit requires one argument

10700: stlimit's argument must be an integer, not <type>

10710: remove expects one argument

10720: remove's argument must be a string, not <type>

10730: linelimit expects two arguments

10740: linelimit's second argument must be an integer, not 
<type>

10750: linelimit's first argument must be a text file, not 
<type>

10760: page expects one argument

10770: Argument to page must be a text file, not <type>

10780: Assert expects one or two arguments

10790: Second argument to assert must be a string, not 
<type>

10800: pack expects three arguments

10810: unpack expects three arguments

10820: Illegal transfer function argument

10830: constant argument expected

10840: Illegal argument with format radix specification; 
probably a comma missing

11010: have incompatible conformant array schemas

11020: sizeof(conformant array) is undefined

11030: Conformant arrays are not allowed at ANSI Level 0

11040: Subscripting allowed only on arrays, not on <type>s

11050: subrange value or array subscript (<integer>) is out 
of range

11060: compiler takes size of array

11070: Elements of a packed array cannot be passed by 
reference

11080: Subscripting allowed only on arrays and varying, not 
on <type>s

11090: Varying size must be a constant

11100: Size of <identifier> is zero

11110: Character array lower bound <> 1

11120: Character array upper bound of 1

11130: <function> requires a to be an unpacked array, not 
<type>

11140: <function> requires z to be a packed array, not <type>

11150: <operation> not allowed on arrays - only allow = and 
<>

11160: Packed multidimensional conformant arrays are not 
permitted

11170: For-statement variable <identifier> cannot be an element 
of a record

11180: . allowed only on records, not on <type>s

11190: <identifier> is not a field in this record

11200: Record required when specifying variant tags

11210: Missing case constants in variant record

11220: <identifier> is a duplicate field name in this record

11230: Duplicate variant case label in record

11240: <operation> not allowed on records - only allow = and 
<>

11250: Variable in with statement refers to <identifier>, not 
to a record

11260: Too many tag fields

11270: No variant case label value equals specified 
constant value

11280: Tag fields cannot be <type>s

11290: Bad variant constant

11300: variant required after case

12010: Assert expression must be Boolean, not <type>s

12020: illegal transfer function with <identifier>

12030: Illegal transfer function

12040: Transfer functions on bit fields not implemented

12050: Oct/hex allowed only on writeln/write calls

12060: Width expressions allowed only in writeln/write 
calls

12070: Cannot write <type>s with two write widths

12080: Can't write <identifier>s with oct/hex

12090: First write width must be integer, not <type>

12100: Second write width must be integer, not <type>

12110: Negative widths are not allowed

12120: Cannot write unpacked array to textfile

12130: Can't read <type>s from a text file

12140: Can't 'readln' a non text file

12150: Oct/hex allowed only on text files

12160: Write widths allowed only on text files

12170: Cannot write unpacked array to textfile

12180: Can't write <type>s to a text file

12190: Can't 'writeln' a non text file

13010: constant identifier required

13020: Constant value cannot be evaluated at compile-time

13030: Constant too large for this implementation

13040: <identifier> is a constant and cannot be qualified

13050: Constant string too long

13060: Constant expression is required

13070: constant argument expected

13080: newline in string or char constant

13090: empty character constant

13100: too many characters in character constant

14010: Constant declarations should precede type, var and 
routine declarations

14020: Label declarations should precede const, type, var 
and routine declarations

14030: Type declarations should precede var and routine 
declarations

14040: All types should be declared in one type part

14050: All constants should be declared in one const part

14060: INTERNAL ignored, procedure was previously declared 
PUBLIC or as EXTERNAL

14070: <function> has already been declared forward

14080: Unknown language <identifier> in EXTERN procedure 
declaration ignored

14090: Unresolved forward declaration of <function>

14100: <identifier> DEFINED, but not declared

14110: label <identifier> was declared but not defined

14120: PUBLIC procedures must be declared at outer block 
level

14130: PRIVATE ignored, procedure was declared DEFINED 
previously

14140: PUBLIC ignored, procedure was declared INTERNAL or 
PRIVATE previously

14150: PRIVATE ignored, procedure was declared PUBLIC or as 
EXTERNAL previously

14160: For-statement variable <identifier> must be declared in 
the block in which it is used

14170: All labels should be declared in one label part

14180: Expected identifier VARYING in declaration

14190: Variable declarations should precede routine 
declarations

14200: All variables should be declared in one var part

14210: public vars must be declared at outer block level

14220: Declarations may not be both STATIC and PUBLIC, 
STATIC is ignored

14230: Declarations may not be both DEFINE and PRIVATE, 
DEFINE is ignored

14240: Declarations may not be both EXTERN and PRIVATE, 
EXTERN is ignored

14250: <identifier> was declared in a DEFINE, cannot be STATIC

14260: <identifier> was declared in a DEFINE, cannot be PRIVATE

14270: <identifier> used as both a field and a type name in a 
record definition

14280: cannot DEFINE <identifier>, variable was not previously 
declared as EXTERN

14290: Declaration found when statement expected

14300: Expected keyword begin after declarations, before 
statements

14310: Improper initialization for variable <identifier>

14320: <identifier> is already defined globally

14330: Definition of name <identifier> after applied use in 
<identifier>

14340: Definition of name <identifier> after applied use

14350: <identifier> is already defined in this block

14360: Range lower bound exceeds upper bound

14370: '*' subrange descriptor used in illegal context

14380: Cannot initialize dynamic local variables

15010: File <identifier> listed in program statement but not 
declared

15020: File <identifier> listed in program statement but 
declared as a <identifier>

15030: File <identifier> listed in program statement but 
defined as <identifier>

15040: Files cannot be passed by value

15050: Files cannot be a component of <identifier> passed by 
value

15060: Pre-defined files input and output redefined

15070: Files cannot be members of files

15080: Missing closing <quote or bracket> for include file name

15090: Include filename must end in .i or .h

15100: Cannot open #include file <filename>

15110: line <number> does not exist in file <identifier>

15120: End-of-file expected - QUIT

15130: Unexpected end-of-file - QUIT

16010: <identifier> is not a function

16020: Too many levels of function/procedure nesting

16030: No assignment to the function variable

16040: Functions should not return <type>s

16050: Procedure/function nesting too deep

16060: pcc_fvar(): no result for this function

16070: <identifier> is a <class>, not a function

16080: Illegal function qualification

16090: compiler takes size of function

16100: Can't call <identifier>, its  not a pointer to a 
procedure or function

16110: Can't qualify a function result value

16120: Cannot assign value to built in function

16130: INTERNAL option illegal for procedure pointer - 
option ignored

16140: Unknown option for procedure pointer ignored : 
<option>

16150: Too many levels of function/procedure nesting

16160: Procedure/function nesting too deep

16170: Can't call <identifier>, its  not a pointer to a 
procedure or function

16180: Can't call <identifier>, it's <class> not a procedure

16190: Procedure <identifier> found where expression required

16200: Illegal procedure call, expecting value

16210: Non-pascal routine <identifier> will fail if called 
indirectly from pascal

16220: Passing nested routine <identifier> to non-pascal 
routine <identifier>

16230: Can't call <identifier>, its not a pointer to a 
procedure or function

17010: Case label out of range

17020: Real constant out of range for this implementation

17030: Short real out of range for this implementation

17040: Short real <number> out of range for this 
implementation

17050: Implementation restriction: sets must be indexed by 
16 bit quantities

17060: Subscript of <identifier> is out of range

17070: Subscript value of <number> is out of range

17080: subrange value or array subscript (<integer>) is out 
of range

17090: Successor of <integer> is out of range

17100: Predecessor of <integer> is out of range

17110: Value of <integer> is out of range

17120: Range upper bound of <integer> out of set bounds

17130: Range lower bound of <integer> out of set bounds

17140: Value of <integer> out of set bounds

17150: value of <integer> (initial assign. to for loop 
variable) is out of range

17160: Value of <integer> (terminal assign. to for loop 
variable) is out of range

17170: Tag type is out of range

17180: Base out of range (2..36)

18020: (* in a (* ... *) comment

18030: { in a { ... } comment

18040: Comment does not terminate - QUIT

18050: Illegal character, use the -xl option to process % 
compiler directives

18060: Illegal character

18070: unexpected EOF

18080: Point of error

18090: Parsing resumes

18100: Parse stack overflow

18110: Expression passed to UNIV formal <identifier> was 
converted to <type> of size <number> bytes

18120: 8 or 9 in octal number

18130: Number too large for this implementation

18140: <operation> is undefined for reals

18150: <identifier> cannot have more elements in z (<integer>) 
than in a (<integer>)

18160: <identifier> is an unimplemented extension

18180: Initializer must be a string

18190: Initialization string <string> is too long

18200: Expected 'options', not <identifier>

18210: Unknown option ignored : <identifier>

18220: Duplicate options specification : <identifier>

18230: Unimplemented option ignored : <identifier>

18240: <identifier> undefined on line <number>

18250: <identifier> improperly used on line <number>

18260: <identifier> is neither used nor set

18270: <identifier> is never used

18280: <identifier> is used but never set

18290: Length of external label for identifier <identifier> 
exceeds implementation limit

18300: Applied use of <identifier> before definition in this 
block

18320: <operation> is forbidden for reals

18420: Undefined <identifier>

18430: Undefined identifier

18440: Improper <identifier> identifier

18450: Deleted <token>

18460: Replaced <token> with a <token>

18470: Replaced <class> id with a <class> id

18480: Inserted <token>

18490: Expected <token>

18500: Label <identifier> not defined in correct block

18510: Label <identifier> redefined

18520: <identifier> is undefined

18530: ^ allowed only on files and pointers, not on <type>s

18540: Pascal uses [] for subscripting, not ()

18550: Error occurred on qualification of <identifier>

18560: division by 0

18580: Variable required in this context

18590: Universal pointers may not be dereferenced

18600: Illegal format

18610: Unknown format radix <identifier> ignored, expecting hex 
or oct

18620: Expression required

18630: Unreachable statement

18640: Unrecoverable syntax error - QUIT

18650: Too many syntax errors - QUIT

18660: Input line too long - QUIT

18670: Unrecognizable # statement

18680: Include syntax error - expected ' or \" not found

18690: Absurdly deep include nesting - QUIT

18700: Too many levels of include nesting - QUIT

18710: Bad arbitrary base integer

18720: Bad base <number> number, <number>

18730: Digits required after decimal point

18740: Digits required before decimal point

18750: Digits required in exponent

18760: Space required between number and word-symbol

18770: Character/string delimiter is '

18780: Unmatched ' for string

18790: Null string not allowed

18800: Invalid preprocessed file (probably renamed as 
'.p').  Compile the original .p file with -sb again

19010: Module name expected after keyword MODULE

19020: Identifiers after module name ignored

19030: Missing program statement

19040: Input is used but not defined in the program 
statement

19050: Output is used but not defined in the program 
statement

19060: Program parameter <identifier> is repeated

20010: Left operand of <operator> must be integer, real or 
set, not <type>

20020: Right operand of <operator> must be integer, real or 
set, not <type>

20030: Cannot mix sets with integers and reals as operands 
of <type>

20040: Operands of <operator> must be Boolean or Integer

20050: Left operand of / must be integer or real, not <type>

20060: Right operand of / must be integer or real, not 
<type>

20070: Left operand of <operator> must be Boolean, not <type>

20080: Right operand of <operator> must be Boolean, not <type>

20090: Left operand of <operator> must be integer, not <type>

20100: Right operand of <operator> must be integer, not <type>

20110: Right operand of 'in' must be a set, not <type>

20120: Operands of + are of incompatible types

20130: Operand of <operator> must be integer or real, not 
<type>

20140: Operands of <operator> must both be sets

20150: Set types of operands of <operator> must be compatible

20160: Incorrect statement usage const. with operand

20170: ^ allowed only on files and pointers, not on <type>s

20180: <operation> is an illegal operation on strings

20190: not must operate on a Boolean or Integer, not <type>

20200: not must operate on a Boolean, not <type>

20210: <operation> not allowed on pointers - only allow = and 
<>

20220: Strings not same length in <operator> comparison

20230: <identifier>s and <identifier>s cannot be compared - 
operator was <operator>

20240: <identifier>s may not participate in comparisons

21010: Attempt to pass IN parameter to formal reference 
parameter

21020: Expression type clashed with type of value parameter 
<identifier> of <identifier>

21030: Expression given (variable required) for var 
parameter <identifier> of <identifier>

21040: Parenthesis not allowed for var parameter <identifier> 
of <identifier>

21050: Parameter type not identical to type of var 
parameter <identifier> of <identifier>

21060: Packed/unpacked type conflict between formal and 
actual parameters

21070: Conformant array parameters in the same 
specification must be the same type

21080: actual parameter is not an array

21090: array index type is incompatible with conformant 
array parameter <identifier>

21100: array index type is not within of index type of 
conformant array parameter <identifier>

21110: array index type is not within 
range[<number>..<number>] of index type of conformant array 
parameter <identifier>

21130: <class> <identifier> given for formal <class> parameter 
<identifier>

21140: does not match type of formal <class> parameter 
<identifier> (line <number>)

21150: <class> parameter <identifier> of <identifier> (line <number>)

21160: does not match <class> parameter <identifier> of <identifier> 
(line <number>)

21170: Type of <class> parameter <identifier> of <identifier> (line 
<number>)

21180:  does not match type of <class> parameter <identifier> of 
<identifier> (line <number>)

21190: Parameter congruity error:  incompatible groupings

21200: Packed/unpacked type conflict between parameters of 
<identifier> and <identifier>

21210: than formal <class> parameter <identifier> (line <number>)

21220: Conformant array parameter bound symbol table entry 
is NULL

21230: Program parameter <identifier> is repeated

21240: Previous declaration for formal parameter '<identifier>' 
has different type

21250: Previous declaration for formal parameter '<identifier>' 
has different name '<identifier>'

21260: Previous declaration for procedure '<identifier>' had 
different number of formal parameters

21270: Formal <class> <name> cannot be qualified

21280: <class> <name> cannot be qualified

21290: Expression given, <class> required for <class> parameter 
<identifier>

21300: Variable given, <class> required for <class> parameter 
<identifier>

21310: Cannot take value of OUT parameter

21320: Invalid assignment to a parameter marked as IN

21330: Parameter congruity error: incompatible groupings

21340: UNIV parameter <identifier> should be passed as a var 
parameter

21350: Fields which select variant parts may not be passed 
by reference

21360: Cannot pass components of packed structures by 
reference

21370: Cannot pass components of packed structures by VAR, 
OUT, or IN/OUT

22010: Ran out of memory (gentypind)

22020: Ran out of memory (case)

22030: Ran out of memory (hash)

22040: Ran out of memory (TRIM)

22050: Ran out of memory (defnl)

22060: Ran out of memory (buffer_ir_pass)

22070: Ran out of memory (string)

22080: Ran out of memory (tralloc)

22090: out of memory (tstr)

22100: out of memory

22110: Ran out of hash tables

22120: Ran out of tree tables

22130: Out of space (put_on_idlist)

22140: out of tree space; try simplifying

22150: out of temporary string space

23010: <identifier> is a non-standard function

23020: <identifier> is a non-standard procedure

23030: Two argument forms of reset and rewrite are non-
standard

23040: NIL values in const declaration are non-standard

23050: Set constants in const declaration are non-standard

23060: Expressions in const declaration are non-standard

23070: Routine Options are not standard

23080: External procedures and functions are not standard

23090: Separately compiled routine segments are not 
standard

23100: UNIV parameters are non-standard

23110: IN parameters are non-standard

23120: OUT parameters are non-standard

23130: IN OUT parameters are non-standard

23140: <identifier> is a nonstandard function

23150: OTHERWISE clause in case statements is non-standard

23160: Ranges in case statements are non-standard

23170: Transfer functions are non-standard

23180: Reading scalars from text files is non-standard

23190: Writing <type>s with two write widths is non-standard

23200: Zero widths are non-standard

23210: Oct and hex are non-standard

23220: Writing <type>s to text files is non-standard

23230: <identifier> is a nonstandard procedure

23240: Short-circuit operators are non-standard

23250: <operator> comparison on sets is non-standard

23260: record comparison is non-standard

23270: Storage Class non-standard

23280: Initialization in declaration part is non-standard

23290: UNIV_PTR types are non-standard

23300: '_' in an identifier is nonstandard

23310: Octal constants are non-standard

23320: <operator> is non-standard

24010: Cannot exit -- not within a loop

24020: For-statement variable <identifier> must be unqualified

24030: For-statement variable <identifier> cannot be an element 
of a record

24040: For-statement variable <identifier> may be illegally 
changed at line <number>

24050: For-statement variable <identifier> must be declared in 
the block in which it is used

24060: For-statement variable <identifier> cannot be <type>s

24070: Can't modify the for-statement variable <identifier> in 
the range of the loop

24080: Incorrect control variable

24090: Type of initial expression clashed with index type 
in 'for' statement

24100: Type of limit expression clashed with index type in 
'for' statement

24110: Can't modify the for variable <identifier> in the range 
of the loop

24120: Case selectors cannot be <type>s

24130: Duplicate otherwise clause in case statement

24140: Case label type clashed with case selector 
expression type

24150: Multiply defined label in case, lines <number> and 
<number>

24160: No case-list-elements

24170: Bad case constant

24180: Range in case label must be in ascending order

24190: Maximum number of case selectors exceeded

24200: Cannot next -- not within a loop

24210: Goto <label> is into a structured statement

24220: Goto <label> from line <number> is into a structured 
statement

24230: Variable in with statement refers to <type>, not to a 
record

24240: Maximum WITH nesting depth exceeded, ignoring WITH 
variables

24250: Variable in with statement not correct

24260: cannot assign to lhs

24270: Variable required

24280: <class> <identifier> found where variable required

24290: univ_ptr variable cannot be dereferenced in 
assignment

24300: Improper use of the DEFINE statement

24310: End matched <keyword> on line <number>

24320: Inserted keyword end matching {begin|record|class} 
on line <number>

25010: {pack|unpack}: elements of a and z must have the 
same type

25020: component types of formal and actual arrays are not 
conformable

25030: Type of function <name> (line <number>)

25040: Case label type clashed with case selector 
expression type

25050: Type clash: initializer must be a pointer

25060: Type clash: type of initializer does not match type 
of array

25070: Type clash: Integer is incompatible with real

25080: Type clash:  Initializer out of range

25090: Type clash: real is incompatible with integer

25100: This resulted because you used '/' which always 
returns real rather

25110: than 'div' which divides integers and returns 
integers

25120: Type clash: non-identical scalar types

25130: Type clash: unequal length strings

25140: Type clash: varying char and unknown

25150: Type clash: packed and unpacked set

25160: Type clash: files not allowed in this context

25170: Type clash: non-identical <class> types

25180: Type clash: <type>s with file components not allowed 
in this context

25190: Type clash: <type> is incompatible with <type>

25200: Type clash: string and unpacked array

25210: Type clash: string and packed array with lower bound 
<> 1

25220: Type clash: Non-identical string types must be 
packed

25230: Type clash: packed array with lower bound <> 1

25240: Set default type 'intset' is not a set

25250: Upper bound of element type clashed with set type in 
constant set

25260: Lower bound of element type clashed with set type in 
constant set

25270: Element type clashed with set type in constant set

25280: Set elements must be scalars, not <type>s

25290: Set of real is not allowed

25300: Procedures cannot have types

25310: Function type can be specified only by using a type 
identifier

25320: Function type should be given only in forward 
declaration

25330: Different type declared previously for function 
return <name>

25340: Function type must be specified

25350: Type of expression in while statement must be 
Boolean, not <type>

25360: Until expression type must be Boolean, not <type>, in 
repeat statement

25370: Array index type incompatible with declared index 
type

25380: Too many subscripts

25390: Bad type of variable used for call

25400: Transfer functions only work on types of the same 
size

25410: Only type char allowed in varying array

25420: Type mismatch in read from non-text file

25430: Type mismatch in write to non-text file

25440: Specified tag constant type clashed with variant 
case selector type

25460: Tag type is out of range

25470: Variant label type incompatible with selector type

25480: set types must be compatible in comparisons - 
operator was <operator>

25490: <class> types must be identical in comparisons - 
operator was <operator>

25500: Index type clashed with set component type for 'in'

25510: Operands of + are of incompatible types

25520: Type names (e.g. <type>) allowed only in declarations

25530: Type name (e.g. <type>) found in illegal context

25540: Set types of operands of <operator> must be compatible

25550: expression has invalid type

25560: Type of expression clashed with type of variable in 
assignment

25570: Type of expression in if statement must be Boolean, 
not <type>

25580: Type of transfer function does not match type of 
right side

25590: <identifier> is a <class>, not a type as required

25600: Set type must be range or scalar, not <type>

25610: Sets must have basetype with range <number>..<number>

25620: Subrange type cannot contain a expression

25630: Scalar types must be identical in subranges

25640: Can't mix <identifier>s and <identifier>s in subranges

25650: Subrange of real is not allowed

25660: Subrange bounds must be Boolean, character, integer 
or scalar, not <type>

25670: Index type for arrays cannot be real

25680: Array index type is a <type>, not a range or scalar 
as required

25690: Packed conformant array schema requires type 
identifier as element type

25700: Illegal type in VARYING array, only type CHAR 
allowed

25710: Size of <type> type exceeds implementation limits

25720: Initializer must be a constant value of same type

26010: Malformed program statement

26020: Malformed declaration

26030: Malformed const declaration

26040: Malformed type declaration

26050: Malformed var declaration

26060: Malformed record declaration

26070: Malformed statement in case

26080: Malformed statement

26090: Missing/malformed expression

26100: Label restricted to 4 digits

26110: Label declared non-integer

26120: Replaced unknown parameter specifier <identifier> with 
OUT

26130: Deleted ';' before keyword else

26140: Extension to WITH statement not allowed

27010: Integer overflow in constant expression

18340: ir_symbol: unknown class

18350: ir_leaf: cannot take address of op <identifier>

18360: ir_leaf: illegal leaf node, op = <identifier>

18370: ir_starg: illegal STARG

18380: ir_exit: no return label

18390: cannot take address of op <identifier>

18400: op '<identifier>' not implemented yet

18410: goal <integer> not defined for op <operation>

18570: wasted space: <number>