-- comment
with Text_IO;
pragma Elaborate (Text_IO);
use Text_IO;
procedure T_Translate_General is
   use Text_IO;
   F : Float := 0.0 + 1.0; G : Integer;
   Index,J : Integer; K : Standard.Float;
   Tab : array (1..10) of Float;
   function INTERNE return Float is --Line comment
      Float : Integer := Integer(T_Translate_General.F);
   begin
      Float := 0;
      return 2.0;   end Interne;

   package Pager is
      pragma Page;
   end Pager;

   Try : aliased Integer;
   type F_Int is new Integer;
   Z : F_Int;

   type T_Base is range 1..10;
   VBase : T_Base'Base := T_Base'Base'First;

   Ptr : access Integer := Try'Access;
begin
   -- another comment
   F:= F+1.0;
   F := "+" (Left => F, Right => Interne);

   B : for Index in 1 .. 10 loop
       if Index = B.Index then
          null;
       end if;
   end loop B;

   case Index is
      when 1 =>
         declare
            Unused : Standard.Float renames Tab (Index);
         begin
            Unused := Tab(Index);
         end;
      when others =>
         null;
   end case;

   if Index in 1 .. 10 | Index | Integer (Tab (Index)) .. Integer (Tab (Index + Index)) then
      null;
   end if;
end T_Translate_General;
with Text_IO; use Text_IO;
procedure T_Translate_Overloading is
   type A is (VV, X, Y);
   type B is (V, Y, Z);
   Va : A;
   Vb : B;

   package Pack is
      type Pack_T is range 1..10;
      procedure Prim_T (X: Pack_T);
   end Pack;

   package body Pack is
      procedure Prim_T (X : Pack_T) is
      begin
         null;
      end Prim_T;
   end Pack;
   use Pack;

   VT : Pack_T := 1;

   type D1 is new Pack_T;
   procedure Prim_D1 (X : D1) is null;
   V1 : D1 := 1;

   type D2 is new D1;
   V2 : D2 := 1;

   procedure P_Integer (X : Integer) is
   begin
      null;
   end;

   procedure P_Access (X : access Integer) is
   begin
      null;
   end;

   procedure P_Float (X : Float) is
   begin
      null;
   end P_Float;

   Index : aliased Integer;

begin
   Va := VV;
   Va := X;
   Va := Y;
   Vb := V;
   Vb := Y;
   Vb := Z;

   Prim_T(X => VT);
   Prim_D1(X => V1);
   Prim_T(X => V2);

   P_Integer (1);
   P_Float (1.0);
   P_Access (Index'Access);

end T_Translate_Overloading;
