--------------------------------
-- Ivan Levashew aka OCTAGRAM --
--              Barnaul, 2009 --
--------------------------------

package body Turbo is

   --------------------
   -- Inc, Dec, etc. --
   --------------------

   procedure Inc (Addend : in out Integer_8) is
   begin
      Addend := Addend + 1;
   end Inc;

   procedure Inc (Addend : not null access Integer_8) is
   begin
      Addend.all := Addend.all + 1;
   end;

   procedure Inc (Addend : in out Integer_8;
      Item : Integer_8) is
   begin
      Addend := Addend + Item;
   end Inc;

   procedure Inc (Addend : not null access Integer_8;
      Item : Integer_8) is
   begin
      Addend.all := Addend.all + Item;
   end Inc;

   procedure Dec (Addend : in out Integer_8) is
   begin
      Addend := Addend - 1;
   end Dec;

   procedure Dec (Addend : not null access Integer_8) is
   begin
      Addend.all := Addend.all - 1;
   end Dec;

   procedure Dec (Addend : in out Integer_8;
      Item : Integer_8) is
   begin
      Addend := Addend - Item;
   end Dec;

   procedure Dec (Addend : not null access Integer_8;
      Item : Integer_8) is
   begin
      Addend.all := Addend.all - Item;
   end Dec;

   procedure Inc (Addend : in out Unsigned_8) is
   begin
      Addend := Addend + 1;
   end Inc;

   procedure Inc (Addend : not null access Unsigned_8) is
   begin
      Addend.all := Addend.all + 1;
   end Inc;

   procedure Inc (Addend : in out Unsigned_8;
      Item : Unsigned_8) is
   begin
      Addend := Addend + Item;
   end Inc;

   procedure Inc (Addend : not null access Unsigned_8;
      Item : Unsigned_8) is
   begin
      Addend.all := Addend.all + Item;
   end Inc;

   procedure Dec (Addend : in out Unsigned_8) is
   begin
      Addend := Addend - 1;
   end Dec;

   procedure Dec (Addend : not null access Unsigned_8) is
   begin
      Addend.all := Addend.all - 1;
   end Dec;

   procedure Dec (Addend : in out Unsigned_8;
      Item : Unsigned_8) is
   begin
      Addend := Addend - Item;
   end Dec;

   procedure Dec (Addend : not null access Unsigned_8;
      Item : Unsigned_8) is
   begin
      Addend.all := Addend.all - Item;
   end Dec;

   procedure Do_And (Multipliee : in out Unsigned_8;
      Item : Unsigned_8) is
   begin
      Multipliee := Multipliee and Item;
   end Do_And;

   procedure Do_And (Multipliee : not null access Unsigned_8;
      Item : Unsigned_8) is
   begin
      Multipliee.all := Multipliee.all and Item;
   end Do_And;

   procedure Do_Or (Multipliee : in out Unsigned_8;
      Item : Unsigned_8) is
   begin
      Multipliee := Multipliee or Item;
   end Do_Or;

   procedure Do_Or (Multipliee : not null access Unsigned_8;
      Item : Unsigned_8) is
   begin
      Multipliee.all := Multipliee.all or Item;
   end Do_Or;

   procedure Do_Xor (Multipliee : in out Unsigned_8;
      Item : Unsigned_8) is
   begin
      Multipliee := Multipliee xor Item;
   end Do_Xor;

   procedure Do_Xor (Multipliee : not null access Unsigned_8;
      Item : Unsigned_8) is
   begin
      Multipliee.all := Multipliee.all xor Item;
   end Do_Xor;

   procedure Inc (Addend : in out Integer_16) is
   begin
      Addend := Addend + 1;
   end Inc;

   procedure Inc (Addend : not null access Integer_16) is
   begin
      Addend.all := Addend.all + 1;
   end;

   procedure Inc (Addend : in out Integer_16;
      Item : Integer_16) is
   begin
      Addend := Addend + Item;
   end Inc;

   procedure Inc (Addend : not null access Integer_16;
      Item : Integer_16) is
   begin
      Addend.all := Addend.all + Item;
   end Inc;

   procedure Dec (Addend : in out Integer_16) is
   begin
      Addend := Addend - 1;
   end Dec;

   procedure Dec (Addend : not null access Integer_16) is
   begin
      Addend.all := Addend.all - 1;
   end Dec;

   procedure Dec (Addend : in out Integer_16;
      Item : Integer_16) is
   begin
      Addend := Addend - Item;
   end Dec;

   procedure Dec (Addend : not null access Integer_16;
      Item : Integer_16) is
   begin
      Addend.all := Addend.all - Item;
   end Dec;

   procedure Inc (Addend : in out Unsigned_16) is
   begin
      Addend := Addend + 1;
   end Inc;

   procedure Inc (Addend : not null access Unsigned_16) is
   begin
      Addend.all := Addend.all + 1;
   end Inc;

   procedure Inc (Addend : in out Unsigned_16;
      Item : Unsigned_16) is
   begin
      Addend := Addend + Item;
   end Inc;

   procedure Inc (Addend : not null access Unsigned_16;
      Item : Unsigned_16) is
   begin
      Addend.all := Addend.all + Item;
   end Inc;

   procedure Dec (Addend : in out Unsigned_16) is
   begin
      Addend := Addend - 1;
   end Dec;

   procedure Dec (Addend : not null access Unsigned_16) is
   begin
      Addend.all := Addend.all - 1;
   end Dec;

   procedure Dec (Addend : in out Unsigned_16;
      Item : Unsigned_16) is
   begin
      Addend := Addend - Item;
   end Dec;

   procedure Dec (Addend : not null access Unsigned_16;
      Item : Unsigned_16) is
   begin
      Addend.all := Addend.all - Item;
   end Dec;

   procedure Do_And (Multipliee : in out Unsigned_16;
      Item : Unsigned_16) is
   begin
      Multipliee := Multipliee and Item;
   end Do_And;

   procedure Do_And (Multipliee : not null access Unsigned_16;
      Item : Unsigned_16) is
   begin
      Multipliee.all := Multipliee.all and Item;
   end Do_And;

   procedure Do_Or (Multipliee : in out Unsigned_16;
      Item : Unsigned_16) is
   begin
      Multipliee := Multipliee or Item;
   end Do_Or;

   procedure Do_Or (Multipliee : not null access Unsigned_16;
      Item : Unsigned_16) is
   begin
      Multipliee.all := Multipliee.all or Item;
   end Do_Or;

   procedure Do_Xor (Multipliee : in out Unsigned_16;
      Item : Unsigned_16) is
   begin
      Multipliee := Multipliee xor Item;
   end Do_Xor;

   procedure Do_Xor (Multipliee : not null access Unsigned_16;
      Item : Unsigned_16) is
   begin
      Multipliee.all := Multipliee.all xor Item;
   end Do_Xor;

   procedure Inc (Addend : in out Integer_32) is
   begin
      Addend := Addend + 1;
   end Inc;

   procedure Inc (Addend : not null access Integer_32) is
   begin
      Addend.all := Addend.all + 1;
   end;

   procedure Inc (Addend : in out Integer_32;
      Item : Integer_32) is
   begin
      Addend := Addend + Item;
   end Inc;

   procedure Inc (Addend : not null access Integer_32;
      Item : Integer_32) is
   begin
      Addend.all := Addend.all + Item;
   end Inc;

   procedure Dec (Addend : in out Integer_32) is
   begin
      Addend := Addend - 1;
   end Dec;

   procedure Dec (Addend : not null access Integer_32) is
   begin
      Addend.all := Addend.all - 1;
   end Dec;

   procedure Dec (Addend : in out Integer_32;
      Item : Integer_32) is
   begin
      Addend := Addend - Item;
   end Dec;

   procedure Dec (Addend : not null access Integer_32;
      Item : Integer_32) is
   begin
      Addend.all := Addend.all - Item;
   end Dec;

   procedure Inc (Addend : in out Unsigned_32) is
   begin
      Addend := Addend + 1;
   end Inc;

   procedure Inc (Addend : not null access Unsigned_32) is
   begin
      Addend.all := Addend.all + 1;
   end Inc;

   procedure Inc (Addend : in out Unsigned_32;
      Item : Unsigned_32) is
   begin
      Addend := Addend + Item;
   end Inc;

   procedure Inc (Addend : not null access Unsigned_32;
      Item : Unsigned_32) is
   begin
      Addend.all := Addend.all + Item;
   end Inc;

   procedure Dec (Addend : in out Unsigned_32) is
   begin
      Addend := Addend - 1;
   end Dec;

   procedure Dec (Addend : not null access Unsigned_32) is
   begin
      Addend.all := Addend.all - 1;
   end Dec;

   procedure Dec (Addend : in out Unsigned_32;
      Item : Unsigned_32) is
   begin
      Addend := Addend - Item;
   end Dec;

   procedure Dec (Addend : not null access Unsigned_32;
      Item : Unsigned_32) is
   begin
      Addend.all := Addend.all - Item;
   end Dec;

   procedure Do_And (Multipliee : in out Unsigned_32;
      Item : Unsigned_32) is
   begin
      Multipliee := Multipliee and Item;
   end Do_And;

   procedure Do_And (Multipliee : not null access Unsigned_32;
      Item : Unsigned_32) is
   begin
      Multipliee.all := Multipliee.all and Item;
   end Do_And;

   procedure Do_Or (Multipliee : in out Unsigned_32;
      Item : Unsigned_32) is
   begin
      Multipliee := Multipliee or Item;
   end Do_Or;

   procedure Do_Or (Multipliee : not null access Unsigned_32;
      Item : Unsigned_32) is
   begin
      Multipliee.all := Multipliee.all or Item;
   end Do_Or;

   procedure Do_Xor (Multipliee : in out Unsigned_32;
      Item : Unsigned_32) is
   begin
      Multipliee := Multipliee xor Item;
   end Do_Xor;

   procedure Do_Xor (Multipliee : not null access Unsigned_32;
      Item : Unsigned_32) is
   begin
      Multipliee.all := Multipliee.all xor Item;
   end Do_Xor;

   procedure Inc (Addend : in out Integer_64) is
   begin
      Addend := Addend + 1;
   end Inc;

   procedure Inc (Addend : not null access Integer_64) is
   begin
      Addend.all := Addend.all + 1;
   end;

   procedure Inc (Addend : in out Integer_64;
      Item : Integer_64) is
   begin
      Addend := Addend + Item;
   end Inc;

   procedure Inc (Addend : not null access Integer_64;
      Item : Integer_64) is
   begin
      Addend.all := Addend.all + Item;
   end Inc;

   procedure Dec (Addend : in out Integer_64) is
   begin
      Addend := Addend - 1;
   end Dec;

   procedure Dec (Addend : not null access Integer_64) is
   begin
      Addend.all := Addend.all - 1;
   end Dec;

   procedure Dec (Addend : in out Integer_64;
      Item : Integer_64) is
   begin
      Addend := Addend - Item;
   end Dec;

   procedure Dec (Addend : not null access Integer_64;
      Item : Integer_64) is
   begin
      Addend.all := Addend.all - Item;
   end Dec;

   procedure Inc (Addend : in out Unsigned_64) is
   begin
      Addend := Addend + 1;
   end Inc;

   procedure Inc (Addend : not null access Unsigned_64) is
   begin
      Addend.all := Addend.all + 1;
   end Inc;

   procedure Inc (Addend : in out Unsigned_64;
      Item : Unsigned_64) is
   begin
      Addend := Addend + Item;
   end Inc;

   procedure Inc (Addend : not null access Unsigned_64;
      Item : Unsigned_64) is
   begin
      Addend.all := Addend.all + Item;
   end Inc;

   procedure Dec (Addend : in out Unsigned_64) is
   begin
      Addend := Addend - 1;
   end Dec;

   procedure Dec (Addend : not null access Unsigned_64) is
   begin
      Addend.all := Addend.all - 1;
   end Dec;

   procedure Dec (Addend : in out Unsigned_64;
      Item : Unsigned_64) is
   begin
      Addend := Addend - Item;
   end Dec;

   procedure Dec (Addend : not null access Unsigned_64;
      Item : Unsigned_64) is
   begin
      Addend.all := Addend.all - Item;
   end Dec;

   procedure Do_And (Multipliee : in out Unsigned_64;
      Item : Unsigned_64) is
   begin
      Multipliee := Multipliee and Item;
   end Do_And;

   procedure Do_And (Multipliee : not null access Unsigned_64;
      Item : Unsigned_64) is
   begin
      Multipliee.all := Multipliee.all and Item;
   end Do_And;

   procedure Do_Or (Multipliee : in out Unsigned_64;
      Item : Unsigned_64) is
   begin
      Multipliee := Multipliee or Item;
   end Do_Or;

   procedure Do_Or (Multipliee : not null access Unsigned_64;
      Item : Unsigned_64) is
   begin
      Multipliee.all := Multipliee.all or Item;
   end Do_Or;

   procedure Do_Xor (Multipliee : in out Unsigned_64;
      Item : Unsigned_64) is
   begin
      Multipliee := Multipliee xor Item;
   end Do_Xor;

   procedure Do_Xor (Multipliee : not null access Unsigned_64;
      Item : Unsigned_64) is
   begin
      Multipliee.all := Multipliee.all xor Item;
   end Do_Xor;

   procedure Inc (Addend : in out Integer_Addr) is
   begin
      Addend := Addend + 1;
   end Inc;

   procedure Inc (Addend : not null access Integer_Addr) is
   begin
      Addend.all := Addend.all + 1;
   end;

   procedure Inc (Addend : in out Integer_Addr;
      Item : Integer_Addr) is
   begin
      Addend := Addend + Item;
   end Inc;

   procedure Inc (Addend : not null access Integer_Addr;
      Item : Integer_Addr) is
   begin
      Addend.all := Addend.all + Item;
   end Inc;

   procedure Dec (Addend : in out Integer_Addr) is
   begin
      Addend := Addend - 1;
   end Dec;

   procedure Dec (Addend : not null access Integer_Addr) is
   begin
      Addend.all := Addend.all - 1;
   end Dec;

   procedure Dec (Addend : in out Integer_Addr;
      Item : Integer_Addr) is
   begin
      Addend := Addend - Item;
   end Dec;

   procedure Dec (Addend : not null access Integer_Addr;
      Item : Integer_Addr) is
   begin
      Addend.all := Addend.all - Item;
   end Dec;

   procedure Inc (Addend : in out Unsigned_Addr) is
   begin
      Addend := Addend + 1;
   end Inc;

   procedure Inc (Addend : not null access Unsigned_Addr) is
   begin
      Addend.all := Addend.all + 1;
   end Inc;

   procedure Inc (Addend : in out Unsigned_Addr;
      Item : Unsigned_Addr) is
   begin
      Addend := Addend + Item;
   end Inc;

   procedure Inc (Addend : not null access Unsigned_Addr;
      Item : Unsigned_Addr) is
   begin
      Addend.all := Addend.all + Item;
   end Inc;

   procedure Dec (Addend : in out Unsigned_Addr) is
   begin
      Addend := Addend - 1;
   end Dec;

   procedure Dec (Addend : not null access Unsigned_Addr) is
   begin
      Addend.all := Addend.all - 1;
   end Dec;

   procedure Dec (Addend : in out Unsigned_Addr;
      Item : Unsigned_Addr) is
   begin
      Addend := Addend - Item;
   end Dec;

   procedure Dec (Addend : not null access Unsigned_Addr;
      Item : Unsigned_Addr) is
   begin
      Addend.all := Addend.all - Item;
   end Dec;

   procedure Do_And (Multipliee : in out Unsigned_Addr;
      Item : Unsigned_Addr) is
   begin
      Multipliee := Multipliee and Item;
   end Do_And;

   procedure Do_And (Multipliee : not null access Unsigned_Addr;
      Item : Unsigned_Addr) is
   begin
      Multipliee.all := Multipliee.all and Item;
   end Do_And;

   procedure Do_Or (Multipliee : in out Unsigned_Addr;
      Item : Unsigned_Addr) is
   begin
      Multipliee := Multipliee or Item;
   end Do_Or;

   procedure Do_Or (Multipliee : not null access Unsigned_Addr;
      Item : Unsigned_Addr) is
   begin
      Multipliee.all := Multipliee.all or Item;
   end Do_Or;

   procedure Do_Xor (Multipliee : in out Unsigned_Addr;
      Item : Unsigned_Addr) is
   begin
      Multipliee := Multipliee xor Item;
   end Do_Xor;

   procedure Do_Xor (Multipliee : not null access Unsigned_Addr;
      Item : Unsigned_Addr) is
   begin
      Multipliee.all := Multipliee.all xor Item;
   end Do_Xor;

   ----------------
   -- Boolean_32 --
   ----------------

   function "+" (Item : Boolean_32) return Boolean is
   begin
      return Integer_32 (Item) /= 0;
   end "+";

   function "+" (Item : Boolean_32) return Integer_32 is
   begin
      return Integer_32 (Item);
   end "+";

   function "+" (Item : Boolean) return Boolean_32 is
   begin
      return Boolean'Pos (Item);
   end "+";

   function "+" (Item : Integer_32) return Boolean_32 is
   begin
      return Boolean_32 (Item);
   end "+";

   function "=" (Left : Boolean_32; Right : Boolean) return Boolean is
   begin
      return Right = (Integer_32 (Left) /= 0);
   end "=";

   function "=" (Left : Boolean; Right : Boolean_32) return Boolean is
   begin
      return Left = (Integer_32 (Right) /= 0);
   end "=";

   function "=" (Left, Right : Boolean_32) return Boolean is
   begin
      return (Integer_32 (Left) /= 0)
           = (Integer_32 (Right) /= 0);
   end "=";

   function ">" (Left : Boolean_32; Right : Boolean) return Boolean is
   begin
      return Right < (Integer_32 (Left) /= 0);
   end ">";

   function ">" (Left : Boolean; Right : Boolean_32) return Boolean is
   begin
      return Left > (Integer_32 (Right) /= 0);
   end ">";

   function ">" (Left, Right : Boolean_32) return Boolean is
   begin
      return (Integer_32 (Left) /= 0)
           > (Integer_32 (Right) /= 0);
   end ">";

   function "<" (Left : Boolean_32; Right : Boolean) return Boolean is
   begin
      return Right > (Integer_32 (Left) /= 0);
   end "<";

   function "<" (Left : Boolean; Right : Boolean_32) return Boolean is
   begin
      return Left < (Integer_32 (Right) /= 0);
   end "<";

   function "<" (Left, Right : Boolean_32) return Boolean is
   begin
      return (Integer_32 (Left) /= 0)
           < (Integer_32 (Right) /= 0);
   end "<";

   function ">=" (Left : Boolean_32; Right : Boolean) return Boolean is
   begin
      return Right <= (Integer_32 (Left) /= 0);
   end ">=";

   function ">=" (Left : Boolean; Right : Boolean_32) return Boolean is
   begin
      return Left >= (Integer_32 (Right) /= 0);
   end ">=";

   function ">=" (Left, Right : Boolean_32) return Boolean is
   begin
      return (Integer_32 (Left) /= 0)
          >= (Integer_32 (Right) /= 0);
   end ">=";

   function "<=" (Left : Boolean_32; Right : Boolean) return Boolean is
   begin
      return Right >= (Integer_32 (Left) /= 0);
   end "<=";

   function "<=" (Left : Boolean; Right : Boolean_32) return Boolean is
   begin
      return Left <= (Integer_32 (Right) /= 0);
   end "<=";

   function "<=" (Left, Right : Boolean_32) return Boolean is
   begin
      return (Integer_32 (Left) /= 0)
          <= (Integer_32 (Right) /= 0);
   end "<=";

   function "and" (Left : Boolean_32; Right : Boolean) return Boolean is
   begin
      return Right and (Integer_32 (Left) /= 0);
   end "and";

   function "and" (Left : Boolean; Right : Boolean_32) return Boolean is
   begin
      return Left and (Integer_32 (Right) /= 0);
   end "and";

   function "and" (Left, Right : Boolean_32) return Boolean is
   begin
      return Integer_32 (Left) /= 0
         and Integer_32 (Right) /= 0;
   end "and";

   function "or" (Left : Boolean_32; Right : Boolean) return Boolean is
   begin
      return Right or (Integer_32 (Left) /= 0);
   end "or";

   function "or" (Left : Boolean; Right : Boolean_32) return Boolean is
   begin
      return Left or (Integer_32 (Right) /= 0);
   end "or";

   function "or" (Left, Right : Boolean_32) return Boolean is
   begin
      return Integer_32 (Left) /= 0
          or Integer_32 (Right) /= 0;
   end "or";

   function "xor" (Left : Boolean_32; Right : Boolean) return Boolean is
   begin
      return Right xor (Integer_32 (Left) /= 0);
   end "xor";

   function "xor" (Left : Boolean; Right : Boolean_32) return Boolean is
   begin
      return Left xor (Integer_32 (Right) /= 0);
   end "xor";

   function "xor" (Left, Right : Boolean_32) return Boolean is
   begin
      return Integer_32 (Left) /= 0
         xor Integer_32 (Right) /= 0;
   end "xor";

   function "not" (Item : Boolean_32) return Boolean is
   begin
      return Integer_32 (Item) = 0;
   end "not";

   ----------------
   -- Boolean_16 --
   ----------------

   function "+" (Item : Boolean_16) return Boolean is
   begin
      return Integer_16 (Item) /= 0;
   end "+";

   function "+" (Item : Boolean_16) return Integer_16 is
   begin
      return Integer_16 (Item);
   end "+";

   function "+" (Item : Boolean) return Boolean_16 is
   begin
      return Boolean'Pos (Item);
   end "+";

   function "+" (Item : Integer_16) return Boolean_16 is
   begin
      return Boolean_16 (Item);
   end "+";

   function "=" (Left : Boolean_16; Right : Boolean) return Boolean is
   begin
      return Right = (Integer_16 (Left) /= 0);
   end "=";

   function "=" (Left : Boolean; Right : Boolean_16) return Boolean is
   begin
      return Left = (Integer_16 (Right) /= 0);
   end "=";

   function "=" (Left, Right : Boolean_16) return Boolean is
   begin
      return (Integer_16 (Left) /= 0)
           = (Integer_16 (Right) /= 0);
   end "=";

   function ">" (Left : Boolean_16; Right : Boolean) return Boolean is
   begin
      return Right < (Integer_16 (Left) /= 0);
   end ">";

   function ">" (Left : Boolean; Right : Boolean_16) return Boolean is
   begin
      return Left > (Integer_16 (Right) /= 0);
   end ">";

   function ">" (Left, Right : Boolean_16) return Boolean is
   begin
      return (Integer_16 (Left) /= 0)
           > (Integer_16 (Right) /= 0);
   end ">";

   function "<" (Left : Boolean_16; Right : Boolean) return Boolean is
   begin
      return Right > (Integer_16 (Left) /= 0);
   end "<";

   function "<" (Left : Boolean; Right : Boolean_16) return Boolean is
   begin
      return Left < (Integer_16 (Right) /= 0);
   end "<";

   function "<" (Left, Right : Boolean_16) return Boolean is
   begin
      return (Integer_16 (Left) /= 0)
           < (Integer_16 (Right) /= 0);
   end "<";

   function ">=" (Left : Boolean_16; Right : Boolean) return Boolean is
   begin
      return Right <= (Integer_16 (Left) /= 0);
   end ">=";

   function ">=" (Left : Boolean; Right : Boolean_16) return Boolean is
   begin
      return Left >= (Integer_16 (Right) /= 0);
   end ">=";

   function ">=" (Left, Right : Boolean_16) return Boolean is
   begin
      return (Integer_16 (Left) /= 0)
          >= (Integer_16 (Right) /= 0);
   end ">=";

   function "<=" (Left : Boolean_16; Right : Boolean) return Boolean is
   begin
      return Right >= (Integer_16 (Left) /= 0);
   end "<=";

   function "<=" (Left : Boolean; Right : Boolean_16) return Boolean is
   begin
      return Left <= (Integer_16 (Right) /= 0);
   end "<=";

   function "<=" (Left, Right : Boolean_16) return Boolean is
   begin
      return (Integer_16 (Left) /= 0)
          <= (Integer_16 (Right) /= 0);
   end "<=";

   function "and" (Left : Boolean_16; Right : Boolean) return Boolean is
   begin
      return Right and (Integer_16 (Left) /= 0);
   end "and";

   function "and" (Left : Boolean; Right : Boolean_16) return Boolean is
   begin
      return Left and (Integer_16 (Right) /= 0);
   end "and";

   function "and" (Left, Right : Boolean_16) return Boolean is
   begin
      return Integer_16 (Left) /= 0
         and Integer_16 (Right) /= 0;
   end "and";

   function "or" (Left : Boolean_16; Right : Boolean) return Boolean is
   begin
      return Right or (Integer_16 (Left) /= 0);
   end "or";

   function "or" (Left : Boolean; Right : Boolean_16) return Boolean is
   begin
      return Left or (Integer_16 (Right) /= 0);
   end "or";

   function "or" (Left, Right : Boolean_16) return Boolean is
   begin
      return Integer_16 (Left) /= 0
          or Integer_16 (Right) /= 0;
   end "or";

   function "xor" (Left : Boolean_16; Right : Boolean) return Boolean is
   begin
      return Right xor (Integer_16 (Left) /= 0);
   end "xor";

   function "xor" (Left : Boolean; Right : Boolean_16) return Boolean is
   begin
      return Left xor (Integer_16 (Right) /= 0);
   end "xor";

   function "xor" (Left, Right : Boolean_16) return Boolean is
   begin
      return Integer_16 (Left) /= 0
         xor Integer_16 (Right) /= 0;
   end "xor";

   function "not" (Item : Boolean_16) return Boolean is
   begin
      return Integer_16 (Item) = 0;
   end "not";

   ---------------
   -- Boolean_8 --
   ---------------

   function "+" (Item : Boolean_8) return Boolean is
   begin
      return Integer_8 (Item) /= 0;
   end "+";

   function "+" (Item : Boolean_8) return Integer_8 is
   begin
      return Integer_8 (Item);
   end "+";

   function "+" (Item : Boolean) return Boolean_8 is
   begin
      return Boolean'Pos (Item);
   end "+";

   function "+" (Item : Integer_8) return Boolean_8 is
   begin
      return Boolean_8 (Item);
   end "+";

   function "=" (Left : Boolean_8; Right : Boolean) return Boolean is
   begin
      return Right = (Integer_8 (Left) /= 0);
   end "=";

   function "=" (Left : Boolean; Right : Boolean_8) return Boolean is
   begin
      return Left = (Integer_8 (Right) /= 0);
   end "=";

   function "=" (Left, Right : Boolean_8) return Boolean is
   begin
      return (Integer_8 (Left) /= 0)
           = (Integer_8 (Right) /= 0);
   end "=";

   function ">" (Left : Boolean_8; Right : Boolean) return Boolean is
   begin
      return Right < (Integer_8 (Left) /= 0);
   end ">";

   function ">" (Left : Boolean; Right : Boolean_8) return Boolean is
   begin
      return Left > (Integer_8 (Right) /= 0);
   end ">";

   function ">" (Left, Right : Boolean_8) return Boolean is
   begin
      return (Integer_8 (Left) /= 0)
           > (Integer_8 (Right) /= 0);
   end ">";

   function "<" (Left : Boolean_8; Right : Boolean) return Boolean is
   begin
      return Right > (Integer_8 (Left) /= 0);
   end "<";

   function "<" (Left : Boolean; Right : Boolean_8) return Boolean is
   begin
      return Left < (Integer_8 (Right) /= 0);
   end "<";

   function "<" (Left, Right : Boolean_8) return Boolean is
   begin
      return (Integer_8 (Left) /= 0)
           < (Integer_8 (Right) /= 0);
   end "<";

   function ">=" (Left : Boolean_8; Right : Boolean) return Boolean is
   begin
      return Right <= (Integer_8 (Left) /= 0);
   end ">=";

   function ">=" (Left : Boolean; Right : Boolean_8) return Boolean is
   begin
      return Left >= (Integer_8 (Right) /= 0);
   end ">=";

   function ">=" (Left, Right : Boolean_8) return Boolean is
   begin
      return (Integer_8 (Left) /= 0)
          >= (Integer_8 (Right) /= 0);
   end ">=";

   function "<=" (Left : Boolean_8; Right : Boolean) return Boolean is
   begin
      return Right >= (Integer_8 (Left) /= 0);
   end "<=";

   function "<=" (Left : Boolean; Right : Boolean_8) return Boolean is
   begin
      return Left <= (Integer_8 (Right) /= 0);
   end "<=";

   function "<=" (Left, Right : Boolean_8) return Boolean is
   begin
      return (Integer_8 (Left) /= 0)
          <= (Integer_8 (Right) /= 0);
   end "<=";

   function "and" (Left : Boolean_8; Right : Boolean) return Boolean is
   begin
      return Right and (Integer_8 (Left) /= 0);
   end "and";

   function "and" (Left : Boolean; Right : Boolean_8) return Boolean is
   begin
      return Left and (Integer_8 (Right) /= 0);
   end "and";

   function "and" (Left, Right : Boolean_8) return Boolean is
   begin
      return Integer_8 (Left) /= 0
         and Integer_8 (Right) /= 0;
   end "and";

   function "or" (Left : Boolean_8; Right : Boolean) return Boolean is
   begin
      return Right or (Integer_8 (Left) /= 0);
   end "or";

   function "or" (Left : Boolean; Right : Boolean_8) return Boolean is
   begin
      return Left or (Integer_8 (Right) /= 0);
   end "or";

   function "or" (Left, Right : Boolean_8) return Boolean is
   begin
      return Integer_8 (Left) /= 0
          or Integer_8 (Right) /= 0;
   end "or";

   function "xor" (Left : Boolean_8; Right : Boolean) return Boolean is
   begin
      return Right xor (Integer_8 (Left) /= 0);
   end "xor";

   function "xor" (Left : Boolean; Right : Boolean_8) return Boolean is
   begin
      return Left xor (Integer_8 (Right) /= 0);
   end "xor";

   function "xor" (Left, Right : Boolean_8) return Boolean is
   begin
      return Integer_8 (Left) /= 0
         xor Integer_8 (Right) /= 0;
   end "xor";

   function "not" (Item : Boolean_8) return Boolean is
   begin
      return Integer_8 (Item) = 0;
   end "not";

end Turbo;
