| HI2000 |
UNKNOWN ERROR
Contact Microsoft Product Support Services |
| |
The compiler detected an unknown error condition. |
| |
Note the circumstances of the error and notify Microsoft Corporation by following the instructions on the Microsoft Product Assistance Request form at the back of one of your manuals. |
| HI2001 |
newline in constant |
| |
A string constant was continued onto a second line without either a backslash or closing and opening quotes. |
| |
To break a string constant onto two lines in the source file, do one of the following:
 End the first line with the line-continuation character, a backslash, \.
Close the string on the first line with a double quotation mark, and open the string on the next line with another quotation mark.
|
| |
It is not sufficient to end the first line with \n, the escape sequence for embedding a newline character in a string constant. |
| |
The following two examples demonstrate causes of this error:
printf("Hello,
world");
|
| |
or
printf("Hello,\n
world");
|
| |
The following two examples show ways to correct this error:
printf("Hello,\
world");
|
| |
or
printf("Hello,"
" world");
|
| |
Note that any spaces at the beginning of the next line after a line-continuation character are included in the string constant. Note, also, that neither solution actually places a newline character into the string constant. To embed this character:
printf("Hello,\n\
world");
|
| |
or
printf("Hello,\
\nworld");
|
| |
or
printf("Hello,\n"
"world");
|
| |
or
printf("Hello,"
"\nworld");
|
| HI2003 |
expected defined id |
| |
An identifier was expected after the preprocessing keyword defined. |
| HI2004 |
expected defined(id) |
| |
An identifier was expected after the left parenthesis, (, following the preprocessing keyword defined. |
| HI2005 |
#line expected a line number, found token |
| |
A #line directive lacked the required line-number specification. |
| HI2006 |
#include expected a file name, found token |
| |
An #include directive lacked the required filename specification. |
| HI2007 |
#define syntax |
| |
An identifier was expected following #define in a preprocessing directive. |
| HI2008 |
character : unexpected in macro definition |
| |
The given character was found immediately following the name of the macro. |
| HI2009 |
reuse of macro formal identifier |
| |
The given identifier was used more than once in the formal-parameter list of a macro definition. |
| HI2010 |
character : unexpected in macro formal-parameter list |
| |
The given character was used incorrectly in the formal-parameter list of a macro definition. |
| HI2012 |
missing name following '<' |
| |
An #include directive lacked the required filename specification. |
| HI2013 |
missing '>' |
| |
The closing angle bracket (>) was missing from an #include directive. |
| HI2014 |
preprocessor command must start as first non-white-space |
| |
Non-white-space characters appeared before the number sign (#) of a preprocessor directive on the same line. |
| HI2015 |
too many characters in constant |
| |
A character constant contained more than one character. |
| |
Note that an escape sequence (for example, \t for tab) is converted to a single character. |
| HI2016 |
no closing single quotation mark |
| |
A newline character was found before the closing single quotation mark of a character constant. |
| HI2017 |
illegal escape sequence |
| |
An escape sequence appeared where one was not expected. |
| |
An escape sequence (a backslash, \, followed by a number or letter) may occur only in a character or string constant. |
| HI2018 |
unknown character hexnumber |
| |
The ASCII character corresponding to the given hexadecimal number appeared in the source file but is an illegal character. |
| |
One possible cause of this error is corruption of the source file. Edit the file and look at the line on which the error occurred. |
| HI2019 |
expected preprocessor directive, found character |
| |
The given character followed a number sign (#), but it was not the first letter of a preprocessor directive. |
| HI2021 |
expected exponent value, not character |
| |
The given character was used as the exponent of a floating-point constant but was not a valid number. |
| HI2022 |
number : too big for character |
| |
The octal number following a backslash (\) in a character or string constant was too large to be represented as a character. |
| HI2025 |
identifier : enum/struct/union type redefinition |
| |
The given identifier had already been used for an enumeration, structure, or union tag. |
| HI2026 |
identifier : member of enum redefinition |
| |
The given identifier has already been used for an enumeration constant, either within the same enumeration type or within another visible enumeration type. |
| HI2027 |
use of undefined enum/struct/union identifier |
| |
The given identifier referred to a structure or union type that was not defined. |
| HI2028 |
struct/union member needs to be inside a struct/union |
| |
Structure and union members must be declared within the structure or union. |
| |
This error may be caused by an enumeration declaration containing a declaration of a structure member, as in the following example:
enum a {
january,
february,
int march; /* Illegal structure declaration */
};
|
| HI2030 |
identifier : struct/union member redefinition |
| |
The identifier was used for more than one member of the same structure or union. |
| HI2031 |
identifier : function cannot be struct/union member |
| |
The given function was declared to be a member of a structure or union. |
| |
To correct this error, use a pointer to the function instead. |
| HI2033 |
identifier : bit field cannot have indirection |
| |
The given bit field was declared as a pointer (*), which is not allowed. |
| HI2034 |
identifier : type of bit field too small for number of bits |
| |
The number of bits specified in the bit-field declaration exceeded the number of bits in the given base type. |
| HI2035 |
struct/union identifier : unknown size |
| |
The given structure or union had an undefined size. |
| |
Usually this occurs when referencing a declared but not defined structure or union tag. |
| |
For example, the following causes this error:
struct s_tag *ps;
ps = &my_var;
*ps = 17; /* This line causes the error */
|
| HI2037 |
left of operator specifies undefined struct/union identifier |
| |
The expression before the member-selection operator ( -> or .) identified a structure or union type that was not defined. |
| HI2038 |
identifier : not struct/union member |
| |
The given identifier was used in a context that required a structure or union member. |
| HI2041 |
illegal digit character for base number |
| |
The given character was not a legal digit for the base used. |
| HI2042 |
signed/unsigned keywords mutually exclusive |
| |
The keywords signed and unsigned were both used in a single declaration, as in the following example:
unsigned signed int i;
|
| HI2056 |
illegal expression |
| |
An expression was illegal because of a previous error, which may not have produced an error message. |
| HI2057 |
expected constant expression |
| |
The context requires a constant expression. |
| HI2058 |
constant expression is not integral |
| |
The context requires an integral constant expression. |
| HI2059 |
syntax error : token |
| |
The token caused a syntax error. |
| HI2060 |
syntax error : end-of-file found |
| |
The compiler expected at least one more token. |
| |
Some causes of this error include: |
| |
Omitting a semicolon (;), as in
int *p
|
| |
Omitting a closing brace (}) from the last function, as in
main()
{
|
| HI2061 |
syntax error : identifier identifier |
| |
The identifier caused a syntax error. |
| HI2062 |
type type unexpected |
| |
The compiler did not expect the given type to appear here, possibly because it already had a required type. |
| HI2063 |
identifier : not a function |
| |
The given identifier was not declared as a function, but an attempt was made to use it as a function. |
| HI2064 |
term does not evaluate to a function |
| |
An attempt was made to call a function through an expression that did not evaluate to a function pointer. |
| HI2065 |
identifier : undefined |
| |
An attempt was made to use an identifier that was not defined. |
| HI2066 |
cast to function type is illegal |
| |
An object was cast to a function type, which is illegal. |
| |
However, it is legal to cast an object to a function pointer. |
| HI2067 |
cast to array type is illegal |
| |
An object was cast to an array type. |
| HI2068 |
illegal cast |
| |
A type used in a cast operation was not legal for this expression. |
| HI2069 |
cast of void term to nonvoid |
| |
The void type was cast to a different type. |
| HI2070 |
illegal sizeof operand |
| |
The operand of a sizeof expression was not an identifier or a type name. |
| HI2071 |
identifier : illegal storage class |
| |
The given storage class cannot be used in this context. |
| HI2072 |
identifier : initialization of a function |
| |
An attempt was made to initialize a function. |
| HI2043 |
illegal break |
| |
A break statement is legal only within a do, for, while, or switch statement. |
| HI2044 |
illegal continue |
| |
A continue statement is legal only within a do, for, or while statement. |
| HI2045 |
identifier : label redefined |
| |
The label appeared before more than one statement in the same function. |
| HI2046 |
illegal case |
| |
The keyword case may appear only within a switch statement. |
| HI2047 |
illegal default |
| |
The keyword default may appear only within a switch statement. |
| HI2048 |
more than one default |
| |
A switch statement contained more than one default label. |
| HI2049 |
case value value already used |
| |
The case value was already used in this switch statement. |
| HI2050 |
nonintegral switch expression |
| |
A switch expression did not evaluate to an integral value. |
| HI2051 |
case expression not constant |
| |
Case expressions must be integral constants. |
| HI2052 |
case expression not integral |
| |
Case expressions must be integral constants. |
| HI2054 |
expected '(' to follow identifier |
| |
The context requires parentheses after the function identifier. |
| |
One cause of this error is forgetting an equal sign (=) on a complex initialization, as in
int array1[] /* Missing = */
{
1,2,3
};
|
| HI2055 |
expected formal-parameter list, not a type list |
| |
An argument-type list appeared in a function definition instead of a formal-parameter list. |
| HI2075 |
identifier : array initialization needs curly braces |
| |
There were no curly braces, {}, around the given array initializer. |
| HI2076 |
identifier : struct/union initialization needs curly braces |
| |
There were no curly braces, {}, around the given structure or union initializer. |
| HI2077 |
nonscalar field initializer identifier |
| |
An attempt was made to initialize a bit-field member of a structure with a nonscalar value. |
| HI2078 |
too many initializers |
| |
The number of initializers exceeded the number of objects to be initialized. |
| HI2079 |
identifier uses undefined struct/union name |
| |
The identifier was declared as structure or union type name, but the name had not been defined. This error may also occur if an attempt is made to initialize an anonymous union. |
| HI2080 |
illegal far _fastcall function |
| |
A far _fastcall function may not be compiled with the /Gw option, nor with the /Gq option if stack checking is enabled. |
| HI2082 |
redefinition of formal parameter identifier |
| |
A formal parameter to a function was redeclared within the function body. |
| HI2084 |
function function already has a body |
| |
The function has already been defined. |
| HI2086 |
identifier : redefinition |
| |
The given identifier was defined more than once, or a subsequent declaration differed from a previous one. |
| |
The following are ways to cause this error:
int a;
char a;
main()
{
}
main()
{
int a;
int a;
}
|
| |
However, the following does not cause this error:
int a;
int a;
main()
{
}
|
| HI2087 |
identifier : missing subscript |
| |
The definition of an array with multiple subscripts was missing a subscript value for a dimension other than the first dimension. |
| |
The following is an example of an illegal definition:
int func(a)
char a[10][];
{ }
|
| |
The following is an example of a legal definition:
int func(a)
char a[][5];
{ }
|
| HI2090 |
function returns array |
| |
A function cannot return an array. It can return a pointer to an array. |
| HI2091 |
function returns function |
| |
A function cannot return a function. It can return a pointer to a function. |
| HI2092 |
array element type cannot be function |
| |
Arrays of functions are not allowed. Arrays of pointers to functions are allowed. |
| HI2095 |
function : actual has type void : parameter number |
| |
An attempt was made to pass a void argument to a function. The given number indicates which argument was in error. |
| |
Formal parameters and arguments to functions cannot have type void. They can, however, have type void * (pointer to void). |
| HI2100 |
illegal indirection |
| |
The indirection operator (*) was applied to a nonpointer value. |
| HI2101 |
'&' on constant |
| |
The address-of operator (&) did not have an lvalue as its operand. |
| HI2102 |
'&' requires lvalue |
| |
The address-of operator (&) must be applied to an lvalue expression. |
| HI2103 |
'&' on register variable |
| |
An attempt was made to take the address of a register variable. |
| HI2104 |
'&' on bit field ignored |
| |
An attempt was made to take the address of a bit field. |
| HI2105 |
operator needs lvalue |
| |
The given operator did not have an lvalue operand. |
| HI2106 |
operator : left operand must be lvalue |
| |
The left operand of the given operator was not an lvalue. |
| HI2107 |
illegal index, indirection not allowed |
| |
A subscript was applied to an expression that did not evaluate to a pointer. |
| HI2108 |
nonintegral index |
| |
A nonintegral expression was used in an array subscript. |
| HI2109 |
subscript on nonarray |
| |
A subscript was used on a variable that was not an array. |
| HI2110 |
pointer + pointer |
| |
An attempt was made to add one pointer to another using the plus (+) operator. |
| HI2111 |
pointer + nonintegral value |
| |
An attempt was made to add a nonintegral value to a pointer. |
| HI2112 |
illegal pointer subtraction |
| |
An attempt was made to subtract pointers that did not point to the same type. |
| HI2113 |
pointer subtracted from nonpointer |
| |
The right operand in a subtraction operation using the minus (-) operator was a pointer, but the left operand was not. |
| HI2114 |
operator : pointer on left; needs integral right |
| |
The left operand of the given operator was a pointer, so the right operand must be an integral value. |
| HI2115 |
identifier : incompatible types |
| |
An expression contained incompatible types. |
| HI2117 |
operator : illegal for struct/union |
| |
Structure and union type values are not allowed with the given operator. |
| HI2118 |
negative subscript |
| |
A value defining an array size was negative. |
| HI2120 |
void illegal with all types |
| |
The void type was used in a declaration with another type. |
| HI2121 |
operator : bad left/right operand |
| |
The left or right operand of the given operator was illegal for that operator. |
| HI2124 |
divide or mod by zero |
| |
A constant expression was evaluated and found to have a zero denominator. |
| HI2128 |
identifier : huge array cannot be aligned to segment boundary |
| |
The given huge array was large enough to cross two segment boundaries, but could not be aligned to both boundaries to prevent an individual array element from crossing a boundary. |
| |
If the size of a huge array causes it to cross two boundaries, the size of each array element must be a power of two, so that a whole number of elements will fit between two segment boundaries. |
| HI2129 |
static function function not found |
| |
A forward reference was made to a static function that was never defined. |
| HI2130 |
#line expected a string containing the file name, found token |
| |
The optional token following the line number on a #line directive was not a string. |
| HI2131 |
more than one memory attribute |
| |
More than one of the keywords _near, _far, _huge, or _based were applied to an item, as in the following example:
typedef int _near nint;
nint _far a; /* Illegal */
|
| HI2132 |
syntax error : unexpected identifier |
| |
An identifier appeared in a syntactically illegal context. |
| HI2133 |
identifier : unknown size |
| |
An attempt was made to declare an unsized array as a local variable. |
| HI2134 |
identifier : struct/union too large |
| |
The size of a structure or union exceeded the 64K compiler limit. |
| HI2136 |
function : prototype must have parameter types |
| |
A function prototype declarator had formal-parameter names, but no types were provided for the parameters. |
| |
A formal parameter in a function prototype must either have a type or be represented by an ellipsis (...) to indicate a variable number of arguments and no type checking. |
| |
One cause of this error is a misspelling of a type name in a prototype that does not provide the names of formal parameters. |
| HI2137 |
empty character constant |
| |
The illegal empty-character constant (`') was used. |
| HI2139 |
type following identifier is illegal |
| |
Two types were used in the same declaration. |
| |
For example:
int double a;
|
| HI2141 |
value out of range for enum constant |
| |
An enumeration constant had a value outside the range of values allowed for type int. |
| HI2143 |
syntax error : missing token1 before token2 |
| |
The compiler expected token1 to appear before token2. |
| |
This message may appear if a required closing brace (}), right parenthesis ()), or semicolon (;) is missing. |
| HI2144 |
syntax error : missing token before type type |
| |
The compiler expected the given token to appear before the given type name. |
| |
This message may appear if a required closing brace (}), right parenthesis ()), or semicolon (;) is missing. |
| HI2145 |
syntax error : missing token before identifier |
| |
The compiler expected the given token to appear before an identifier. |
| |
This message may appear if a semicolon (;) does not appear after the last declaration of a block. |
| HI2146 |
syntax error : missing token before identifier identifier |
| |
The compiler expected the given token to appear before the given identifier. |
| HI2147 |
unknown size |
| |
An attempt was made to increment an index or pointer to an array whose base type has not yet been declared. |
| HI2148 |
array too large |
| |
An array exceeded the maximum legal size of 64K. |
| |
Either reduce the size of the array, or declare it with _huge. |
| HI2149 |
identifier : named bit field cannot have 0 width |
| |
The given named bit field had zero width. Only unnamed bit fields are allowed to have zero width. |
| HI2150 |
identifier : bit field must have type int, signed int, or unsigned int |
| |
The ANSI C standard requires bit fields to have types of int, signed int, or unsigned int. This message appears only when compiling with the /Za option. |
| HI2151 |
more than one language attribute |
| |
More than one keyword specifying a calling convention for a function was given. |
| HI2152 |
identifier : pointers to functions with different attributes |
| |
An attempt was made to assign a pointer to a function declared with one calling convention (_cdecl, _fortran, _pascal, or _fastcall) to a pointer to a function declared with a different calling convention. |
| HI2153 |
hex constants must have at least 1 hex digit |
| |
The hexadecimal constants 0x, 0X, and \x are illegal. At least one hexadecimal digit must follow the x or X. |
| HI2154 |
segment : does not refer to a segment name |
| |
A _based-allocated variable must be allocated in a segment unless it is extern and uninitialized. |
| HI2156 |
pragma must be outside function |
| |
A pragma that must be specified at a global level, outside a function body, occurred within a function. |
| |
For example, the following causes this error:
main()
{
#pragma optimize("l", on)
}
|
| HI2157 |
function : must be declared before use in pragma list |
| |
The function name in the list of functions for an alloc_text pragma has not been declared prior to being referenced in the list. |
| HI2158 |
identifier : is a function |
| |
The given identifier was specified in the list of variables in a same_seg pragma but was previously declared as a function. |
| HI2159 |
more than one storage class specified |
| |
A declaration contained more than one storage class, as in
extern static int i;
|
| HI2160 |
## cannot occur at the beginning of a macro definition |
| |
A macro definition began with a token-pasting operator (##), as in
#define mac(a,b) ##a
|
| HI2161 |
## cannot occur at the end of a macro definition |
| |
A macro definition ended with a token-pasting operator (##), as in
#define mac(a,b) a##
|
| HI2162 |
expected macro formal parameter |
| |
The token following a stringizing operator (#) was not a formal-parameter name. |
| |
For example:
#define print(a) printf(#b)
|
| HI2165 |
keyword : cannot modify pointers to data |
| |
The _fortran, _pascal, _cdecl, or _fastcall keyword was used illegally to modify a pointer to data, as in the following example:
char _pascal *p;
|
| HI2166 |
lvalue specifies const object |
| |
An attempt was made to modify an item declared with const type. |
| HI2167 |
function : too many actual parameters for intrinsic function |
| |
A reference to the intrinsic function name contained too many actual parameters. |
| HI2168 |
function : too few actual parameters for intrinsic function |
| |
A reference to the intrinsic function name contained too few actual parameters. |
| HI2171 |
operator : illegal operand |
| |
The given unary operator was used with an illegal operand type, as in the following example:
int (*fp)();
double d,d1;
fp++;
d = ~d1;
|
| HI2172 |
function : actual is not a pointer : parameter number |
| |
An attempt was made to pass an argument that was not a pointer to a function that expected a pointer. The given number indicates which argument was in error. |
| HI2173 |
function : actual is not a pointer : parameter number1,
parameter list number2 |
| |
An attempt was made to pass a nonpointer argument to a function that expected a pointer. |
| |
This error occurs in calls that return a pointer to a function. The first number indicates which argument was in error; the second number indicates which argument list contained the invalid argument. |
| HI2174 |
function : actual has type void : parameter number1,
parameter list number2 |
| |
An attempt was made to pass a void argument to a function. Formal parameters and arguments to functions cannot have type void. They can, however, have type void * (pointer to void). |
| |
This error occurs in calls that return a pointer to a function. The first number indicates which argument was in error; the second number indicates which argument list contained the invalid argument. |
| HI2177 |
constant too big |
| |
Information was lost because a constant value was too large to be represented in the type to which it was assigned. |
| HI2178 |
identifier : storage class for same_seg variables must be extern |
| |
The given variable was specified in a same_seg pragma, but it was not declared with extern storage class. |
| HI2179 |
identifier : was used in same_seg, but storage class is no longer extern |
| |
The given variable was specified in a same_seg pragma, but it was redeclared with a storage class other than extern. |
| HI2185 |
identifier : illegal _based allocation |
| |
A _based-allocated variable that explicitly has extern storage class and is uninitialized may not have a base of any of the following:
(_segment) & var
_segname("_STACK")
(_segment)_self
void
|
| |
If the variable does not explicitly have extern storage class or it is uninitialized, then its base must use _segname("string") where string is any segment name or reserved segment name except "_STACK". |
| HI2187 |
cast of near function pointer to far function pointer |
| |
An attempt was made to cast a near function pointer as a far function pointer. |
| HI2189 |
#error : string |
| |
An #error directive was encountered. The string is the descriptive text supplied in the directive. |
| HI2193 |
identifier : already in a segment |
| |
A variable in the same_seg pragma has already been allocated in a segment, using _based. |
| HI2194 |
segment : is a text segment |
| |
The given text segment was used where a data, const, or bss segment was expected. |
| HI2195 |
segment : is a data segment |
| |
The given data segment was used where a text segment was expected. |
| HI2200 |
function : function has already been defined |
| |
A function name passed as an argument in an alloc_text pragma has already been defined. |
| HI2201 |
function : storage class must be extern |
| |
A function declaration appears within a block, but the function is not declared extern. This causes an error if the /Za option is in effect. |
| |
For example, the following causes this error, when compiled with /Za:
main()
{
static int func1();
}
|
| HI2205 |
identifier : cannot initialize extern block-scoped variables |
| |
A variable with extern storage class may not be initialized in a function. |
| HI2208 |
no members defined using this type |
| |
An enum, struct, or union was defined without any members. This is an error only when compiling with /Za; otherwise, it is a warning. |
| HI2209 |
type cast in _based construct must be (_segment) |
| |
The only type allowed within a cast in a _based declarator is (_segment). |
| HI2210 |
identifier : must be near/far data pointer |
| |
The base in a _based declarator may not be an array, a function, or a _based pointer. |
| HI2211 |
(_segment) applied to function identifier function |
| |
The item cast in a _based declarator must not be a function. |
| HI2212 |
identifier : _based not available for functions/pointers to functions |
| |
Functions cannot be _based-allocated. Use the alloc_text pragma. |
| HI2213 |
identifier : illegal argument to _based |
| |
A symbol used as a base must have type _segment or be a near or far pointer. |
| HI2214 |
pointers based on void require the use of :> |
| |
A _based pointer based on void cannot be dereferenced. Use the :> operator to create an address that can be dereferenced. |
| HI2215 |
:> operator only for objects based on void |
| |
The right operand of the :> operator must be a pointer based on void, as in
char _based(void) *cbvpi
|
| HI2216 |
attribute1 may not be used with attribute2 |
| |
The given function attributes are incompatible. |
| |
Some combinations of attributes that cause this error are
_saveregs and _interrupt
_fastcall and _saveregs
_fastcall and _interrupt
_fastcall and _export
|
| HI2217 |
attribute1 must be used with attribute2 |
| |
The first function attribute requires the second attribute to be used. |
| |
Some causes for this error include
An interrupt function explicitly declared as near. Interrupt functions must be far.
An interrupt function or a function with a variable number of arguments, when that function is declared with the _fortran, _pascal, or _fastcall attribute. Functions declared with the _interrupt attribute or with a variable number of arguments must use the C calling conventions. Remove the _fortran, _pascal, or _fastcall attribute from the function declaration.
|
| HI2218 |
type in _based construct must be void |
| |
The only type allowed within a _based construct is void. |
| HI2219 |
syntax error : type qualifier must be after '*' |
| |
Either const or volatile appeared where a type or qualifier is not allowed, as in
int (const *p);
|
| HI2220 |
warning treated as error - no object file generated |
| |
When the compiler option /WX is used, the first warning generated by the compiler causes this error message to be displayed. |
| |
Either correct the condition that caused the warning, or compile at a lower warning level or without /WX. |
| HI2221 |
'.' : left operand points to struct/union, use -> |
| |
The left operand of the '.' operator must be a struct/union type. It cannot be a pointer to a struct/union type. |
| |
This error usually means that a -> operator must be used. |
| HI2222 |
-> : left operand has struct/union type, use '.' |
| |
The left operand of the -> operator must be a pointer to a struct/union type. It cannot be a struct/union type. |
| |
This error usually means that a '.' operator must be used. |
| HI2223 |
left of ->member must point to struct/union |
| |
The left operand of the -> operator is not a pointer to a struct/union type. |
| |
This error can occur when the left operand is an undefined variable. Undefined variables have type int. |
| HI2224 |
left of .member must have struct/union type |
| |
The left operand of the '.' operator is not a struct/union type. |
| |
This error can occur when the left operand is an undefined variable. Undefined variables have type int. |
| HI2225 |
tagname : first member of struct is unnamed |
| |
The struct with the given tag started with an unnamed member (an alignment member). Struct definitions must start with a named member. |