```.mw-parser-output .ada-kw{background:none;border:none;padding:0;margin:0;color:DodgerBlue;font-weight:bold}.mw-parser-output .ada-kw a,.mw-parser-output .ada-kw a:visited{color:inherit}`package` Standard `is`
`pragma` Pure (Standard);

`type` Boolean `is` (False, True);

-- The predefined relational operators for this type are as follows:

-- function "="   (Left, Right : Boolean'Base) return Boolean;
-- function "/="  (Left, Right : Boolean'Base) return Boolean;
-- function "<"   (Left, Right : Boolean'Base) return Boolean;
-- function "<="  (Left, Right : Boolean'Base) return Boolean;
-- function ">"   (Left, Right : Boolean'Base) return Boolean;
-- function ">="  (Left, Right : Boolean'Base) return Boolean;

-- The predefined logical operators and the predefined logical
-- negation operator are as follows:

-- function "and" (Left, Right : Boolean'Base) return Boolean;
-- function "or"  (Left, Right : Boolean'Base) return Boolean;
-- function "xor" (Left, Right : Boolean'Base) return Boolean;

-- function "not" (Right : Boolean'Base) return Boolean;

-- The integer type root_integer and the
-- corresponding universal type universal_integer are predefined.

`type` Integer `is` `range` implementation-defined;

`subtype` Natural  `is` Integer `range` 0 .. Integer'Last;
`subtype` Positive `is` Integer `range` 1 .. Integer'Last;

-- The predefined operators for type Integer are as follows:

-- function "="  (Left, Right : Integer'Base) return Boolean;
-- function "/=" (Left, Right : Integer'Base) return Boolean;
-- function "<"  (Left, Right : Integer'Base) return Boolean;
-- function "<=" (Left, Right : Integer'Base) return Boolean;
-- function ">"  (Left, Right : Integer'Base) return Boolean;
-- function ">=" (Left, Right : Integer'Base) return Boolean;

-- function "+"   (Right : Integer'Base) return Integer'Base;
-- function "-"   (Right : Integer'Base) return Integer'Base;
-- function "abs" (Right : Integer'Base) return Integer'Base;

-- function "+"   (Left, Right : Integer'Base) return Integer'Base;
-- function "-"   (Left, Right : Integer'Base) return Integer'Base;
-- function "*"   (Left, Right : Integer'Base) return Integer'Base;
-- function "/"   (Left, Right : Integer'Base) return Integer'Base;
-- function "rem" (Left, Right : Integer'Base) return Integer'Base;
-- function "mod" (Left, Right : Integer'Base) return Integer'Base;

-- function "**"  (Left : Integer'Base; Right : Natural)
--                  return Integer'Base;

-- The specification of each operator for the type
-- root_integer, or for any additional predefined integer
-- type, is obtained by replacing Integer by the name of the type
-- in the specification of the corresponding operator of the type
-- Integer. The right operand of the exponentiation operator
-- remains as subtype Natural.

-- The floating point type root_real and the
-- corresponding universal type universal_real are predefined

`type` Float `is` `digits` implementation-defined;

-- The predefined operators for this type are as follows:

-- function "="   (Left, Right : Float) return Boolean;
-- function "/="  (Left, Right : Float) return Boolean;
-- function "<"   (Left, Right : Float) return Boolean;
-- function "<="  (Left, Right : Float) return Boolean;
-- function ">"   (Left, Right : Float) return Boolean;
-- function ">="  (Left, Right : Float) return Boolean;

-- function "+"   (Right : Float) return Float;
-- function "-"   (Right : Float) return Float;
-- function "abs" (Right : Float) return Float;

-- function "+"   (Left, Right : Float) return Float;
-- function "-"   (Left, Right : Float) return Float;
-- function "*"   (Left, Right : Float) return Float;
-- function "/"   (Left, Right : Float) return Float;

-- function "**"  (Left : Float; Right : Integer'Base) return Float;

-- The specification of each operator for the type root_real, or for
-- any additional predefined floating point type, is obtained by
-- replacing Float by the name of the type in the specification of the
-- corresponding operator of the type Float.

-- In addition, the following operators are predefined for the root
-- numeric types:

`function` "*" (Left : root_integer; Right : root_real)
`return` root_real;

`function` "*" (Left : root_real;    Right : root_integer)
`return` root_real;

`function` "/" (Left : root_real;    Right : root_integer)
`return` root_real;

-- The type universal_fixed is predefined.
-- The only multiplying operators defined between
-- fixed point types are

`function` "*" (Left : universal_fixed; Right : universal_fixed)
`return` universal_fixed;

`function` "/" (Left : universal_fixed; Right : universal_fixed)
`return` universal_fixed;

-- The type universal_access is predefined.
-- The following equality operators are predefined:

`function` "="  (Left, Right: universal_access) `return` Boolean;
`function` "/=" (Left, Right: universal_access) `return` Boolean;

-- The declaration of type Character is based on the standard ISO 8859-1 character set.

-- There are no character literals corresponding to the positions for control characters.
-- They are indicated in italics in this definition. See 3.5.2.

`type` Character `is`
(nul,     soh,   stx,    etx,      eot,   enq,    ack,   bel,   --   0 (16#00#) ..   7 (16#07#)
bs,      ht,    lf,     vt,       ff,    cr,     so,    si,    --   8 (16#08#) ..  15 (16#0F#)

dle,     dc1,   dc2,    dc3,      dc4,   nak,    syn,   etb,   --  16 (16#10#) ..  23 (16#17#)
can,     em,    sub,    esc,      fs,    gs,     rs,    us,    --  24 (16#18#) ..  31 (16#1F#)

' ',     '!',   '"',    '#',      '\$',   '%',    '&',   ''',   --  32 (16#20#) ..  39 (16#27#)
'(',     ')',   '*',    '+',      ',',   '-',    '.',   '/',   --  40 (16#28#) ..  47 (16#2F#)

'0',     '1',   '2',    '3',      '4',   '5',    '6',   '7',   --  48 (16#30#) ..  55 (16#37#)
'8',     '9',   ':',    ';',      '<',   '=',    '>',   '?',   --  56 (16#38#) ..  63 (16#3F#)

'@',     'A',   'B',    'C',      'D',   'E',    'F',   'G',   --  64 (16#40#) ..  71 (16#47#)
'H',     'I',   'J',    'K',      'L',   'M',    'N',   'O',   --  72 (16#48#) ..  79 (16#4F#)

'P',     'Q',   'R',    'S',      'T',   'U',    'V',   'W',   --  80 (16#50#) ..  87 (16#57#)
'X',     'Y',   'Z',    '[',      '\',   ']',    '^',   '_',   --  88 (16#58#) ..  95 (16#5F#)

'`',     'a',   'b',    'c',      'd',   'e',    'f',   'g',   --  96 (16#60#) .. 103 (16#67#)
'h',     'i',   'j',    'k',      'l',   'm',    'n',   'o',   -- 104 (16#68#) .. 111 (16#6F#)

'p',     'q',   'r',    's',      't',   'u',    'v',   'w',   -- 112 (16#70#) .. 119 (16#77#)
'x',     'y',   'z',    '{',      '|',   '}',    '~',   del,   -- 120 (16#78#) .. 127 (16#7F#)

reserved_128,   reserved_129,     bph,   nbh,                  -- 128 (16#80#) .. 131 (16#83#)
reserved_132,   nel,    ssa,      esa,                         -- 132 (16#84#) .. 135 (16#87#)
hts,     htj,   vts,    pld,      plu,   ri,     ss2,   ss3,   -- 136 (16#88#) .. 143 (16#8F#)

dcs,     pu1,   pu2,    sts,      cch,   mw,     spa,   epa,   -- 144 (16#90#) .. 151 (16#97#)
sos,     reserved_153,  sci,      csi,                         -- 152 (16#98#) .. 155 (16#9B#)
st,      osc,   pm,     apc,                                   -- 156 (16#9C#) .. 159 (16#9F#)

' ',     '¡',   '¢',    '£',      '¤',   '¥',    '¦',   '§',   -- 160 (16#A0#) .. 167 (16#A7#)
'¨',     '©',   'ª',    '«',                                   -- 168 (16#A8#) .. 171 (16#AB#)
'¬',     soft_hyphen,    '®',   '¯',                           -- 172 (16#AC#) .. 175 (16#AF#)

'°',     '±',   '²',    '³',      '´',   'µ',    '¶',   '·',   -- 176 (16#B0#) .. 183 (16#B7#)
'¸',     '¹',   'º',    '»',      '¼',   '½',    '¾',   '¿',   -- 184 (16#B8#) .. 191 (16#BF#)

'À',     'Á',   'Â',    'Ã',      'Ä',   'Å',    'Æ',   'Ç',   -- 192 (16#C0#) .. 199 (16#C7#)
'È',     'É',   'Ê',    'Ë',      'Ì',   'Í',    'Î',   'Ï',   -- 200 (16#C8#) .. 207 (16#CF#)

'Ð',     'Ñ',   'Ò',    'Ó',      'Ô',   'Õ',    'Ö',   '×',   -- 208 (16#D0#) .. 215 (16#D7#)
'Ø',     'Ù',   'Ú',    'Û',      'Ü',   'Ý',    'Þ',   'ß',   -- 216 (16#D8#) .. 223 (16#DF#)

'à',     'á',   'â',    'ã',      'ä',   'å',    'æ',   'ç',   -- 224 (16#E0#) .. 231 (16#E7#)
'è',     'é',   'ê',    'ë',      'ì',   'í',    'î',   'ï',   -- 232 (16#E8#) .. 239 (16#EF#)

'ð',     'ñ',   'ò',    'ó',      'ô',   'õ',    'ö',   '÷',   -- 240 (16#F0#) .. 247 (16#F7#)
'ø',     'ù',   'ú',    'û',      'ü',   'ý',    'þ',   'ÿ',   -- 248 (16#F8#) .. 255 (16#FF#)

-- The predefined operators for the type Character are the same as for
-- any enumeration type.

-- The declaration of type Wide_Character is based on the standard ISO/IEC 10646:2011 BMP character
-- set. The first 256 positions have the same contents as type Character. See 3.5.2.

`type` Wide_Character `is` (nul, soh ... Hex_0000FFFE, Hex_0000FFFF);

-- The declaration of type Wide_Wide_Character is based on the full
-- ISO/IEC 10646:2011 character set. The first 65536 positions have the
-- same contents as type Wide_Character. See 3.5.2.

`type` Wide_Wide_Character `is` (nul, soh ... Hex_7FFFFFFE, Hex_7FFFFFFF);
`for` Wide_Wide_Character'Size `use` 32;

`package` ASCII `is` ... `end` ASCII;  -- Obsolescent; see J.5

-- Predefined string types:

`type` String `is` `array` (Positive `range` <>) `of` Character
`with` Pack;

-- The predefined operators for this type are as follows:

--     function "="  (Left, Right: String) return Boolean;
--     function "/=" (Left, Right: String) return Boolean;
--     function "<"  (Left, Right: String) return Boolean;
--     function "<=" (Left, Right: String) return Boolean;
--     function ">"  (Left, Right: String) return Boolean;
--     function ">=" (Left, Right: String) return Boolean;

--     function "&" (Left: String;    Right: String)    return String;
--     function "&" (Left: Character; Right: String)    return String;
--     function "&" (Left: String;    Right: Character) return String;
--     function "&" (Left: Character; Right: Character) return String;

`type` Wide_String `is` `array` (Positive `range` <>) `of` Wide_Character
`with` Pack;

-- The predefined operators for this type correspond to those for String.

`type` Wide_Wide_String `is` `array` (Positive `range` <>)
`of` Wide_Character
`with` Pack;

-- The predefined operators for this type correspond to those for String.

`type` Duration `is` `delta` implementation-defined `range` implementation-defined;

-- The predefined operators for the type Duration are the same as for
-- any fixed point type.

-- The predefined exceptions:

Constraint_Error: `exception`;
Program_Error   : `exception`;
Storage_Error   : `exception`;
Tasking_Error   : `exception`;

`end` Standard;
```