libyaml in x86_64-linux-gnu

c-alloca.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.stddef;
package C.alloca is
   pragma Preelaborate;
   function alloca (size : stddef.size_t) return void_ptr;
   pragma Import (C, alloca, "alloca");
   ALLOCA_H : constant := 1;
end C.alloca;

c-bits-byteswap.adb

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package body C.bits.byteswap is
   function bswap_32 (bsx : unsigned_int) return unsigned_int is
   begin
      return builtin_bswap32 (bsx);
   end bswap_32;
   function bswap_64 (bsx : types.uint64_t) return types.uint64_t is
   begin
      return types.uint64_t (builtin_bswap64 (unsigned_long_long (bsx)));
   end bswap_64;
end C.bits.byteswap;

c-bits-byteswap.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.bits.types;
package C.bits.byteswap is
   pragma Preelaborate;
   function bswap_32 (bsx : unsigned_int) return unsigned_int;
   pragma Convention (C, bswap_32);
   pragma Inline (bswap_32);
   function bswap_64 (bsx : types.uint64_t) return types.uint64_t;
   pragma Convention (C, bswap_64);
   pragma Inline (bswap_64);
   BITS_BYTESWAP_H : constant := 1;
   --  __bswap_constant_16 (function macro)
   --  __bswap_constant_32 (function macro)
   --  __bswap_constant_64 (function macro)
end C.bits.byteswap;

c-bits-byteswap_16.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.bits.byteswap_16 is
   pragma Preelaborate;
   --  __bswap_16 (function macro)
end C.bits.byteswap_16;

c-bits-endian.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.bits.endian is
   pragma Preelaborate;
   BYTE_ORDER : constant := 1234;
end C.bits.endian;

c-bits-pthreadtypes.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.bits.pthreadtypes is
   pragma Preelaborate;
   subtype pthread_t is unsigned_long;
   type union_pthread_attr_t;
   type union_pthread_attr_t (Unchecked_Tag : unsigned_int := 0) is record
      case Unchecked_Tag is
         when 0 =>
            size : char_array (0 .. 55);
         when others =>
            align : signed_long;
      end case;
   end record;
   pragma Unchecked_Union (union_pthread_attr_t);
   pragma Convention (C_Pass_By_Copy, union_pthread_attr_t);
   subtype pthread_attr_t is union_pthread_attr_t;
   type struct_pthread_internal_list;
   type struct_pthread_internal_list_ptr is
      access all struct_pthread_internal_list;
   for struct_pthread_internal_list_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_pthread_internal_list_ptr);
   pragma Convention (C, struct_pthread_internal_list_ptr);
   type struct_pthread_internal_list is record
      prev : aliased struct_pthread_internal_list_ptr;
      next : aliased struct_pthread_internal_list_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_pthread_internal_list);
   subtype pthread_list_t is struct_pthread_internal_list;
   type struct_pthread_mutex_s;
   type struct_pthread_mutex_s is record
      lock : aliased signed_int;
      count : aliased unsigned_int;
      owner : aliased signed_int;
      nusers : aliased unsigned_int;
      kind : aliased signed_int;
      spins : aliased signed_short;
      elision : aliased signed_short;
      list : aliased pthread_list_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_pthread_mutex_s);
   type union_d6251af3 (Unchecked_Tag : unsigned_int := 0) is record
      case Unchecked_Tag is
         when 0 =>
            data : struct_pthread_mutex_s;
         when 1 =>
            size : char_array (0 .. 39);
         when others =>
            align : signed_long;
      end case;
   end record;
   pragma Unchecked_Union (union_d6251af3);
   pragma Convention (C_Pass_By_Copy, union_d6251af3);
   subtype pthread_mutex_t is union_d6251af3;
   type union_43f49c0e (Unchecked_Tag : unsigned_int := 0) is record
      case Unchecked_Tag is
         when 0 =>
            size : char_array (0 .. 3);
         when others =>
            align : signed_int;
      end case;
   end record;
   pragma Unchecked_Union (union_43f49c0e);
   pragma Convention (C_Pass_By_Copy, union_43f49c0e);
   subtype pthread_mutexattr_t is union_43f49c0e;
   type struct_d1b5ad24 is record
      lock : aliased signed_int;
      futex : aliased unsigned_int;
      total_seq : aliased unsigned_long_long;
      wakeup_seq : aliased unsigned_long_long;
      woken_seq : aliased unsigned_long_long;
      mutex : aliased void_ptr;
      nwaiters : aliased unsigned_int;
      broadcast_seq : aliased unsigned_int;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_d1b5ad24);
   type union_5ebf2c7c (Unchecked_Tag : unsigned_int := 0) is record
      case Unchecked_Tag is
         when 0 =>
            data : struct_d1b5ad24;
         when 1 =>
            size : char_array (0 .. 47);
         when others =>
            align : signed_long_long;
      end case;
   end record;
   pragma Unchecked_Union (union_5ebf2c7c);
   pragma Convention (C_Pass_By_Copy, union_5ebf2c7c);
   subtype pthread_cond_t is union_5ebf2c7c;
   type union_cbbe6c38 (Unchecked_Tag : unsigned_int := 0) is record
      case Unchecked_Tag is
         when 0 =>
            size : char_array (0 .. 3);
         when others =>
            align : signed_int;
      end case;
   end record;
   pragma Unchecked_Union (union_cbbe6c38);
   pragma Convention (C_Pass_By_Copy, union_cbbe6c38);
   subtype pthread_condattr_t is union_cbbe6c38;
   subtype pthread_key_t is unsigned_int;
   subtype pthread_once_t is signed_int;
   type struct_10e47c77 is record
      lock : aliased signed_int;
      nr_readers : aliased unsigned_int;
      readers_wakeup : aliased unsigned_int;
      writer_wakeup : aliased unsigned_int;
      nr_readers_queued : aliased unsigned_int;
      nr_writers_queued : aliased unsigned_int;
      writer : aliased signed_int;
      shared : aliased signed_int;
      rwelision : aliased signed_char;
      pad1 : aliased unsigned_char_array (0 .. 6);
      pad2 : aliased unsigned_long;
      flags : aliased unsigned_int;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_10e47c77);
   type union_8ca156a2 (Unchecked_Tag : unsigned_int := 0) is record
      case Unchecked_Tag is
         when 0 =>
            data : struct_10e47c77;
         when 1 =>
            size : char_array (0 .. 55);
         when others =>
            align : signed_long;
      end case;
   end record;
   pragma Unchecked_Union (union_8ca156a2);
   pragma Convention (C_Pass_By_Copy, union_8ca156a2);
   subtype pthread_rwlock_t is union_8ca156a2;
   type union_bb6f579a (Unchecked_Tag : unsigned_int := 0) is record
      case Unchecked_Tag is
         when 0 =>
            size : char_array (0 .. 7);
         when others =>
            align : signed_long;
      end case;
   end record;
   pragma Unchecked_Union (union_bb6f579a);
   pragma Convention (C_Pass_By_Copy, union_bb6f579a);
   subtype pthread_rwlockattr_t is union_bb6f579a;
   subtype pthread_spinlock_t is signed_int_volatile;
   type union_f4be611a (Unchecked_Tag : unsigned_int := 0) is record
      case Unchecked_Tag is
         when 0 =>
            size : char_array (0 .. 31);
         when others =>
            align : signed_long;
      end case;
   end record;
   pragma Unchecked_Union (union_f4be611a);
   pragma Convention (C_Pass_By_Copy, union_f4be611a);
   subtype pthread_barrier_t is union_f4be611a;
   type union_770e9778 (Unchecked_Tag : unsigned_int := 0) is record
      case Unchecked_Tag is
         when 0 =>
            size : char_array (0 .. 3);
         when others =>
            align : signed_int;
      end case;
   end record;
   pragma Unchecked_Union (union_770e9778);
   pragma Convention (C_Pass_By_Copy, union_770e9778);
   subtype pthread_barrierattr_t is union_770e9778;
   BITS_PTHREADTYPES_H : constant := 1;
   PTHREAD_MUTEX_HAVE_PREV : constant := 1;
   --  __PTHREAD_RWLOCK_ELISION_EXTRA (unparsible)
   PTHREAD_RWLOCK_INT_FLAGS_SHARED : constant := 1;
   --  __PTHREAD_SPINS (unparsible)
   SIZEOF_PTHREAD_ATTR_T : constant := 56;
   SIZEOF_PTHREAD_BARRIERATTR_T : constant := 4;
   SIZEOF_PTHREAD_BARRIER_T : constant := 32;
   SIZEOF_PTHREAD_CONDATTR_T : constant := 4;
   SIZEOF_PTHREAD_COND_T : constant := 48;
   SIZEOF_PTHREAD_MUTEXATTR_T : constant := 4;
   SIZEOF_PTHREAD_MUTEX_T : constant := 40;
   SIZEOF_PTHREAD_RWLOCKATTR_T : constant := 8;
   SIZEOF_PTHREAD_RWLOCK_T : constant := 56;
   have_pthread_attr_t : constant := 1;
end C.bits.pthreadtypes;

c-bits-select_h.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.bits.select_h is
   pragma Preelaborate;
   --  __FD_CLR (uninterpretable)
   --  __FD_ISSET (uninterpretable)
   --  __FD_SET (uninterpretable)
   --  __FD_ZERO (uninterpretable)
   FD_ZERO_STOS : constant char_array (0 .. 5) := "stosq" & char'Val (0);
end C.bits.select_h;

c-bits-sigset.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.bits.sigset is
   pragma Preelaborate;
   subtype sig_atomic_t is signed_int;
   type struct_22570f8b is record
      val : aliased unsigned_long_array (0 .. 15);
   end record;
   pragma Convention (C_Pass_By_Copy, struct_22570f8b);
   type struct_22570f8b_const_ptr is access constant struct_22570f8b;
   for struct_22570f8b_const_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_22570f8b_const_ptr);
   pragma Convention (C, struct_22570f8b_const_ptr);
   subtype sigset_t is struct_22570f8b;
   subtype sigset_t_const_ptr is struct_22570f8b_const_ptr;
   SIGSET_H_types : constant := 1;
   SIGSET_NWORDS : constant := 16;
end C.bits.sigset;

c-bits-stdio_lim.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.bits.stdio_lim is
   pragma Preelaborate;
   FILENAME_MAX : constant := 4096;
   FOPEN_MAX : constant := 16;
   L_ctermid : constant := 9;
   L_tmpnam : constant := 20;
   TMP_MAX : constant := 238328;
end C.bits.stdio_lim;

c-bits-sys_errlist.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.bits.sys_errlist is
   pragma Preelaborate;
   sys_nerr : aliased signed_int;
   pragma Import (C, sys_nerr, "sys_nerr");
   sys_errlist : aliased char_const_ptr_array (0 .. 0);
   pragma Import (C, sys_errlist, "sys_errlist");
end C.bits.sys_errlist;

c-bits-time.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.bits.types;
package C.bits.time is
   pragma Preelaborate;
   type struct_timeval;
   type struct_timeval is record
      tv_sec : aliased types.qqtime_t;
      tv_usec : aliased types.suseconds_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_timeval);
   type struct_timeval_ptr is access all struct_timeval;
   for struct_timeval_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_timeval_ptr);
   pragma Convention (C, struct_timeval_ptr);
   qSTRUCT_TIMEVAL : constant := 1;
end C.bits.time;

c-bits-types.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.bits.types is
   pragma Preelaborate;
   subtype u_char is unsigned_char;
   subtype u_short is unsigned_short;
   subtype u_int is unsigned_int;
   subtype u_long is unsigned_long;
   subtype int8_t is signed_char;
   subtype uint8_t is unsigned_char;
   subtype int16_t is signed_short;
   subtype uint16_t is unsigned_short;
   subtype int32_t is signed_int;
   subtype uint32_t is unsigned_int;
   subtype int64_t is signed_long;
   subtype uint64_t is unsigned_long;
   subtype quad_t is signed_long;
   subtype quad_t_ptr is signed_long_ptr;
   subtype u_quad_t is unsigned_long;
   subtype dev_t is unsigned_long;
   subtype uid_t is unsigned_int;
   subtype gid_t is unsigned_int;
   subtype ino_t is unsigned_long;
   subtype ino64_t is unsigned_long;
   subtype mode_t is unsigned_int;
   subtype nlink_t is unsigned_long;
   subtype off_t is signed_long;
   subtype off64_t is signed_long;
   subtype off64_t_ptr is signed_long_ptr;
   subtype pid_t is signed_int;
   type struct_f3d82047 is record
      val : aliased signed_int_array (0 .. 1);
   end record;
   pragma Convention (C_Pass_By_Copy, struct_f3d82047);
   subtype fsid_t is struct_f3d82047;
   subtype qqclock_t is signed_long;
   subtype rlim_t is unsigned_long;
   subtype rlim64_t is unsigned_long;
   subtype id_t is unsigned_int;
   subtype qqtime_t is signed_long;
   subtype useconds_t is unsigned_int;
   subtype suseconds_t is signed_long;
   subtype daddr_t is signed_int;
   subtype key_t is signed_int;
   subtype qqclockid_t is signed_int;
   subtype qqtimer_t is void_ptr;
   subtype blksize_t is signed_long;
   subtype blkcnt_t is signed_long;
   subtype blkcnt64_t is signed_long;
   subtype fsblkcnt_t is unsigned_long;
   subtype fsblkcnt64_t is unsigned_long;
   subtype fsfilcnt_t is unsigned_long;
   subtype fsfilcnt64_t is unsigned_long;
   subtype fsword_t is signed_long;
   subtype ssize_t is signed_long;
   subtype syscall_slong_t is signed_long;
   subtype syscall_ulong_t is unsigned_long;
   subtype loff_t is off64_t;
   subtype qaddr_t is quad_t_ptr;
   subtype caddr_t is char_ptr;
   subtype intptr_t is signed_long;
   subtype socklen_t is unsigned_int;
   BITS_TYPES_H : constant := 1;
   subtype S16_TYPE is signed_short;
   subtype S32_TYPE is signed_int;
   subtype S64_TYPE is signed_long;
   subtype SLONG32_TYPE is signed_int;
   subtype SLONGWORD_TYPE is signed_long;
   subtype SQUAD_TYPE is signed_long;
   subtype SWORD_TYPE is signed_long;
   subtype U16_TYPE is unsigned_short;
   subtype U32_TYPE is unsigned_int;
   subtype U64_TYPE is unsigned_long;
   subtype ULONG32_TYPE is unsigned_int;
   subtype ULONGWORD_TYPE is unsigned_long;
   subtype UQUAD_TYPE is unsigned_long;
   subtype UWORD_TYPE is unsigned_long;
end C.bits.types;

c-bits-typesizes.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.bits.typesizes is
   pragma Preelaborate;
   BITS_TYPESIZES_H : constant := 1;
   subtype BLKCNT64_T_TYPE is signed_long;
   subtype BLKCNT_T_TYPE is signed_long;
   subtype BLKSIZE_T_TYPE is signed_long;
   subtype CLOCKID_T_TYPE is signed_int;
   subtype CLOCK_T_TYPE is signed_long;
   subtype CPU_MASK_TYPE is unsigned_long;
   subtype DADDR_T_TYPE is signed_int;
   subtype DEV_T_TYPE is unsigned_long;
   FD_SETSIZE : constant := 1024;
   subtype FSBLKCNT64_T_TYPE is unsigned_long;
   subtype FSBLKCNT_T_TYPE is unsigned_long;
   subtype FSFILCNT64_T_TYPE is unsigned_long;
   subtype FSFILCNT_T_TYPE is unsigned_long;
   type struct_ad766d7a is record
      val : aliased signed_int_array (0 .. 1);
   end record;
   pragma Convention (C_Pass_By_Copy, struct_ad766d7a);
   subtype FSID_T_TYPE is struct_ad766d7a;
   subtype FSWORD_T_TYPE is signed_long;
   subtype GID_T_TYPE is unsigned_int;
   subtype ID_T_TYPE is unsigned_int;
   subtype INO64_T_TYPE is unsigned_long;
   INO_T_MATCHES_INO64_T : constant := 1;
   subtype INO_T_TYPE is unsigned_long;
   subtype KEY_T_TYPE is signed_int;
   subtype MODE_T_TYPE is unsigned_int;
   subtype NLINK_T_TYPE is unsigned_long;
   subtype OFF64_T_TYPE is signed_long;
   OFF_T_MATCHES_OFF64_T : constant := 1;
   subtype OFF_T_TYPE is signed_long;
   subtype PID_T_TYPE is signed_int;
   subtype RLIM64_T_TYPE is unsigned_long;
   subtype RLIM_T_TYPE is unsigned_long;
   subtype SSIZE_T_TYPE is signed_long;
   subtype SUSECONDS_T_TYPE is signed_long;
   subtype SYSCALL_SLONG_TYPE is signed_long;
   subtype SYSCALL_ULONG_TYPE is unsigned_long;
   --  __TIMER_T_TYPE (unparsible)
   subtype TIME_T_TYPE is signed_long;
   subtype UID_T_TYPE is unsigned_int;
   subtype USECONDS_T_TYPE is unsigned_int;
end C.bits.typesizes;

c-bits-waitflags.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.bits.waitflags is
   pragma Preelaborate;
   type enum_fc8537be is (P_ALL, P_PID, P_PGID);
   for enum_fc8537be use (P_ALL => 0, P_PID => 1, P_PGID => 2);
   pragma Convention (C, enum_fc8537be);
   subtype idtype_t is enum_fc8537be;
   WCONTINUED : constant := 8;
   WEXITED : constant := 4;
   WNOHANG : constant := 1;
   WNOWAIT : constant := 16777216;
   WSTOPPED : constant := 2;
   WUNTRACED : constant := 2;
   ENUM_IDTYPE_T : constant := 1;
   WALL : constant := 1073741824;
   WCLONE : constant := -2147483648;
   WNOTHREAD : constant := 536870912;
end C.bits.waitflags;

c-bits-waitstatus.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.bits.waitstatus is
   pragma Preelaborate;
   --  __WCOREDUMP (function macro)
   WCOREFLAG : constant := 128;
   --  __WEXITSTATUS (function macro)
   --  __WIFCONTINUED (function macro)
   --  __WIFEXITED (function macro)
   --  __WIFSIGNALED (function macro)
   --  __WIFSTOPPED (function macro)
   --  __WSTOPSIG (function macro)
   --  __WTERMSIG (function macro)
   W_CONTINUED : constant := 65535;
   --  __W_EXITCODE (function macro)
   --  __W_STOPCODE (function macro)
end C.bits.waitstatus;

c-bits-wordsize.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.bits.wordsize is
   pragma Preelaborate;
   SYSCALL_WORDSIZE : constant := 64;
   WORDSIZE : constant := 64;
   WORDSIZE_TIME64_COMPAT32 : constant := 1;
end C.bits.wordsize;

c-bits.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.bits is
   pragma Preelaborate;
end C.bits;

c-endian.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.endian is
   pragma Preelaborate;
   BIG_ENDIAN : constant := 4321;
   BYTE_ORDER : constant := 1234;
   LITTLE_ENDIAN : constant := 1234;
   PDP_ENDIAN : constant := 3412;
   ENDIAN_H : constant := 1;
   qqBIG_ENDIAN : constant := 4321;
   FLOAT_WORD_ORDER : constant := 1234;
   qqLITTLE_ENDIAN : constant := 1234;
   --  __LONG_LONG_PAIR (function macro)
   qqPDP_ENDIAN : constant := 3412;
   --  be16toh (function macro)
   --  be32toh (function macro)
   --  be64toh (function macro)
   --  htobe16 (function macro)
   --  htobe32 (function macro)
   --  htobe64 (function macro)
   --  htole16 (function macro)
   --  htole32 (function macro)
   --  htole64 (function macro)
   --  le16toh (function macro)
   --  le32toh (function macro)
   --  le64toh (function macro)
end C.endian;

c-features.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.features is
   pragma Preelaborate;
   ATFILE_SOURCE : constant := 1;
   DEFAULT_SOURCE : constant := 1;
   FEATURES_H : constant := 1;
   POSIX_C_SOURCE : constant := 200809;
   POSIX_SOURCE : constant := 1;
   qqGLIBC_MINORqq : constant := 24;
   --  __GLIBC_PREREQ (function macro)
   qqGLIBCqq : constant := 2;
   --  __GNUC_PREREQ (function macro)
   qqGNU_LIBRARYqq : constant := 6;
   --  __KERNEL_STRICT_NAMES (empty)
   USE_ATFILE : constant := 1;
   USE_FORTIFY_LEVEL : constant := 0;
   USE_ISOC95 : constant := 1;
   USE_ISOC99 : constant := 1;
   USE_MISC : constant := 1;
   USE_POSIX : constant := 1;
   USE_POSIX199309 : constant := 1;
   USE_POSIX199506 : constant := 1;
   USE_POSIX2 : constant := 1;
   USE_POSIX_IMPLICITLY : constant := 1;
   USE_XOPEN2K : constant := 1;
   USE_XOPEN2K8 : constant := 1;
end C.features;

c-gnu-stubs_64.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.gnu.stubs_64 is
   pragma Preelaborate;
   --  __stub___compat_bdflush (empty)
   --  __stub_chflags (empty)
   --  __stub_fattach (empty)
   --  __stub_fchflags (empty)
   --  __stub_fdetach (empty)
   --  __stub_getmsg (empty)
   --  __stub_gtty (empty)
   --  __stub_lchmod (empty)
   --  __stub_putmsg (empty)
   --  __stub_revoke (empty)
   --  __stub_setlogin (empty)
   --  __stub_sigreturn (empty)
   --  __stub_sstk (empty)
   --  __stub_stty (empty)
end C.gnu.stubs_64;

c-gnu.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.gnu is
   pragma Preelaborate;
end C.gnu;

c-libio.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.bits.types;
with C.qG_config;
with C.stdarg;
with C.stddef;
package C.libio is
   pragma Preelaborate;
   type struct_IO_jump_t (<>) is limited private;
   type struct_IO_FILE;
   type struct_IO_FILE_ptr is access all struct_IO_FILE;
   for struct_IO_FILE_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_IO_FILE_ptr);
   pragma Convention (C, struct_IO_FILE_ptr);
   --  subtype _IO_lock_t is void (typedef)
   subtype IO_lock_t_ptr is void_ptr;
   type struct_IO_marker;
   type struct_IO_marker_ptr is access all struct_IO_marker;
   for struct_IO_marker_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_IO_marker_ptr);
   pragma Convention (C, struct_IO_marker_ptr);
   type struct_IO_marker is record
      next : aliased struct_IO_marker_ptr;
      sbuf : aliased struct_IO_FILE_ptr;
      pos : aliased signed_int;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_IO_marker);
   type enum_codecvt_result;
   type enum_codecvt_result is (codecvt_ok, codecvt_partial, codecvt_error,
      codecvt_noconv);
   for enum_codecvt_result use (codecvt_ok => 0, codecvt_partial => 1,
      codecvt_error => 2, codecvt_noconv => 3);
   pragma Convention (C, enum_codecvt_result);
   type struct_IO_FILE is record
      flags : aliased signed_int;
      IO_read_ptr : aliased char_ptr;
      IO_read_end : aliased char_ptr;
      IO_read_base : aliased char_ptr;
      IO_write_base : aliased char_ptr;
      IO_write_ptr : aliased char_ptr;
      IO_write_end : aliased char_ptr;
      IO_buf_base : aliased char_ptr;
      IO_buf_end : aliased char_ptr;
      IO_save_base : aliased char_ptr;
      IO_backup_base : aliased char_ptr;
      IO_save_end : aliased char_ptr;
      markers : aliased struct_IO_marker_ptr;
      chain : aliased struct_IO_FILE_ptr;
      fileno : aliased signed_int;
      flags2 : aliased signed_int;
      old_offset : aliased bits.types.off_t;
      cur_column : aliased unsigned_short;
      vtable_offset : aliased signed_char;
      shortbuf : aliased char_array (0 .. 0);
      lock : aliased IO_lock_t_ptr;
      offset : aliased bits.types.off64_t;
      pad1 : aliased void_ptr;
      pad2 : aliased void_ptr;
      pad3 : aliased void_ptr;
      pad4 : aliased void_ptr;
      pad5 : aliased stddef.size_t;
      mode : aliased signed_int;
      unused2 : aliased char_array (0 .. 19);
   end record;
   pragma Convention (C_Pass_By_Copy, struct_IO_FILE);
   subtype IO_FILE is struct_IO_FILE;
   subtype IO_FILE_ptr is struct_IO_FILE_ptr;
   type struct_IO_FILE_plus (<>) is limited private;
   --  extern _IO_2_1_stdin_ (opaque type)
   --  extern _IO_2_1_stdout_ (opaque type)
   --  extern _IO_2_1_stderr_ (opaque type)
   --  subtype __io_read_fn is ... (function type)
   --  subtype __io_write_fn is ... (function type)
   --  subtype __io_seek_fn is ... (function type)
   --  subtype __io_close_fn is ... (function type)
   function underflow (a1 : access IO_FILE) return signed_int;
   pragma Import (C, underflow, "__underflow");
   function uflow (a1 : access IO_FILE) return signed_int;
   pragma Import (C, uflow, "__uflow");
   function overflow (a1 : access IO_FILE; a2 : signed_int)
      return signed_int;
   pragma Import (C, overflow, "__overflow");
   function IO_getc (fp : access IO_FILE) return signed_int;
   pragma Import (C, IO_getc, "_IO_getc");
   function IO_putc (c : signed_int; fp : access IO_FILE) return signed_int;
   pragma Import (C, IO_putc, "_IO_putc");
   function IO_feof (fp : access IO_FILE) return signed_int;
   pragma Import (C, IO_feof, "_IO_feof");
   function IO_ferror (fp : access IO_FILE) return signed_int;
   pragma Import (C, IO_ferror, "_IO_ferror");
   function IO_peekc_locked (fp : access IO_FILE) return signed_int;
   pragma Import (C, IO_peekc_locked, "_IO_peekc_locked");
   procedure qIO_flockfile (a1 : access IO_FILE);
   pragma Import (C, qIO_flockfile, "_IO_flockfile");
   procedure qIO_funlockfile (a1 : access IO_FILE);
   pragma Import (C, qIO_funlockfile, "_IO_funlockfile");
   function qIO_ftrylockfile (a1 : access IO_FILE) return signed_int;
   pragma Import (C, qIO_ftrylockfile, "_IO_ftrylockfile");
   function IO_vfscanf (a1 : access IO_FILE; a2 : access constant char;
      a3 : stdarg.qqgnuc_va_list; a4 : access signed_int) return signed_int;
   pragma Import (C, IO_vfscanf, "_IO_vfscanf");
   function IO_vfprintf (a1 : access IO_FILE; a2 : access constant char;
      a3 : stdarg.qqgnuc_va_list) return signed_int;
   pragma Import (C, IO_vfprintf, "_IO_vfprintf");
   function IO_padn (a1 : access IO_FILE; a2 : signed_int;
      a3 : bits.types.ssize_t) return bits.types.ssize_t;
   pragma Import (C, IO_padn, "_IO_padn");
   function IO_sgetn (a1 : access IO_FILE; a2 : void_ptr; a3 : stddef.size_t)
      return stddef.size_t;
   pragma Import (C, IO_sgetn, "_IO_sgetn");
   function IO_seekoff (a1 : access IO_FILE; a2 : bits.types.off64_t;
      a3 : signed_int; a4 : signed_int) return bits.types.off64_t;
   pragma Import (C, IO_seekoff, "_IO_seekoff");
   function IO_seekpos (a1 : access IO_FILE; a2 : bits.types.off64_t;
      a3 : signed_int) return bits.types.off64_t;
   pragma Import (C, IO_seekpos, "_IO_seekpos");
   procedure IO_free_backup_area (a1 : access IO_FILE);
   pragma Import (C, IO_free_backup_area, "_IO_free_backup_area");
   EOF : constant := -1;
   IOS_APPEND : constant := 8;
   IOS_ATEND : constant := 4;
   IOS_BIN : constant := 128;
   IOS_INPUT : constant := 1;
   IOS_NOCREATE : constant := 32;
   IOS_NOREPLACE : constant := 64;
   IOS_OUTPUT : constant := 2;
   IOS_TRUNC : constant := 16;
   IO_BAD_SEEN : constant := 16384;
   --  _IO_BE (function macro)
   IO_BOOLALPHA : constant := 65536;
   IO_BUFSIZ : constant := 8192;
   IO_CURRENTLY_PUTTING : constant := 2048;
   IO_DEC : constant := 16;
   IO_DELETE_DONT_CLOSE : constant := 64;
   IO_DONT_CLOSE : constant := 32768;
   IO_EOF_SEEN : constant := 16;
   IO_ERR_SEEN : constant := 32;
   IO_FIXED : constant := 4096;
   IO_FLAGS2_MMAP : constant := 1;
   IO_FLAGS2_NOTCANCEL : constant := 2;
   IO_FLAGS2_USER_WBUF : constant := 8;
   --  _IO_HAVE_ST_BLKSIZE (unparsible)
   IO_HEX : constant := 64;
   IO_INTERNAL : constant := 8;
   IO_IN_BACKUP : constant := 256;
   IO_IS_APPENDING : constant := 4096;
   IO_IS_FILEBUF : constant := 8192;
   IO_LEFT : constant := 2;
   IO_LINE_BUF : constant := 512;
   IO_LINKED : constant := 128;
   IO_MAGIC : constant := -72548352;
   IO_MAGIC_MASK : constant := -65536;
   IO_NO_READS : constant := 4;
   IO_NO_WRITES : constant := 8;
   IO_OCT : constant := 32;
   --  _IO_PENDING_OUTPUT_COUNT (uninterpretable)
   IO_RIGHT : constant := 4;
   IO_SCIENTIFIC : constant := 2048;
   IO_SHOWBASE : constant := 128;
   IO_SHOWPOINT : constant := 256;
   IO_SHOWPOS : constant := 1024;
   IO_SKIPWS : constant := 1;
   IO_STDIO : constant := 16384;
   --  _IO_STDIO_H (empty)
   IO_TIED_PUT_GET : constant := 1024;
   IO_UNBUFFERED : constant := 2;
   IO_UNIFIED_JUMPTABLES : constant := 1;
   IO_UNITBUF : constant := 8192;
   IO_UPPERCASE : constant := 512;
   IO_USER_BUF : constant := 1;
   IO_USER_LOCK : constant := 32768;
   --  _IO_cleanup_region_end (empty)
   --  _IO_cleanup_region_start (empty)
   --  _IO_feof_unlocked (uninterpretable)
   --  _IO_ferror_unlocked (uninterpretable)
   --  ._IO_file_flags renames ._flags (accessor)
   --  _IO_flockfile (empty)
   subtype IO_fpos64_t is qG_config.G_fpos64_t;
   subtype IO_fpos_t is qG_config.G_fpos_t;
   --  _IO_ftrylockfile (empty)
   --  _IO_funlockfile (empty)
   --  _IO_getc_unlocked (uninterpretable)
   --  _IO_iconv_t (unparsible)
   subtype IO_off64_t is bits.types.off64_t;
   subtype IO_off_t is bits.types.off_t;
   --  _IO_peekc (uninterpretable)
   --  _IO_peekc_unlocked (uninterpretable)
   subtype IO_pid_t is bits.types.pid_t;
   --  _IO_putc_unlocked (uninterpretable)
   subtype IO_size_t is stddef.size_t;
   subtype IO_ssize_t is bits.types.ssize_t;
   --  _IO_stderr (unparsible)
   --  _IO_stdin (unparsible)
   --  _IO_stdout (unparsible)
   subtype IO_uid_t is bits.types.uid_t;
   subtype IO_va_list is stdarg.qqgnuc_va_list;
   --  _IO_wint_t (unparsible)
   OLD_STDIO_MAGIC : constant := -88342528;
   --  __HAVE_COLUMN (empty)
private
   type struct_IO_jump_t is null record;
   type struct_IO_FILE_plus is null record;
end C.libio;

c-qg_config.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.bits.types;
with C.stdarg;
with C.wchar;
package C.qG_config is
   pragma Preelaborate;
   type struct_db248717 is record
      pos : aliased bits.types.off_t;
      state : aliased wchar.mbstate_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_db248717);
   type struct_db248717_ptr is access all struct_db248717;
   for struct_db248717_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_db248717_ptr);
   pragma Convention (C, struct_db248717_ptr);
   type struct_db248717_const_ptr is access constant struct_db248717;
   for struct_db248717_const_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_db248717_const_ptr);
   pragma Convention (C, struct_db248717_const_ptr);
   subtype G_fpos_t is struct_db248717;
   subtype G_fpos_t_ptr is struct_db248717_ptr;
   subtype G_fpos_t_const_ptr is struct_db248717_const_ptr;
   type struct_eb9588dd is record
      pos : aliased bits.types.off64_t;
      state : aliased wchar.mbstate_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_eb9588dd);
   subtype G_fpos64_t is struct_eb9588dd;
   G_BUFSIZ : constant := 8192;
   G_HAVE_MMAP : constant := 1;
   G_HAVE_MREMAP : constant := 1;
   --  _G_HAVE_ST_BLKSIZE (unparsible)
   G_IO_IO_FILE_VERSION : constant := 131073;
   G_config_h : constant := 1;
   subtype G_va_list is stdarg.qqgnuc_va_list;
end C.qG_config;

c-stdarg.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.stdarg is
   pragma Preelaborate;
   subtype qqgnuc_va_list is builtin_va_list;
   --  __GNUC_VA_LIST (empty)
end C.stdarg;

c-stddef.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.stddef is
   pragma Preelaborate;
   subtype size_t is Standard.C.size_t;
   subtype size_t_ptr is Standard.C.size_t_ptr;
   --  #include <wchar.h>
   --  #include <_G_config.h>
   --  #include <stdarg.h>
   --  #include <libio.h>
   subtype wchar_t is Standard.C.wchar_t;
   subtype wchar_t_ptr is Standard.C.wchar_t_ptr;
   subtype wchar_t_const_ptr is Standard.C.wchar_t_const_ptr;
   C_NULL : constant void_ptr := void_ptr (System'To_Address (0));
   --  _BSD_SIZE_T_ (empty)
   --  _BSD_SIZE_T_DEFINED_ (empty)
   --  _GCC_SIZE_T (empty)
   --  _GCC_WCHAR_T (empty)
   --  _SIZET_ (empty)
   --  _SIZE_T (empty)
   --  _SIZE_T_ (empty)
   --  _SIZE_T_DECLARED (empty)
   --  _SIZE_T_DEFINED (empty)
   --  _SIZE_T_DEFINED_ (empty)
   --  _SYS_SIZE_T_H (empty)
   --  _T_SIZE (empty)
   --  _T_SIZE_ (empty)
   --  _T_WCHAR (empty)
   --  _T_WCHAR_ (empty)
   --  _WCHAR_T (empty)
   --  _WCHAR_T_ (empty)
   --  _WCHAR_T_DECLARED (empty)
   --  _WCHAR_T_DEFINED (empty)
   --  _WCHAR_T_DEFINED_ (empty)
   --  _WCHAR_T_H (empty)
   --  __INT_WCHAR_T_H (empty)
   --  __SIZE_T (empty)
   --  __SIZE_T__ (empty)
   --  __WCHAR_T (empty)
   --  __WCHAR_T__ (empty)
   --  ___int_size_t_h (empty)
   --  ___int_wchar_t_h (empty)
   --  __size_t (empty)
   --  __size_t__ (empty)
   --  __wchar_t__ (empty)
end C.stddef;

c-stdio.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.bits.types;
with C.libio;
with C.qG_config;
with C.stdarg;
with C.stddef;
package C.stdio is
   pragma Preelaborate;
   subtype FILE is libio.struct_IO_FILE;
   subtype FILE_ptr is libio.struct_IO_FILE_ptr;
   subtype qqFILE is libio.struct_IO_FILE;
   subtype va_list is stdarg.qqgnuc_va_list;
   subtype fpos_t is qG_config.G_fpos_t;
   subtype fpos_t_ptr is qG_config.G_fpos_t_ptr;
   subtype fpos_t_const_ptr is qG_config.G_fpos_t_const_ptr;
   stdin : aliased libio.struct_IO_FILE_ptr;
   pragma Import (C, stdin, "stdin");
   stdout : aliased libio.struct_IO_FILE_ptr;
   pragma Import (C, stdout, "stdout");
   stderr : aliased libio.struct_IO_FILE_ptr;
   pragma Import (C, stderr, "stderr");
   function remove (filename : access constant char) return signed_int;
   pragma Import (C, remove, "remove");
   function rename (old : access constant char; A_new : access constant char)
      return signed_int;
   pragma Import (C, rename, "rename");
   function renameat (oldfd : signed_int; old : access constant char;
      newfd : signed_int; A_new : access constant char) return signed_int;
   pragma Import (C, renameat, "renameat");
   function tmpfile return FILE_ptr;
   pragma Import (C, tmpfile, "tmpfile");
   function tmpnam (s : access char) return char_ptr;
   pragma Import (C, tmpnam, "tmpnam");
   function tmpnam_r (s : access char) return char_ptr;
   pragma Import (C, tmpnam_r, "tmpnam_r");
   function tempnam (dir : access constant char; pfx : access constant char)
      return char_ptr;
   pragma Import (C, tempnam, "tempnam");
   function fclose (stream : access FILE) return signed_int;
   pragma Import (C, fclose, "fclose");
   function fflush (stream : access FILE) return signed_int;
   pragma Import (C, fflush, "fflush");
   function fflush_unlocked (stream : access FILE) return signed_int;
   pragma Import (C, fflush_unlocked, "fflush_unlocked");
   function fopen (filename : access constant char;
      modes : access constant char) return FILE_ptr;
   pragma Import (C, fopen, "fopen");
   function freopen (filename : access constant char;
      modes : access constant char; stream : access FILE) return FILE_ptr;
   pragma Import (C, freopen, "freopen");
   function fdopen (fd : signed_int; modes : access constant char)
      return FILE_ptr;
   pragma Import (C, fdopen, "fdopen");
   function fmemopen (s : void_ptr; len : stddef.size_t;
      modes : access constant char) return FILE_ptr;
   pragma Import (C, fmemopen, "fmemopen");
   function open_memstream (bufloc : access char_ptr;
      sizeloc : access stddef.size_t) return FILE_ptr;
   pragma Import (C, open_memstream, "open_memstream");
   procedure setbuf (stream : access FILE; buf : access char);
   pragma Import (C, setbuf, "setbuf");
   function setvbuf (stream : access FILE; buf : access char;
      modes : signed_int; n : stddef.size_t) return signed_int;
   pragma Import (C, setvbuf, "setvbuf");
   procedure setbuffer (stream : access FILE; buf : access char;
      size : stddef.size_t);
   pragma Import (C, setbuffer, "setbuffer");
   procedure setlinebuf (stream : access FILE);
   pragma Import (C, setlinebuf, "setlinebuf");
   function fprintf (stream : access FILE; format : access constant char)
      return signed_int;
   pragma Import (C, fprintf, "fprintf");
   function printf (format : access constant char) return signed_int;
   pragma Import (C, printf, "printf");
   function sprintf (s : access char; format : access constant char)
      return signed_int;
   pragma Import (C, sprintf, "sprintf");
   function vfprintf (s : access FILE; format : access constant char;
      arg : stdarg.qqgnuc_va_list) return signed_int;
   pragma Import (C, vfprintf, "vfprintf");
   function vprintf (format : access constant char;
      arg : stdarg.qqgnuc_va_list) return signed_int;
   pragma Import (C, vprintf, "vprintf");
   function vsprintf (s : access char; format : access constant char;
      arg : stdarg.qqgnuc_va_list) return signed_int;
   pragma Import (C, vsprintf, "vsprintf");
   function snprintf (s : access char; maxlen : stddef.size_t;
      format : access constant char) return signed_int;
   pragma Import (C, snprintf, "snprintf");
   function vsnprintf (s : access char; maxlen : stddef.size_t;
      format : access constant char; arg : stdarg.qqgnuc_va_list)
      return signed_int;
   pragma Import (C, vsnprintf, "vsnprintf");
   function vdprintf (fd : signed_int; fmt : access constant char;
      arg : stdarg.qqgnuc_va_list) return signed_int;
   pragma Import (C, vdprintf, "vdprintf");
   function dprintf (fd : signed_int; fmt : access constant char)
      return signed_int;
   pragma Import (C, dprintf, "dprintf");
   function fscanf (stream : access FILE; format : access constant char)
      return signed_int;
   pragma Import (C, fscanf, "_isoc99_fscanf");
   function scanf (format : access constant char) return signed_int;
   pragma Import (C, scanf, "_isoc99_scanf");
   function sscanf (s : access constant char; format : access constant char)
      return signed_int;
   pragma Import (C, sscanf, "_isoc99_sscanf");
   function vfscanf (s : access FILE; format : access constant char;
      arg : stdarg.qqgnuc_va_list) return signed_int;
   pragma Import (C, vfscanf, "_isoc99_vfscanf");
   function vscanf (format : access constant char;
      arg : stdarg.qqgnuc_va_list) return signed_int;
   pragma Import (C, vscanf, "_isoc99_vscanf");
   function vsscanf (s : access constant char; format : access constant char;
      arg : stdarg.qqgnuc_va_list) return signed_int;
   pragma Import (C, vsscanf, "_isoc99_vsscanf");
   function fgetc (stream : access FILE) return signed_int;
   pragma Import (C, fgetc, "fgetc");
   function getc (stream : access FILE) return signed_int;
   pragma Import (C, getc, "getc");
   function getchar return signed_int;
   pragma Import (C, getchar, "getchar");
   function getc_unlocked (stream : access FILE) return signed_int;
   pragma Import (C, getc_unlocked, "getc_unlocked");
   function getchar_unlocked return signed_int;
   pragma Import (C, getchar_unlocked, "getchar_unlocked");
   function fgetc_unlocked (stream : access FILE) return signed_int;
   pragma Import (C, fgetc_unlocked, "fgetc_unlocked");
   function fputc (c : signed_int; stream : access FILE) return signed_int;
   pragma Import (C, fputc, "fputc");
   function putc (c : signed_int; stream : access FILE) return signed_int;
   pragma Import (C, putc, "putc");
   function putchar (c : signed_int) return signed_int;
   pragma Import (C, putchar, "putchar");
   function fputc_unlocked (c : signed_int; stream : access FILE)
      return signed_int;
   pragma Import (C, fputc_unlocked, "fputc_unlocked");
   function putc_unlocked (c : signed_int; stream : access FILE)
      return signed_int;
   pragma Import (C, putc_unlocked, "putc_unlocked");
   function putchar_unlocked (c : signed_int) return signed_int;
   pragma Import (C, putchar_unlocked, "putchar_unlocked");
   function getw (stream : access FILE) return signed_int;
   pragma Import (C, getw, "getw");
   function putw (w : signed_int; stream : access FILE) return signed_int;
   pragma Import (C, putw, "putw");
   function fgets (s : access char; n : signed_int; stream : access FILE)
      return char_ptr;
   pragma Import (C, fgets, "fgets");
   function gets (s : access char) return char_ptr;
   pragma Import (C, gets, "gets");
   function qqgetdelim (lineptr : access char_ptr; n : access stddef.size_t;
      delimiter : signed_int; stream : access FILE)
      return bits.types.ssize_t;
   pragma Import (C, qqgetdelim, "__getdelim");
   function getdelim (lineptr : access char_ptr; n : access stddef.size_t;
      delimiter : signed_int; stream : access FILE)
      return bits.types.ssize_t;
   pragma Import (C, getdelim, "getdelim");
   function getline (lineptr : access char_ptr; n : access stddef.size_t;
      stream : access FILE) return bits.types.ssize_t;
   pragma Import (C, getline, "getline");
   function fputs (s : access constant char; stream : access FILE)
      return signed_int;
   pragma Import (C, fputs, "fputs");
   function puts (s : access constant char) return signed_int;
   pragma Import (C, puts, "puts");
   function ungetc (c : signed_int; stream : access FILE) return signed_int;
   pragma Import (C, ungetc, "ungetc");
   function fread (ptr : void_ptr; size : stddef.size_t; n : stddef.size_t;
      stream : access FILE) return stddef.size_t;
   pragma Import (C, fread, "fread");
   function fwrite (ptr : void_const_ptr; size : stddef.size_t;
      n : stddef.size_t; s : access FILE) return stddef.size_t;
   pragma Import (C, fwrite, "fwrite");
   function fread_unlocked (ptr : void_ptr; size : stddef.size_t;
      n : stddef.size_t; stream : access FILE) return stddef.size_t;
   pragma Import (C, fread_unlocked, "fread_unlocked");
   function fwrite_unlocked (ptr : void_const_ptr; size : stddef.size_t;
      n : stddef.size_t; stream : access FILE) return stddef.size_t;
   pragma Import (C, fwrite_unlocked, "fwrite_unlocked");
   function fseek (stream : access FILE; off : signed_long;
      whence : signed_int) return signed_int;
   pragma Import (C, fseek, "fseek");
   function ftell (stream : access FILE) return signed_long;
   pragma Import (C, ftell, "ftell");
   procedure rewind (stream : access FILE);
   pragma Import (C, rewind, "rewind");
   function fseeko (stream : access FILE; off : bits.types.off_t;
      whence : signed_int) return signed_int;
   pragma Import (C, fseeko, "fseeko");
   function ftello (stream : access FILE) return bits.types.off_t;
   pragma Import (C, ftello, "ftello");
   function fgetpos (stream : access FILE; pos : access fpos_t)
      return signed_int;
   pragma Import (C, fgetpos, "fgetpos");
   function fsetpos (stream : access FILE; pos : access constant fpos_t)
      return signed_int;
   pragma Import (C, fsetpos, "fsetpos");
   procedure clearerr (stream : access FILE);
   pragma Import (C, clearerr, "clearerr");
   function feof (stream : access FILE) return signed_int;
   pragma Import (C, feof, "feof");
   function ferror (stream : access FILE) return signed_int;
   pragma Import (C, ferror, "ferror");
   procedure clearerr_unlocked (stream : access FILE);
   pragma Import (C, clearerr_unlocked, "clearerr_unlocked");
   function feof_unlocked (stream : access FILE) return signed_int;
   pragma Import (C, feof_unlocked, "feof_unlocked");
   function ferror_unlocked (stream : access FILE) return signed_int;
   pragma Import (C, ferror_unlocked, "ferror_unlocked");
   procedure perror (s : access constant char);
   pragma Import (C, perror, "perror");
   --  #include <bits/sys_errlist.h>
   function fileno (stream : access FILE) return signed_int;
   pragma Import (C, fileno, "fileno");
   function fileno_unlocked (stream : access FILE) return signed_int;
   pragma Import (C, fileno_unlocked, "fileno_unlocked");
   function popen (command : access constant char;
      modes : access constant char) return FILE_ptr;
   pragma Import (C, popen, "popen");
   function pclose (stream : access FILE) return signed_int;
   pragma Import (C, pclose, "pclose");
   function ctermid (s : access char) return char_ptr;
   pragma Import (C, ctermid, "ctermid");
   procedure flockfile (stream : access FILE);
   pragma Import (C, flockfile, "flockfile");
   function ftrylockfile (stream : access FILE) return signed_int;
   pragma Import (C, ftrylockfile, "ftrylockfile");
   procedure funlockfile (stream : access FILE);
   pragma Import (C, funlockfile, "funlockfile");
   BUFSIZ : constant := 8192;
   P_tmpdir : constant char_array (0 .. 4) := "/tmp" & char'Val (0);
   SEEK_CUR : constant := 1;
   SEEK_END : constant := 2;
   SEEK_SET : constant := 0;
   IOFBF : constant := 0;
   IOLBF : constant := 1;
   IONBF : constant := 2;
   STDIO_H : constant := 1;
   --  _STDIO_USES_IOSTREAM (empty)
   --  _VA_LIST_DEFINED (empty)
   FILE_defined : constant := 1;
   qqqqFILE_defined : constant := 1;
   --  stderr (repeating itself)
   --  stdin (repeating itself)
   --  stdout (repeating itself)
end C.stdio;

c-stdlib.adb

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package body C.stdlib is
   function MB_CUR_MAX return stddef.size_t is
   begin
      return ctype_get_mb_cur_max;
   end MB_CUR_MAX;
end C.stdlib;

c-stdlib.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.stddef;
with C.sys.types;
package C.stdlib is
   pragma Preelaborate;
   type struct_3210b632 is record
      quot : aliased signed_int;
      F_rem : aliased signed_int;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_3210b632);
   subtype div_t is struct_3210b632;
   type struct_b762d41b is record
      quot : aliased signed_long;
      F_rem : aliased signed_long;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_b762d41b);
   subtype ldiv_t is struct_b762d41b;
   type struct_b37d1920 is record
      quot : aliased signed_long_long;
      F_rem : aliased signed_long_long;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_b37d1920);
   subtype lldiv_t is struct_b37d1920;
   function ctype_get_mb_cur_max return stddef.size_t;
   pragma Import (C, ctype_get_mb_cur_max, "__ctype_get_mb_cur_max");
   function atof (nptr : access constant char) return double;
   pragma Import (C, atof, "atof");
   function atoi (nptr : access constant char) return signed_int;
   pragma Import (C, atoi, "atoi");
   function atol (nptr : access constant char) return signed_long;
   pragma Import (C, atol, "atol");
   function atoll (nptr : access constant char) return signed_long_long;
   pragma Import (C, atoll, "atoll");
   function strtod (nptr : access constant char; endptr : access char_ptr)
      return double;
   pragma Import (C, strtod, "strtod");
   function strtof (nptr : access constant char; endptr : access char_ptr)
      return float;
   pragma Import (C, strtof, "strtof");
   function strtold (nptr : access constant char; endptr : access char_ptr)
      return long_double;
   pragma Import (C, strtold, "strtold");
   function strtol (nptr : access constant char; endptr : access char_ptr;
      base : signed_int) return signed_long;
   pragma Import (C, strtol, "strtol");
   function strtoul (nptr : access constant char; endptr : access char_ptr;
      base : signed_int) return unsigned_long;
   pragma Import (C, strtoul, "strtoul");
   function strtoq (nptr : access constant char; endptr : access char_ptr;
      base : signed_int) return signed_long_long;
   pragma Import (C, strtoq, "strtoq");
   function strtouq (nptr : access constant char; endptr : access char_ptr;
      base : signed_int) return unsigned_long_long;
   pragma Import (C, strtouq, "strtouq");
   function strtoll (nptr : access constant char; endptr : access char_ptr;
      base : signed_int) return signed_long_long;
   pragma Import (C, strtoll, "strtoll");
   function strtoull (nptr : access constant char; endptr : access char_ptr;
      base : signed_int) return unsigned_long_long;
   pragma Import (C, strtoull, "strtoull");
   function l64a (n : signed_long) return char_ptr;
   pragma Import (C, l64a, "l64a");
   function a64l (s : access constant char) return signed_long;
   pragma Import (C, a64l, "a64l");
   --  #include <bits/byteswap.h>
   --  #include <bits/sigset.h>
   --  #include <time.h>
   --  #include <bits/time.h>
   --  #include <sys/select.h>
   --  #include <sys/sysmacros.h>
   --  #include <sys/types.h>
   --  #include <bits/pthreadtypes.h>
   function random return signed_long;
   pragma Import (C, random, "random");
   procedure srandom (seed : unsigned_int);
   pragma Import (C, srandom, "srandom");
   function initstate (seed : unsigned_int; statebuf : access char;
      statelen : stddef.size_t) return char_ptr;
   pragma Import (C, initstate, "initstate");
   function setstate (statebuf : access char) return char_ptr;
   pragma Import (C, setstate, "setstate");
   type struct_random_data;
   type struct_random_data is record
      fptr : aliased sys.types.int32_t_ptr;
      rptr : aliased sys.types.int32_t_ptr;
      state : aliased sys.types.int32_t_ptr;
      rand_type : aliased signed_int;
      rand_deg : aliased signed_int;
      rand_sep : aliased signed_int;
      end_ptr : aliased sys.types.int32_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_random_data);
   type struct_random_data_ptr is access all struct_random_data;
   for struct_random_data_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_random_data_ptr);
   pragma Convention (C, struct_random_data_ptr);
   function random_r (buf : access struct_random_data;
      result : access sys.types.int32_t) return signed_int;
   pragma Import (C, random_r, "random_r");
   function srandom_r (seed : unsigned_int; buf : access struct_random_data)
      return signed_int;
   pragma Import (C, srandom_r, "srandom_r");
   function initstate_r (seed : unsigned_int; statebuf : access char;
      statelen : stddef.size_t; buf : access struct_random_data)
      return signed_int;
   pragma Import (C, initstate_r, "initstate_r");
   function setstate_r (statebuf : access char;
      buf : access struct_random_data) return signed_int;
   pragma Import (C, setstate_r, "setstate_r");
   function rand return signed_int;
   pragma Import (C, rand, "rand");
   procedure srand (seed : unsigned_int);
   pragma Import (C, srand, "srand");
   function rand_r (seed : access unsigned_int) return signed_int;
   pragma Import (C, rand_r, "rand_r");
   function drand48 return double;
   pragma Import (C, drand48, "drand48");
   function erand48 (xsubi : access unsigned_short) return double;
   pragma Import (C, erand48, "erand48");
   function lrand48 return signed_long;
   pragma Import (C, lrand48, "lrand48");
   function nrand48 (xsubi : access unsigned_short) return signed_long;
   pragma Import (C, nrand48, "nrand48");
   function mrand48 return signed_long;
   pragma Import (C, mrand48, "mrand48");
   function jrand48 (xsubi : access unsigned_short) return signed_long;
   pragma Import (C, jrand48, "jrand48");
   procedure srand48 (seedval : signed_long);
   pragma Import (C, srand48, "srand48");
   function seed48 (seed16v : access unsigned_short)
      return unsigned_short_ptr;
   pragma Import (C, seed48, "seed48");
   procedure lcong48 (param : access unsigned_short);
   pragma Import (C, lcong48, "lcong48");
   type struct_drand48_data;
   type struct_drand48_data is record
      x : aliased unsigned_short_array (0 .. 2);
      old_x : aliased unsigned_short_array (0 .. 2);
      c : aliased unsigned_short;
      init : aliased unsigned_short;
      a : aliased unsigned_long_long;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_drand48_data);
   type struct_drand48_data_ptr is access all struct_drand48_data;
   for struct_drand48_data_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_drand48_data_ptr);
   pragma Convention (C, struct_drand48_data_ptr);
   function drand48_r (buffer : access struct_drand48_data;
      result : access double) return signed_int;
   pragma Import (C, drand48_r, "drand48_r");
   function erand48_r (xsubi : access unsigned_short;
      buffer : access struct_drand48_data; result : access double)
      return signed_int;
   pragma Import (C, erand48_r, "erand48_r");
   function lrand48_r (buffer : access struct_drand48_data;
      result : access signed_long) return signed_int;
   pragma Import (C, lrand48_r, "lrand48_r");
   function nrand48_r (xsubi : access unsigned_short;
      buffer : access struct_drand48_data; result : access signed_long)
      return signed_int;
   pragma Import (C, nrand48_r, "nrand48_r");
   function mrand48_r (buffer : access struct_drand48_data;
      result : access signed_long) return signed_int;
   pragma Import (C, mrand48_r, "mrand48_r");
   function jrand48_r (xsubi : access unsigned_short;
      buffer : access struct_drand48_data; result : access signed_long)
      return signed_int;
   pragma Import (C, jrand48_r, "jrand48_r");
   function srand48_r (seedval : signed_long;
      buffer : access struct_drand48_data) return signed_int;
   pragma Import (C, srand48_r, "srand48_r");
   function seed48_r (seed16v : access unsigned_short;
      buffer : access struct_drand48_data) return signed_int;
   pragma Import (C, seed48_r, "seed48_r");
   function lcong48_r (param : access unsigned_short;
      buffer : access struct_drand48_data) return signed_int;
   pragma Import (C, lcong48_r, "lcong48_r");
   function malloc (size : stddef.size_t) return void_ptr;
   pragma Import (C, malloc, "malloc");
   function calloc (nmemb : stddef.size_t; size : stddef.size_t)
      return void_ptr;
   pragma Import (C, calloc, "calloc");
   function realloc (ptr : void_ptr; size : stddef.size_t) return void_ptr;
   pragma Import (C, realloc, "realloc");
   procedure free (ptr : void_ptr);
   pragma Import (C, free, "free");
   procedure cfree (ptr : void_ptr);
   pragma Import (C, cfree, "cfree");
   --  #include <alloca.h>
   function valloc (size : stddef.size_t) return void_ptr;
   pragma Import (C, valloc, "valloc");
   function posix_memalign (memptr : access void_ptr;
      alignment : stddef.size_t; size : stddef.size_t) return signed_int;
   pragma Import (C, posix_memalign, "posix_memalign");
   type access_e823f645 is access procedure;
   pragma Convention (C, access_e823f645);
   procedure C_abort;
   pragma No_Return (C_abort);
   pragma Import (C, C_abort, "abort");
   function atexit (func : access_e823f645) return signed_int;
   pragma Import (C, atexit, "atexit");
   type access_e23946a4 is access procedure (status : signed_int;
      arg : void_ptr);
   pragma Convention (C, access_e23946a4);
   function on_exit (func : access_e23946a4; arg : void_ptr)
      return signed_int;
   pragma Import (C, on_exit, "on_exit");
   procedure C_exit (status : signed_int);
   pragma No_Return (C_exit);
   pragma Import (C, C_exit, "exit");
   procedure C_qExit_U (status : signed_int);
   pragma No_Return (C_qExit_U);
   pragma Import (C, C_qExit_U, "_Exit");
   function getenv (name : access constant char) return char_ptr;
   pragma Import (C, getenv, "getenv");
   function putenv (string : access char) return signed_int;
   pragma Import (C, putenv, "putenv");
   function setenv (name : access constant char;
      value : access constant char; replace : signed_int) return signed_int;
   pragma Import (C, setenv, "setenv");
   function unsetenv (name : access constant char) return signed_int;
   pragma Import (C, unsetenv, "unsetenv");
   function clearenv return signed_int;
   pragma Import (C, clearenv, "clearenv");
   function mktemp (template : access char) return char_ptr;
   pragma Import (C, mktemp, "mktemp");
   function mkstemp (template : access char) return signed_int;
   pragma Import (C, mkstemp, "mkstemp");
   function mkstemps (template : access char; suffixlen : signed_int)
      return signed_int;
   pragma Import (C, mkstemps, "mkstemps");
   function mkdtemp (template : access char) return char_ptr;
   pragma Import (C, mkdtemp, "mkdtemp");
   function C_system (command : access constant char) return signed_int;
   pragma Import (C, C_system, "system");
   function realpath (name : access constant char; resolved : access char)
      return char_ptr;
   pragma Import (C, realpath, "realpath");
   type access_9017117e is access function (a1 : void_const_ptr;
      a2 : void_const_ptr) return signed_int;
   pragma Convention (C, access_9017117e);
   subtype qqcompar_fn_t is access_9017117e;
   function bsearch (key : void_const_ptr; base : void_const_ptr;
      nmemb : stddef.size_t; size : stddef.size_t; compar : qqcompar_fn_t)
      return void_ptr;
   pragma Import (C, bsearch, "bsearch");
   procedure qsort (base : void_ptr; nmemb : stddef.size_t;
      size : stddef.size_t; compar : qqcompar_fn_t);
   pragma Import (C, qsort, "qsort");
   function C_abs (x : signed_int) return signed_int;
   pragma Import (C, C_abs, "abs");
   function labs (x : signed_long) return signed_long;
   pragma Import (C, labs, "labs");
   function llabs (x : signed_long_long) return signed_long_long;
   pragma Import (C, llabs, "llabs");
   function div (numer : signed_int; denom : signed_int) return div_t;
   pragma Import (C, div, "div");
   function ldiv (numer : signed_long; denom : signed_long) return ldiv_t;
   pragma Import (C, ldiv, "ldiv");
   function lldiv (numer : signed_long_long; denom : signed_long_long)
      return lldiv_t;
   pragma Import (C, lldiv, "lldiv");
   function ecvt (value : double; ndigit : signed_int;
      decpt : access signed_int; sign : access signed_int) return char_ptr;
   pragma Import (C, ecvt, "ecvt");
   function fcvt (value : double; ndigit : signed_int;
      decpt : access signed_int; sign : access signed_int) return char_ptr;
   pragma Import (C, fcvt, "fcvt");
   function gcvt (value : double; ndigit : signed_int; buf : access char)
      return char_ptr;
   pragma Import (C, gcvt, "gcvt");
   function qecvt (value : long_double; ndigit : signed_int;
      decpt : access signed_int; sign : access signed_int) return char_ptr;
   pragma Import (C, qecvt, "qecvt");
   function qfcvt (value : long_double; ndigit : signed_int;
      decpt : access signed_int; sign : access signed_int) return char_ptr;
   pragma Import (C, qfcvt, "qfcvt");
   function qgcvt (value : long_double; ndigit : signed_int;
      buf : access char) return char_ptr;
   pragma Import (C, qgcvt, "qgcvt");
   function ecvt_r (value : double; ndigit : signed_int;
      decpt : access signed_int; sign : access signed_int; buf : access char;
      len : stddef.size_t) return signed_int;
   pragma Import (C, ecvt_r, "ecvt_r");
   function fcvt_r (value : double; ndigit : signed_int;
      decpt : access signed_int; sign : access signed_int; buf : access char;
      len : stddef.size_t) return signed_int;
   pragma Import (C, fcvt_r, "fcvt_r");
   function qecvt_r (value : long_double; ndigit : signed_int;
      decpt : access signed_int; sign : access signed_int; buf : access char;
      len : stddef.size_t) return signed_int;
   pragma Import (C, qecvt_r, "qecvt_r");
   function qfcvt_r (value : long_double; ndigit : signed_int;
      decpt : access signed_int; sign : access signed_int; buf : access char;
      len : stddef.size_t) return signed_int;
   pragma Import (C, qfcvt_r, "qfcvt_r");
   function mblen (s : access constant char; n : stddef.size_t)
      return signed_int;
   pragma Import (C, mblen, "mblen");
   function mbtowc (pwc : access stddef.wchar_t; s : access constant char;
      n : stddef.size_t) return signed_int;
   pragma Import (C, mbtowc, "mbtowc");
   function wctomb (s : access char; wchar : stddef.wchar_t)
      return signed_int;
   pragma Import (C, wctomb, "wctomb");
   function mbstowcs (pwcs : access stddef.wchar_t; s : access constant char;
      n : stddef.size_t) return stddef.size_t;
   pragma Import (C, mbstowcs, "mbstowcs");
   function wcstombs (s : access char; pwcs : access constant stddef.wchar_t;
      n : stddef.size_t) return stddef.size_t;
   pragma Import (C, wcstombs, "wcstombs");
   function rpmatch (response : access constant char) return signed_int;
   pragma Import (C, rpmatch, "rpmatch");
   function getsubopt (optionp : access char_ptr; tokens : access char_ptr;
      valuep : access char_ptr) return signed_int;
   pragma Import (C, getsubopt, "getsubopt");
   function getloadavg (loadavg : access double; nelem : signed_int)
      return signed_int;
   pragma Import (C, getloadavg, "getloadavg");
   EXIT_FAILURE : constant := 1;
   EXIT_SUCCESS : constant := 0;
   function MB_CUR_MAX return stddef.size_t;
   pragma Inline_Always (MB_CUR_MAX);
   RAND_MAX : constant := 2147483647;
   --  WEXITSTATUS (unparsible)
   --  WIFCONTINUED (unparsible)
   --  WIFEXITED (unparsible)
   --  WIFSIGNALED (unparsible)
   --  WIFSTOPPED (unparsible)
   --  WSTOPSIG (unparsible)
   --  WTERMSIG (unparsible)
   STDLIB_H : constant := 1;
   --  __COMPAR_FN_T (empty)
   ldiv_t_defined : constant := 1;
   lldiv_t_defined : constant := 1;
   --  __malloc_and_calloc_defined (empty)
end C.stdlib;

c-string.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.stddef;
with C.xlocale;
package C.string is
   pragma Preelaborate;
   function memcpy (dest : void_ptr; src : void_const_ptr; n : stddef.size_t)
      return void_ptr;
   pragma Import (C, memcpy, "memcpy");
   function memmove (dest : void_ptr; src : void_const_ptr;
      n : stddef.size_t) return void_ptr;
   pragma Import (C, memmove, "memmove");
   function memccpy (dest : void_ptr; src : void_const_ptr; c : signed_int;
      n : stddef.size_t) return void_ptr;
   pragma Import (C, memccpy, "memccpy");
   function memset (s : void_ptr; c : signed_int; n : stddef.size_t)
      return void_ptr;
   pragma Import (C, memset, "memset");
   function memcmp (s1 : void_const_ptr; s2 : void_const_ptr;
      n : stddef.size_t) return signed_int;
   pragma Import (C, memcmp, "memcmp");
   function memchr (s : void_const_ptr; c : signed_int; n : stddef.size_t)
      return void_ptr;
   pragma Import (C, memchr, "memchr");
   function strcpy (dest : access char; src : access constant char)
      return char_ptr;
   pragma Import (C, strcpy, "strcpy");
   function strncpy (dest : access char; src : access constant char;
      n : stddef.size_t) return char_ptr;
   pragma Import (C, strncpy, "strncpy");
   function strcat (dest : access char; src : access constant char)
      return char_ptr;
   pragma Import (C, strcat, "strcat");
   function strncat (dest : access char; src : access constant char;
      n : stddef.size_t) return char_ptr;
   pragma Import (C, strncat, "strncat");
   function strcmp (s1 : access constant char; s2 : access constant char)
      return signed_int;
   pragma Import (C, strcmp, "strcmp");
   function strncmp (s1 : access constant char; s2 : access constant char;
      n : stddef.size_t) return signed_int;
   pragma Import (C, strncmp, "strncmp");
   function strcoll (s1 : access constant char; s2 : access constant char)
      return signed_int;
   pragma Import (C, strcoll, "strcoll");
   function strxfrm (dest : access char; src : access constant char;
      n : stddef.size_t) return stddef.size_t;
   pragma Import (C, strxfrm, "strxfrm");
   --  #include <xlocale.h>
   function strcoll_l (s1 : access constant char; s2 : access constant char;
      l : access xlocale.struct_locale_struct) return signed_int;
   pragma Import (C, strcoll_l, "strcoll_l");
   function strxfrm_l (dest : access char; src : access constant char;
      n : stddef.size_t; l : access xlocale.struct_locale_struct)
      return stddef.size_t;
   pragma Import (C, strxfrm_l, "strxfrm_l");
   function strdup (s : access constant char) return char_ptr;
   pragma Import (C, strdup, "strdup");
   function strndup (string : access constant char; n : stddef.size_t)
      return char_ptr;
   pragma Import (C, strndup, "strndup");
   function strchr (s : access constant char; c : signed_int)
      return char_ptr;
   pragma Import (C, strchr, "strchr");
   function strrchr (s : access constant char; c : signed_int)
      return char_ptr;
   pragma Import (C, strrchr, "strrchr");
   function strcspn (s : access constant char; reject : access constant char)
      return stddef.size_t;
   pragma Import (C, strcspn, "strcspn");
   function strspn (s : access constant char;
      A_accept : access constant char) return stddef.size_t;
   pragma Import (C, strspn, "strspn");
   function strpbrk (s : access constant char;
      A_accept : access constant char) return char_ptr;
   pragma Import (C, strpbrk, "strpbrk");
   function strstr (haystack : access constant char;
      needle : access constant char) return char_ptr;
   pragma Import (C, strstr, "strstr");
   function strtok (s : access char; delim : access constant char)
      return char_ptr;
   pragma Import (C, strtok, "strtok");
   function qqstrtok_r (s : access char; delim : access constant char;
      save_ptr : access char_ptr) return char_ptr;
   pragma Import (C, qqstrtok_r, "__strtok_r");
   function strtok_r (s : access char; delim : access constant char;
      save_ptr : access char_ptr) return char_ptr;
   pragma Import (C, strtok_r, "strtok_r");
   function strlen (s : access constant char) return stddef.size_t;
   pragma Import (C, strlen, "strlen");
   function strnlen (string : access constant char; maxlen : stddef.size_t)
      return stddef.size_t;
   pragma Import (C, strnlen, "strnlen");
   function strerror (errnum : signed_int) return char_ptr;
   pragma Import (C, strerror, "strerror");
   function strerror_r (errnum : signed_int; buf : access char;
      buflen : stddef.size_t) return signed_int;
   pragma Import (C, strerror_r, "_xpg_strerror_r");
   function strerror_l (errnum : signed_int;
      l : access xlocale.struct_locale_struct) return char_ptr;
   pragma Import (C, strerror_l, "strerror_l");
   procedure qqbzero (s : void_ptr; n : stddef.size_t);
   pragma Import (C, qqbzero, "__bzero");
   procedure bcopy (src : void_const_ptr; dest : void_ptr;
      n : stddef.size_t);
   pragma Import (C, bcopy, "bcopy");
   procedure bzero (s : void_ptr; n : stddef.size_t);
   pragma Import (C, bzero, "bzero");
   function bcmp (s1 : void_const_ptr; s2 : void_const_ptr;
      n : stddef.size_t) return signed_int;
   pragma Import (C, bcmp, "bcmp");
   function index (s : access constant char; c : signed_int) return char_ptr;
   pragma Import (C, index, "index");
   function rindex (s : access constant char; c : signed_int)
      return char_ptr;
   pragma Import (C, rindex, "rindex");
   function ffs (i : signed_int) return signed_int;
   pragma Import (C, ffs, "ffs");
   function strcasecmp (s1 : access constant char; s2 : access constant char)
      return signed_int;
   pragma Import (C, strcasecmp, "strcasecmp");
   function strncasecmp (s1 : access constant char;
      s2 : access constant char; n : stddef.size_t) return signed_int;
   pragma Import (C, strncasecmp, "strncasecmp");
   function strsep (stringp : access char_ptr; delim : access constant char)
      return char_ptr;
   pragma Import (C, strsep, "strsep");
   function strsignal (sig : signed_int) return char_ptr;
   pragma Import (C, strsignal, "strsignal");
   function qqstpcpy (dest : access char; src : access constant char)
      return char_ptr;
   pragma Import (C, qqstpcpy, "__stpcpy");
   function stpcpy (dest : access char; src : access constant char)
      return char_ptr;
   pragma Import (C, stpcpy, "stpcpy");
   function qqstpncpy (dest : access char; src : access constant char;
      n : stddef.size_t) return char_ptr;
   pragma Import (C, qqstpncpy, "__stpncpy");
   function stpncpy (dest : access char; src : access constant char;
      n : stddef.size_t) return char_ptr;
   pragma Import (C, stpncpy, "stpncpy");
   STRING_H : constant := 1;
end C.string;

c-sys-cdefs.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.sys.cdefs is
   pragma Preelaborate;
   SYS_CDEFS_H : constant := 1;
   --  __ASMNAME (unparsible)
   --  __ASMNAME2 (unparsible)
   --  __BEGIN_DECLS (empty)
   --  __BEGIN_NAMESPACE_C99 (empty)
   --  __BEGIN_NAMESPACE_STD (empty)
   --  __CONCAT (has # or ##)
   --  __END_DECLS (empty)
   --  __END_NAMESPACE_C99 (empty)
   --  __END_NAMESPACE_STD (empty)
   --  __LDBL_REDIR (unparsible)
   --  __LDBL_REDIR1 (unparsible)
   --  __LDBL_REDIR1_NTH (unparsible)
   --  __LDBL_REDIR_DECL (empty)
   --  __LDBL_REDIR_NTH (unparsible)
   --  __LEAF (unparsible)
   --  __LEAF_ATTR (attribute)
   --  __NTH (unparsible)
   --  __P (function macro)
   --  __PMT (function macro)
   --  __REDIRECT (has # or ##)
   --  __REDIRECT_LDBL (unparsible)
   --  __REDIRECT_NTH (has # or ##)
   --  __REDIRECT_NTHNL (has # or ##)
   --  __REDIRECT_NTH_LDBL (unparsible)
   --  __STRING (has # or ##)
   --  __THROW (attribute)
   --  __THROWNL (attribute)
   --  __USING_NAMESPACE_C99 (empty)
   --  __USING_NAMESPACE_STD (empty)
   --  __always_inline (alias of inline)
   --  __attribute_alloc_size__ (unparsible)
   --  __attribute_artificial__ (attribute)
   --  __attribute_const__ (attribute)
   --  __attribute_deprecated__ (attribute)
   --  __attribute_format_arg__ (parameterized declaration-specifiers)
   --  __attribute_format_strfmon__ (parameterized declaration-specifiers)
   --  __attribute_malloc__ (attribute)
   --  __attribute_noinline__ (attribute)
   --  __attribute_pure__ (attribute)
   --  __attribute_used__ (attribute)
   --  __attribute_warn_unused_result__ (attribute)
   --  __bos (function macro)
   --  __bos0 (function macro)
   --  __errordecl (unparsible)
   --  __extern_always_inline (unparsible)
   --  __extern_inline (alias of inline)
   --  __flexarr (unparsible)
   --  __fortify_function (unparsible)
   --  __glibc_likely (function macro)
   --  __glibc_unlikely (function macro)
   subtype long_double_t is long_double;
   --  __nonnull (unparsible)
   --  __ptr_t (unparsible)
   --  __restrict_arr (alias of restrict)
   --  __va_arg_pack (unparsible)
   --  __va_arg_pack_len (unparsible)
   --  __warnattr (unparsible)
   --  __warndecl (unparsible)
   --  __wur (empty)
end C.sys.cdefs;

c-sys-select_h.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.bits.sigset;
with C.bits.time;
with C.bits.types;
with C.time;
package C.sys.select_h is
   pragma Preelaborate;
   subtype sigset_t is bits.sigset.sigset_t;
   --  #include <time.h>
   --  #include <bits/time.h>
   subtype suseconds_t is bits.types.suseconds_t;
   subtype qqfd_mask is signed_long;
   subtype qqfd_mask_array is signed_long_array;
   type struct_8a2ace08 is record
      fds_bits : aliased qqfd_mask_array (0 .. 15);
   end record;
   pragma Convention (C_Pass_By_Copy, struct_8a2ace08);
   type struct_8a2ace08_ptr is access all struct_8a2ace08;
   for struct_8a2ace08_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_8a2ace08_ptr);
   pragma Convention (C, struct_8a2ace08_ptr);
   subtype fd_set is struct_8a2ace08;
   subtype fd_set_ptr is struct_8a2ace08_ptr;
   subtype fd_mask is qqfd_mask;
   function C_select (nfds : signed_int; readfds : access fd_set;
      writefds : access fd_set; exceptfds : access fd_set;
      timeout : access bits.time.struct_timeval) return signed_int;
   pragma Import (C, C_select, "select");
   function pselect (nfds : signed_int; readfds : access fd_set;
      writefds : access fd_set; exceptfds : access fd_set;
      timeout : access constant time.struct_timespec;
      sigmask : access constant bits.sigset.sigset_t) return signed_int;
   pragma Import (C, pselect, "pselect");
   --  FD_CLR (uninterpretable)
   --  FD_ISSET (uninterpretable)
   --  FD_SET (uninterpretable)
   FD_SETSIZE : constant := 1024;
   --  FD_ZERO (uninterpretable)
   NFDBITS : constant := 64;
   SYS_SELECT_H : constant := 1;
   --  __FDS_BITS (uninterpretable)
   --  __FD_ELT (function macro)
   --  __FD_MASK (function macro)
   qqNFDBITS : constant := 64;
   --  __sigset_t_defined (empty)
   --  __suseconds_t_defined (empty)
end C.sys.select_h;

c-sys-sysmacros.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.sys.sysmacros is
   pragma Preelaborate;
   function gnu_dev_major (dev : unsigned_long_long) return unsigned_int;
   pragma Import (C, gnu_dev_major, "gnu_dev_major");
   function gnu_dev_minor (dev : unsigned_long_long) return unsigned_int;
   pragma Import (C, gnu_dev_minor, "gnu_dev_minor");
   function gnu_dev_makedev (major : unsigned_int; minor : unsigned_int)
      return unsigned_long_long;
   pragma Import (C, gnu_dev_makedev, "gnu_dev_makedev");
   SYS_SYSMACROS_H : constant := 1;
   --  major (unparsible)
   --  makedev (unparsible)
   --  minor (unparsible)
end C.sys.sysmacros;

c-sys-types.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.bits.types;
package C.sys.types is
   pragma Preelaborate;
   subtype u_char is bits.types.u_char;
   subtype u_short is bits.types.u_short;
   subtype u_int is bits.types.u_int;
   subtype u_long is bits.types.u_long;
   subtype quad_t is bits.types.quad_t;
   subtype u_quad_t is bits.types.u_quad_t;
   subtype fsid_t is bits.types.fsid_t;
   subtype loff_t is bits.types.loff_t;
   subtype ino_t is bits.types.ino_t;
   subtype dev_t is bits.types.dev_t;
   subtype gid_t is bits.types.gid_t;
   subtype mode_t is bits.types.mode_t;
   subtype nlink_t is bits.types.nlink_t;
   subtype uid_t is bits.types.uid_t;
   subtype off_t is bits.types.off_t;
   subtype pid_t is bits.types.pid_t;
   subtype id_t is bits.types.id_t;
   subtype ssize_t is bits.types.ssize_t;
   subtype daddr_t is bits.types.daddr_t;
   subtype caddr_t is bits.types.caddr_t;
   subtype key_t is bits.types.key_t;
   --  #include <time.h>
   subtype ulong is unsigned_long;
   subtype ushort is unsigned_short;
   subtype uint is unsigned_int;
   subtype int8_t is signed_char;
   subtype int16_t is signed_short;
   subtype int32_t is signed_int;
   subtype int32_t_ptr is signed_int_ptr;
   subtype int64_t is signed_long;
   subtype u_int8_t is unsigned_char;
   subtype u_int16_t is unsigned_short;
   subtype u_int32_t is unsigned_int;
   subtype u_int64_t is unsigned_long;
   subtype register_t is signed_long;
   --  #include <bits/byteswap.h>
   --  #include <bits/sigset.h>
   --  #include <time.h>
   --  #include <bits/time.h>
   --  #include <sys/select.h>
   --  #include <sys/sysmacros.h>
   subtype blksize_t is bits.types.blksize_t;
   subtype blkcnt_t is bits.types.blkcnt_t;
   subtype fsblkcnt_t is bits.types.fsblkcnt_t;
   subtype fsfilcnt_t is bits.types.fsfilcnt_t;
   SYS_TYPES_H : constant := 1;
   qqBIT_TYPES_DEFINEDqq : constant := 1;
   --  __blkcnt_t_defined (empty)
   --  __blksize_t_defined (empty)
   --  __daddr_t_defined (empty)
   --  __dev_t_defined (empty)
   --  __fsblkcnt_t_defined (empty)
   --  __fsfilcnt_t_defined (empty)
   --  __gid_t_defined (empty)
   --  __id_t_defined (empty)
   --  __ino_t_defined (empty)
   --  __int8_t_defined (empty)
   --  __intN_t (has # or ##)
   --  __key_t_defined (empty)
   --  __mode_t_defined (empty)
   --  __need_clockid_t (empty)
   --  __nlink_t_defined (empty)
   --  __off_t_defined (empty)
   --  __pid_t_defined (empty)
   --  __ssize_t_defined (empty)
   --  __u_char_defined (empty)
   --  __u_intN_t (has # or ##)
   --  __uid_t_defined (empty)
end C.sys.types;

c-sys.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.sys is
   pragma Preelaborate;
end C.sys;

c-time.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.bits.types;
package C.time is
   pragma Preelaborate;
   subtype clock_t is bits.types.qqclock_t;
   subtype time_t is bits.types.qqtime_t;
   subtype clockid_t is bits.types.qqclockid_t;
   subtype timer_t is bits.types.qqtimer_t;
   --  #include <sys/types.h>
   --  #include <bits/byteswap.h>
   --  #include <bits/sigset.h>
   --  #include <sys/select.h>
   type struct_timespec;
   type struct_timespec is record
      tv_sec : aliased bits.types.qqtime_t;
      tv_nsec : aliased bits.types.syscall_slong_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_timespec);
   type struct_timespec_const_ptr is access constant struct_timespec;
   for struct_timespec_const_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_timespec_const_ptr);
   pragma Convention (C, struct_timespec_const_ptr);
   clock_t_defined : constant := 1;
   clockid_t_defined : constant := 1;
   time_t_defined : constant := 1;
   timer_t_defined : constant := 1;
   timespec_defined : constant := 1;
end C.time;

c-wchar.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.wchar is
   pragma Preelaborate;
   type union_47e5c904 (Unchecked_Tag : unsigned_int := 0) is record
      case Unchecked_Tag is
         when 0 =>
            wch : unsigned_int;
         when others =>
            wchb : char_array (0 .. 3);
      end case;
   end record;
   pragma Unchecked_Union (union_47e5c904);
   pragma Convention (C_Pass_By_Copy, union_47e5c904);
   type struct_2acbcca7 is record
      count : aliased signed_int;
      value : aliased union_47e5c904;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_2acbcca7);
   subtype mbstate_t is struct_2acbcca7;
   mbstate_t_defined : constant := 1;
end C.wchar;

c-xlocale.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.xlocale is
   pragma Preelaborate;
   type struct_locale_struct;
   type struct_locale_data (<>) is limited private;
   type struct_locale_data_ptr is access all struct_locale_data;
   for struct_locale_data_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_locale_data_ptr);
   pragma Convention (C, struct_locale_data_ptr);
   type struct_locale_data_ptr_array is array (size_t range <>) of
      aliased struct_locale_data_ptr;
   pragma Convention (C, struct_locale_data_ptr_array);
   type struct_locale_struct is record
      locales : aliased struct_locale_data_ptr_array (0 .. 12);
      ctype_b : aliased unsigned_short_const_ptr;
      ctype_tolower : aliased signed_int_const_ptr;
      ctype_toupper : aliased signed_int_const_ptr;
      names : aliased char_const_ptr_array (0 .. 12);
   end record;
   pragma Convention (C_Pass_By_Copy, struct_locale_struct);
   type struct_locale_struct_ptr is access all struct_locale_struct;
   for struct_locale_struct_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_locale_struct_ptr);
   pragma Convention (C, struct_locale_struct_ptr);
   subtype qqlocale_t is struct_locale_struct_ptr;
   subtype locale_t is qqlocale_t;
   XLOCALE_H : constant := 1;
private
   type struct_locale_data is null record;
end C.xlocale;

c-yaml.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.stddef;
with C.stdio;
package C.yaml is
   pragma Preelaborate;
   function yaml_get_version_string return char_const_ptr;
   pragma Import (C, yaml_get_version_string, "yaml_get_version_string");
   procedure yaml_get_version (major : access signed_int;
      minor : access signed_int; patch : access signed_int);
   pragma Import (C, yaml_get_version, "yaml_get_version");
   subtype yaml_char_t is unsigned_char;
   subtype yaml_char_t_ptr is unsigned_char_ptr;
   type struct_yaml_version_directive_s;
   type struct_yaml_version_directive_s is record
      major : aliased signed_int;
      minor : aliased signed_int;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_yaml_version_directive_s);
   type struct_yaml_version_directive_s_ptr is
      access all struct_yaml_version_directive_s;
   for struct_yaml_version_directive_s_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_yaml_version_directive_s_ptr);
   pragma Convention (C, struct_yaml_version_directive_s_ptr);
   subtype yaml_version_directive_t is struct_yaml_version_directive_s;
   subtype yaml_version_directive_t_ptr is
      struct_yaml_version_directive_s_ptr;
   type struct_yaml_tag_directive_s;
   type struct_yaml_tag_directive_s is record
      handle : aliased yaml_char_t_ptr;
      prefix : aliased yaml_char_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_yaml_tag_directive_s);
   type struct_yaml_tag_directive_s_ptr is
      access all struct_yaml_tag_directive_s;
   for struct_yaml_tag_directive_s_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_yaml_tag_directive_s_ptr);
   pragma Convention (C, struct_yaml_tag_directive_s_ptr);
   subtype yaml_tag_directive_t is struct_yaml_tag_directive_s;
   subtype yaml_tag_directive_t_ptr is struct_yaml_tag_directive_s_ptr;
   type enum_yaml_encoding_e;
   type enum_yaml_encoding_e is (YAML_ANY_ENCODING, YAML_UTF8_ENCODING,
      YAML_UTF16LE_ENCODING, YAML_UTF16BE_ENCODING);
   for enum_yaml_encoding_e use (YAML_ANY_ENCODING => 0,
      YAML_UTF8_ENCODING => 1, YAML_UTF16LE_ENCODING => 2,
      YAML_UTF16BE_ENCODING => 3);
   pragma Convention (C, enum_yaml_encoding_e);
   subtype yaml_encoding_t is enum_yaml_encoding_e;
   type enum_yaml_break_e;
   type enum_yaml_break_e is (YAML_ANY_BREAK, YAML_CR_BREAK, YAML_LN_BREAK,
      YAML_CRLN_BREAK);
   for enum_yaml_break_e use (YAML_ANY_BREAK => 0, YAML_CR_BREAK => 1,
      YAML_LN_BREAK => 2, YAML_CRLN_BREAK => 3);
   pragma Convention (C, enum_yaml_break_e);
   subtype yaml_break_t is enum_yaml_break_e;
   type enum_yaml_error_type_e;
   type enum_yaml_error_type_e is (YAML_NO_ERROR, YAML_MEMORY_ERROR,
      YAML_READER_ERROR, YAML_SCANNER_ERROR, YAML_PARSER_ERROR,
      YAML_COMPOSER_ERROR, YAML_WRITER_ERROR, YAML_EMITTER_ERROR);
   for enum_yaml_error_type_e use (YAML_NO_ERROR => 0,
      YAML_MEMORY_ERROR => 1, YAML_READER_ERROR => 2,
      YAML_SCANNER_ERROR => 3, YAML_PARSER_ERROR => 4,
      YAML_COMPOSER_ERROR => 5, YAML_WRITER_ERROR => 6,
      YAML_EMITTER_ERROR => 7);
   pragma Convention (C, enum_yaml_error_type_e);
   subtype yaml_error_type_t is enum_yaml_error_type_e;
   type struct_yaml_mark_s;
   type struct_yaml_mark_s is record
      index : aliased stddef.size_t;
      line : aliased stddef.size_t;
      column : aliased stddef.size_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_yaml_mark_s);
   type struct_yaml_mark_s_ptr is access all struct_yaml_mark_s;
   for struct_yaml_mark_s_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_yaml_mark_s_ptr);
   pragma Convention (C, struct_yaml_mark_s_ptr);
   subtype yaml_mark_t is struct_yaml_mark_s;
   subtype yaml_mark_t_ptr is struct_yaml_mark_s_ptr;
   type enum_yaml_scalar_style_e;
   type enum_yaml_scalar_style_e is (YAML_ANY_SCALAR_STYLE,
      YAML_PLAIN_SCALAR_STYLE, YAML_SINGLE_QUOTED_SCALAR_STYLE,
      YAML_DOUBLE_QUOTED_SCALAR_STYLE, YAML_LITERAL_SCALAR_STYLE,
      YAML_FOLDED_SCALAR_STYLE);
   for enum_yaml_scalar_style_e use (YAML_ANY_SCALAR_STYLE => 0,
      YAML_PLAIN_SCALAR_STYLE => 1, YAML_SINGLE_QUOTED_SCALAR_STYLE => 2,
      YAML_DOUBLE_QUOTED_SCALAR_STYLE => 3, YAML_LITERAL_SCALAR_STYLE => 4,
      YAML_FOLDED_SCALAR_STYLE => 5);
   pragma Convention (C, enum_yaml_scalar_style_e);
   subtype yaml_scalar_style_t is enum_yaml_scalar_style_e;
   type enum_yaml_sequence_style_e;
   type enum_yaml_sequence_style_e is (YAML_ANY_SEQUENCE_STYLE,
      YAML_BLOCK_SEQUENCE_STYLE, YAML_FLOW_SEQUENCE_STYLE);
   for enum_yaml_sequence_style_e use (YAML_ANY_SEQUENCE_STYLE => 0,
      YAML_BLOCK_SEQUENCE_STYLE => 1, YAML_FLOW_SEQUENCE_STYLE => 2);
   pragma Convention (C, enum_yaml_sequence_style_e);
   subtype yaml_sequence_style_t is enum_yaml_sequence_style_e;
   type enum_yaml_mapping_style_e;
   type enum_yaml_mapping_style_e is (YAML_ANY_MAPPING_STYLE,
      YAML_BLOCK_MAPPING_STYLE, YAML_FLOW_MAPPING_STYLE);
   for enum_yaml_mapping_style_e use (YAML_ANY_MAPPING_STYLE => 0,
      YAML_BLOCK_MAPPING_STYLE => 1, YAML_FLOW_MAPPING_STYLE => 2);
   pragma Convention (C, enum_yaml_mapping_style_e);
   subtype yaml_mapping_style_t is enum_yaml_mapping_style_e;
   type enum_yaml_token_type_e;
   type enum_yaml_token_type_e is (YAML_NO_TOKEN, YAML_STREAM_START_TOKEN,
      YAML_STREAM_END_TOKEN, YAML_VERSION_DIRECTIVE_TOKEN,
      YAML_TAG_DIRECTIVE_TOKEN, YAML_DOCUMENT_START_TOKEN,
      YAML_DOCUMENT_END_TOKEN, YAML_BLOCK_SEQUENCE_START_TOKEN,
      YAML_BLOCK_MAPPING_START_TOKEN, YAML_BLOCK_END_TOKEN,
      YAML_FLOW_SEQUENCE_START_TOKEN, YAML_FLOW_SEQUENCE_END_TOKEN,
      YAML_FLOW_MAPPING_START_TOKEN, YAML_FLOW_MAPPING_END_TOKEN,
      YAML_BLOCK_ENTRY_TOKEN, YAML_FLOW_ENTRY_TOKEN, YAML_KEY_TOKEN,
      YAML_VALUE_TOKEN, YAML_ALIAS_TOKEN, YAML_ANCHOR_TOKEN, YAML_TAG_TOKEN,
      YAML_SCALAR_TOKEN);
   for enum_yaml_token_type_e use (YAML_NO_TOKEN => 0,
      YAML_STREAM_START_TOKEN => 1, YAML_STREAM_END_TOKEN => 2,
      YAML_VERSION_DIRECTIVE_TOKEN => 3, YAML_TAG_DIRECTIVE_TOKEN => 4,
      YAML_DOCUMENT_START_TOKEN => 5, YAML_DOCUMENT_END_TOKEN => 6,
      YAML_BLOCK_SEQUENCE_START_TOKEN => 7,
      YAML_BLOCK_MAPPING_START_TOKEN => 8, YAML_BLOCK_END_TOKEN => 9,
      YAML_FLOW_SEQUENCE_START_TOKEN => 10,
      YAML_FLOW_SEQUENCE_END_TOKEN => 11,
      YAML_FLOW_MAPPING_START_TOKEN => 12, YAML_FLOW_MAPPING_END_TOKEN => 13,
      YAML_BLOCK_ENTRY_TOKEN => 14, YAML_FLOW_ENTRY_TOKEN => 15,
      YAML_KEY_TOKEN => 16, YAML_VALUE_TOKEN => 17, YAML_ALIAS_TOKEN => 18,
      YAML_ANCHOR_TOKEN => 19, YAML_TAG_TOKEN => 20,
      YAML_SCALAR_TOKEN => 21);
   pragma Convention (C, enum_yaml_token_type_e);
   subtype yaml_token_type_t is enum_yaml_token_type_e;
   type struct_yaml_token_s;
   type struct_f47f45c1 is record
      encoding : aliased yaml_encoding_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_f47f45c1);
   type struct_27abe35f is record
      value : aliased yaml_char_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_27abe35f);
   type struct_ef4636b2 is record
      value : aliased yaml_char_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_ef4636b2);
   type struct_b79acd91 is record
      handle : aliased yaml_char_t_ptr;
      suffix : aliased yaml_char_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_b79acd91);
   type struct_8c47665f is record
      value : aliased yaml_char_t_ptr;
      length : aliased stddef.size_t;
      style : aliased yaml_scalar_style_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_8c47665f);
   type struct_770ff656 is record
      major : aliased signed_int;
      minor : aliased signed_int;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_770ff656);
   type struct_f3bc36bb is record
      handle : aliased yaml_char_t_ptr;
      prefix : aliased yaml_char_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_f3bc36bb);
   type union_e720527d (Unchecked_Tag : unsigned_int := 0) is record
      case Unchecked_Tag is
         when 0 =>
            stream_start : struct_f47f45c1;
         when 1 =>
            alias : struct_27abe35f;
         when 2 =>
            anchor : struct_ef4636b2;
         when 3 =>
            tag : struct_b79acd91;
         when 4 =>
            scalar : struct_8c47665f;
         when 5 =>
            version_directive : struct_770ff656;
         when others =>
            tag_directive : struct_f3bc36bb;
      end case;
   end record;
   pragma Unchecked_Union (union_e720527d);
   pragma Convention (C_Pass_By_Copy, union_e720527d);
   type struct_yaml_token_s is record
      F_type : aliased yaml_token_type_t;
      data : aliased union_e720527d;
      start_mark : aliased yaml_mark_t;
      end_mark : aliased yaml_mark_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_yaml_token_s);
   type struct_yaml_token_s_ptr is access all struct_yaml_token_s;
   for struct_yaml_token_s_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_yaml_token_s_ptr);
   pragma Convention (C, struct_yaml_token_s_ptr);
   subtype yaml_token_t is struct_yaml_token_s;
   subtype yaml_token_t_ptr is struct_yaml_token_s_ptr;
   procedure yaml_token_delete (token : access yaml_token_t);
   pragma Import (C, yaml_token_delete, "yaml_token_delete");
   type enum_yaml_event_type_e;
   type enum_yaml_event_type_e is (YAML_NO_EVENT, YAML_STREAM_START_EVENT,
      YAML_STREAM_END_EVENT, YAML_DOCUMENT_START_EVENT,
      YAML_DOCUMENT_END_EVENT, YAML_ALIAS_EVENT, YAML_SCALAR_EVENT,
      YAML_SEQUENCE_START_EVENT, YAML_SEQUENCE_END_EVENT,
      YAML_MAPPING_START_EVENT, YAML_MAPPING_END_EVENT);
   for enum_yaml_event_type_e use (YAML_NO_EVENT => 0,
      YAML_STREAM_START_EVENT => 1, YAML_STREAM_END_EVENT => 2,
      YAML_DOCUMENT_START_EVENT => 3, YAML_DOCUMENT_END_EVENT => 4,
      YAML_ALIAS_EVENT => 5, YAML_SCALAR_EVENT => 6,
      YAML_SEQUENCE_START_EVENT => 7, YAML_SEQUENCE_END_EVENT => 8,
      YAML_MAPPING_START_EVENT => 9, YAML_MAPPING_END_EVENT => 10);
   pragma Convention (C, enum_yaml_event_type_e);
   subtype yaml_event_type_t is enum_yaml_event_type_e;
   type struct_yaml_event_s;
   type struct_fb571ff1 is record
      encoding : aliased yaml_encoding_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_fb571ff1);
   type struct_93322409 is record
      start : aliased yaml_tag_directive_t_ptr;
      F_end : aliased yaml_tag_directive_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_93322409);
   type struct_456a074d is record
      version_directive : aliased yaml_version_directive_t_ptr;
      tag_directives : aliased struct_93322409;
      implicit : aliased signed_int;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_456a074d);
   type struct_8130e4fa is record
      implicit : aliased signed_int;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_8130e4fa);
   type struct_a3308964 is record
      anchor : aliased yaml_char_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_a3308964);
   type struct_2f7fd6a1 is record
      anchor : aliased yaml_char_t_ptr;
      tag : aliased yaml_char_t_ptr;
      value : aliased yaml_char_t_ptr;
      length : aliased stddef.size_t;
      plain_implicit : aliased signed_int;
      quoted_implicit : aliased signed_int;
      style : aliased yaml_scalar_style_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_2f7fd6a1);
   type struct_a619e610 is record
      anchor : aliased yaml_char_t_ptr;
      tag : aliased yaml_char_t_ptr;
      implicit : aliased signed_int;
      style : aliased yaml_sequence_style_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_a619e610);
   type struct_479e518a is record
      anchor : aliased yaml_char_t_ptr;
      tag : aliased yaml_char_t_ptr;
      implicit : aliased signed_int;
      style : aliased yaml_mapping_style_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_479e518a);
   type union_dc65d82c (Unchecked_Tag : unsigned_int := 0) is record
      case Unchecked_Tag is
         when 0 =>
            stream_start : struct_fb571ff1;
         when 1 =>
            document_start : struct_456a074d;
         when 2 =>
            document_end : struct_8130e4fa;
         when 3 =>
            alias : struct_a3308964;
         when 4 =>
            scalar : struct_2f7fd6a1;
         when 5 =>
            sequence_start : struct_a619e610;
         when others =>
            mapping_start : struct_479e518a;
      end case;
   end record;
   pragma Unchecked_Union (union_dc65d82c);
   pragma Convention (C_Pass_By_Copy, union_dc65d82c);
   type struct_yaml_event_s is record
      F_type : aliased yaml_event_type_t;
      data : aliased union_dc65d82c;
      start_mark : aliased yaml_mark_t;
      end_mark : aliased yaml_mark_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_yaml_event_s);
   type struct_yaml_event_s_ptr is access all struct_yaml_event_s;
   for struct_yaml_event_s_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_yaml_event_s_ptr);
   pragma Convention (C, struct_yaml_event_s_ptr);
   subtype yaml_event_t is struct_yaml_event_s;
   subtype yaml_event_t_ptr is struct_yaml_event_s_ptr;
   function yaml_stream_start_event_initialize (event : access yaml_event_t;
      encoding : yaml_encoding_t) return signed_int;
   pragma Import (C, yaml_stream_start_event_initialize,
      "yaml_stream_start_event_initialize");
   function yaml_stream_end_event_initialize (event : access yaml_event_t)
      return signed_int;
   pragma Import (C, yaml_stream_end_event_initialize,
      "yaml_stream_end_event_initialize");
   function yaml_document_start_event_initialize (
      event : access yaml_event_t;
      version_directive : access yaml_version_directive_t;
      tag_directives_start : access yaml_tag_directive_t;
      tag_directives_end : access yaml_tag_directive_t;
      implicit : signed_int) return signed_int;
   pragma Import (C, yaml_document_start_event_initialize,
      "yaml_document_start_event_initialize");
   function yaml_document_end_event_initialize (event : access yaml_event_t;
      implicit : signed_int) return signed_int;
   pragma Import (C, yaml_document_end_event_initialize,
      "yaml_document_end_event_initialize");
   function yaml_alias_event_initialize (event : access yaml_event_t;
      anchor : access yaml_char_t) return signed_int;
   pragma Import (C, yaml_alias_event_initialize,
      "yaml_alias_event_initialize");
   function yaml_scalar_event_initialize (event : access yaml_event_t;
      anchor : access yaml_char_t; tag : access yaml_char_t;
      value : access yaml_char_t; length : signed_int;
      plain_implicit : signed_int; quoted_implicit : signed_int;
      style : yaml_scalar_style_t) return signed_int;
   pragma Import (C, yaml_scalar_event_initialize,
      "yaml_scalar_event_initialize");
   function yaml_sequence_start_event_initialize (
      event : access yaml_event_t; anchor : access yaml_char_t;
      tag : access yaml_char_t; implicit : signed_int;
      style : yaml_sequence_style_t) return signed_int;
   pragma Import (C, yaml_sequence_start_event_initialize,
      "yaml_sequence_start_event_initialize");
   function yaml_sequence_end_event_initialize (event : access yaml_event_t)
      return signed_int;
   pragma Import (C, yaml_sequence_end_event_initialize,
      "yaml_sequence_end_event_initialize");
   function yaml_mapping_start_event_initialize (event : access yaml_event_t;
      anchor : access yaml_char_t; tag : access yaml_char_t;
      implicit : signed_int; style : yaml_mapping_style_t) return signed_int;
   pragma Import (C, yaml_mapping_start_event_initialize,
      "yaml_mapping_start_event_initialize");
   function yaml_mapping_end_event_initialize (event : access yaml_event_t)
      return signed_int;
   pragma Import (C, yaml_mapping_end_event_initialize,
      "yaml_mapping_end_event_initialize");
   procedure yaml_event_delete (event : access yaml_event_t);
   pragma Import (C, yaml_event_delete, "yaml_event_delete");
   type enum_yaml_node_type_e;
   type enum_yaml_node_type_e is (YAML_NO_NODE, YAML_SCALAR_NODE,
      YAML_SEQUENCE_NODE, YAML_MAPPING_NODE);
   for enum_yaml_node_type_e use (YAML_NO_NODE => 0, YAML_SCALAR_NODE => 1,
      YAML_SEQUENCE_NODE => 2, YAML_MAPPING_NODE => 3);
   pragma Convention (C, enum_yaml_node_type_e);
   subtype yaml_node_type_t is enum_yaml_node_type_e;
   type struct_yaml_node_s;
   type struct_yaml_node_s_ptr is access all struct_yaml_node_s;
   for struct_yaml_node_s_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_yaml_node_s_ptr);
   pragma Convention (C, struct_yaml_node_s_ptr);
   subtype yaml_node_t is struct_yaml_node_s;
   subtype yaml_node_t_ptr is struct_yaml_node_s_ptr;
   subtype yaml_node_item_t is signed_int;
   subtype yaml_node_item_t_ptr is signed_int_ptr;
   type struct_yaml_node_pair_s;
   type struct_yaml_node_pair_s is record
      key : aliased signed_int;
      value : aliased signed_int;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_yaml_node_pair_s);
   type struct_yaml_node_pair_s_ptr is access all struct_yaml_node_pair_s;
   for struct_yaml_node_pair_s_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_yaml_node_pair_s_ptr);
   pragma Convention (C, struct_yaml_node_pair_s_ptr);
   subtype yaml_node_pair_t is struct_yaml_node_pair_s;
   subtype yaml_node_pair_t_ptr is struct_yaml_node_pair_s_ptr;
   type struct_bb39eb73 is record
      value : aliased yaml_char_t_ptr;
      length : aliased stddef.size_t;
      style : aliased yaml_scalar_style_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_bb39eb73);
   type struct_c0b4d5bc is record
      start : aliased yaml_node_item_t_ptr;
      F_end : aliased yaml_node_item_t_ptr;
      top : aliased yaml_node_item_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_c0b4d5bc);
   type struct_1e8f6069 is record
      items : aliased struct_c0b4d5bc;
      style : aliased yaml_sequence_style_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_1e8f6069);
   type struct_27ff5809 is record
      start : aliased yaml_node_pair_t_ptr;
      F_end : aliased yaml_node_pair_t_ptr;
      top : aliased yaml_node_pair_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_27ff5809);
   type struct_9fa6cf60 is record
      pairs : aliased struct_27ff5809;
      style : aliased yaml_mapping_style_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_9fa6cf60);
   type union_425eda57 (Unchecked_Tag : unsigned_int := 0) is record
      case Unchecked_Tag is
         when 0 =>
            scalar : struct_bb39eb73;
         when 1 =>
            sequence : struct_1e8f6069;
         when others =>
            mapping : struct_9fa6cf60;
      end case;
   end record;
   pragma Unchecked_Union (union_425eda57);
   pragma Convention (C_Pass_By_Copy, union_425eda57);
   type struct_yaml_node_s is record
      F_type : aliased yaml_node_type_t;
      tag : aliased yaml_char_t_ptr;
      data : aliased union_425eda57;
      start_mark : aliased yaml_mark_t;
      end_mark : aliased yaml_mark_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_yaml_node_s);
   type struct_yaml_document_s;
   type struct_8a11321e is record
      start : aliased yaml_node_t_ptr;
      F_end : aliased yaml_node_t_ptr;
      top : aliased yaml_node_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_8a11321e);
   type struct_bfefd048 is record
      start : aliased yaml_tag_directive_t_ptr;
      F_end : aliased yaml_tag_directive_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_bfefd048);
   type struct_yaml_document_s is record
      nodes : aliased struct_8a11321e;
      version_directive : aliased yaml_version_directive_t_ptr;
      tag_directives : aliased struct_bfefd048;
      start_implicit : aliased signed_int;
      end_implicit : aliased signed_int;
      start_mark : aliased yaml_mark_t;
      end_mark : aliased yaml_mark_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_yaml_document_s);
   type struct_yaml_document_s_ptr is access all struct_yaml_document_s;
   for struct_yaml_document_s_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_yaml_document_s_ptr);
   pragma Convention (C, struct_yaml_document_s_ptr);
   subtype yaml_document_t is struct_yaml_document_s;
   subtype yaml_document_t_ptr is struct_yaml_document_s_ptr;
   function yaml_document_initialize (document : access yaml_document_t;
      version_directive : access yaml_version_directive_t;
      tag_directives_start : access yaml_tag_directive_t;
      tag_directives_end : access yaml_tag_directive_t;
      start_implicit : signed_int; end_implicit : signed_int)
      return signed_int;
   pragma Import (C, yaml_document_initialize, "yaml_document_initialize");
   procedure yaml_document_delete (document : access yaml_document_t);
   pragma Import (C, yaml_document_delete, "yaml_document_delete");
   function yaml_document_get_node (document : access yaml_document_t;
      index : signed_int) return yaml_node_t_ptr;
   pragma Import (C, yaml_document_get_node, "yaml_document_get_node");
   function yaml_document_get_root_node (document : access yaml_document_t)
      return yaml_node_t_ptr;
   pragma Import (C, yaml_document_get_root_node,
      "yaml_document_get_root_node");
   function yaml_document_add_scalar (document : access yaml_document_t;
      tag : access yaml_char_t; value : access yaml_char_t;
      length : signed_int; style : yaml_scalar_style_t) return signed_int;
   pragma Import (C, yaml_document_add_scalar, "yaml_document_add_scalar");
   function yaml_document_add_sequence (document : access yaml_document_t;
      tag : access yaml_char_t; style : yaml_sequence_style_t)
      return signed_int;
   pragma Import (C, yaml_document_add_sequence,
      "yaml_document_add_sequence");
   function yaml_document_add_mapping (document : access yaml_document_t;
      tag : access yaml_char_t; style : yaml_mapping_style_t)
      return signed_int;
   pragma Import (C, yaml_document_add_mapping, "yaml_document_add_mapping");
   function yaml_document_append_sequence_item (
      document : access yaml_document_t; sequence : signed_int;
      item : signed_int) return signed_int;
   pragma Import (C, yaml_document_append_sequence_item,
      "yaml_document_append_sequence_item");
   function yaml_document_append_mapping_pair (
      document : access yaml_document_t; mapping : signed_int;
      key : signed_int; value : signed_int) return signed_int;
   pragma Import (C, yaml_document_append_mapping_pair,
      "yaml_document_append_mapping_pair");
   type access_a190acaa is access function (data : void_ptr;
      buffer : access unsigned_char; size : stddef.size_t;
      size_read : access stddef.size_t) return signed_int;
   pragma Convention (C, access_a190acaa);
   --  subtype yaml_read_handler_t is ... (function type)
   subtype yaml_read_handler_t_ptr is access_a190acaa;
   type struct_yaml_simple_key_s;
   type struct_yaml_simple_key_s is record
      possible : aliased signed_int;
      required : aliased signed_int;
      token_number : aliased stddef.size_t;
      mark : aliased yaml_mark_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_yaml_simple_key_s);
   type struct_yaml_simple_key_s_ptr is access all struct_yaml_simple_key_s;
   for struct_yaml_simple_key_s_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_yaml_simple_key_s_ptr);
   pragma Convention (C, struct_yaml_simple_key_s_ptr);
   subtype yaml_simple_key_t is struct_yaml_simple_key_s;
   subtype yaml_simple_key_t_ptr is struct_yaml_simple_key_s_ptr;
   type enum_yaml_parser_state_e;
   type enum_yaml_parser_state_e is (YAML_PARSE_STREAM_START_STATE,
      YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE,
      YAML_PARSE_DOCUMENT_START_STATE, YAML_PARSE_DOCUMENT_CONTENT_STATE,
      YAML_PARSE_DOCUMENT_END_STATE, YAML_PARSE_BLOCK_NODE_STATE,
      YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE,
      YAML_PARSE_FLOW_NODE_STATE,
      YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE,
      YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE,
      YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE,
      YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE,
      YAML_PARSE_BLOCK_MAPPING_KEY_STATE,
      YAML_PARSE_BLOCK_MAPPING_VALUE_STATE,
      YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE,
      YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE,
      YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE,
      YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE,
      YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE,
      YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE,
      YAML_PARSE_FLOW_MAPPING_KEY_STATE, YAML_PARSE_FLOW_MAPPING_VALUE_STATE,
      YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE, YAML_PARSE_END_STATE);
   for enum_yaml_parser_state_e use (YAML_PARSE_STREAM_START_STATE => 0,
      YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE => 1,
      YAML_PARSE_DOCUMENT_START_STATE => 2,
      YAML_PARSE_DOCUMENT_CONTENT_STATE => 3,
      YAML_PARSE_DOCUMENT_END_STATE => 4, YAML_PARSE_BLOCK_NODE_STATE => 5,
      YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE => 6,
      YAML_PARSE_FLOW_NODE_STATE => 7,
      YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE => 8,
      YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE => 9,
      YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE => 10,
      YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE => 11,
      YAML_PARSE_BLOCK_MAPPING_KEY_STATE => 12,
      YAML_PARSE_BLOCK_MAPPING_VALUE_STATE => 13,
      YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE => 14,
      YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE => 15,
      YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE => 16,
      YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE => 17,
      YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE => 18,
      YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE => 19,
      YAML_PARSE_FLOW_MAPPING_KEY_STATE => 20,
      YAML_PARSE_FLOW_MAPPING_VALUE_STATE => 21,
      YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE => 22,
      YAML_PARSE_END_STATE => 23);
   pragma Convention (C, enum_yaml_parser_state_e);
   type enum_yaml_parser_state_e_ptr is access all enum_yaml_parser_state_e;
   for enum_yaml_parser_state_e_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (enum_yaml_parser_state_e_ptr);
   pragma Convention (C, enum_yaml_parser_state_e_ptr);
   subtype yaml_parser_state_t is enum_yaml_parser_state_e;
   subtype yaml_parser_state_t_ptr is enum_yaml_parser_state_e_ptr;
   type struct_yaml_alias_data_s;
   type struct_yaml_alias_data_s is record
      anchor : aliased yaml_char_t_ptr;
      index : aliased signed_int;
      mark : aliased yaml_mark_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_yaml_alias_data_s);
   type struct_yaml_alias_data_s_ptr is access all struct_yaml_alias_data_s;
   for struct_yaml_alias_data_s_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_yaml_alias_data_s_ptr);
   pragma Convention (C, struct_yaml_alias_data_s_ptr);
   subtype yaml_alias_data_t is struct_yaml_alias_data_s;
   subtype yaml_alias_data_t_ptr is struct_yaml_alias_data_s_ptr;
   type struct_yaml_parser_s;
   type struct_6fb23e33 is record
      start : aliased unsigned_char_const_ptr;
      F_end : aliased unsigned_char_const_ptr;
      current : aliased unsigned_char_const_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_6fb23e33);
   type union_0206ae30 (Unchecked_Tag : unsigned_int := 0) is record
      case Unchecked_Tag is
         when 0 =>
            string : struct_6fb23e33;
         when others =>
            file : stdio.FILE_ptr;
      end case;
   end record;
   pragma Unchecked_Union (union_0206ae30);
   pragma Convention (C_Pass_By_Copy, union_0206ae30);
   type struct_c1bbaff3 is record
      start : aliased yaml_char_t_ptr;
      F_end : aliased yaml_char_t_ptr;
      pointer : aliased yaml_char_t_ptr;
      last : aliased yaml_char_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_c1bbaff3);
   type struct_49a60013 is record
      start : aliased unsigned_char_ptr;
      F_end : aliased unsigned_char_ptr;
      pointer : aliased unsigned_char_ptr;
      last : aliased unsigned_char_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_49a60013);
   type struct_28c7a211 is record
      start : aliased yaml_token_t_ptr;
      F_end : aliased yaml_token_t_ptr;
      head : aliased yaml_token_t_ptr;
      tail : aliased yaml_token_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_28c7a211);
   type struct_80631006 is record
      start : aliased signed_int_ptr;
      F_end : aliased signed_int_ptr;
      top : aliased signed_int_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_80631006);
   type struct_0cb2899a is record
      start : aliased yaml_simple_key_t_ptr;
      F_end : aliased yaml_simple_key_t_ptr;
      top : aliased yaml_simple_key_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_0cb2899a);
   type struct_f4d68d71 is record
      start : aliased yaml_parser_state_t_ptr;
      F_end : aliased yaml_parser_state_t_ptr;
      top : aliased yaml_parser_state_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_f4d68d71);
   type struct_b103af9f is record
      start : aliased yaml_mark_t_ptr;
      F_end : aliased yaml_mark_t_ptr;
      top : aliased yaml_mark_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_b103af9f);
   type struct_7af2cfb2 is record
      start : aliased yaml_tag_directive_t_ptr;
      F_end : aliased yaml_tag_directive_t_ptr;
      top : aliased yaml_tag_directive_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_7af2cfb2);
   type struct_6a9a0745 is record
      start : aliased yaml_alias_data_t_ptr;
      F_end : aliased yaml_alias_data_t_ptr;
      top : aliased yaml_alias_data_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_6a9a0745);
   type struct_yaml_parser_s is record
      error : aliased yaml_error_type_t;
      problem : aliased char_const_ptr;
      problem_offset : aliased stddef.size_t;
      problem_value : aliased signed_int;
      problem_mark : aliased yaml_mark_t;
      context : aliased char_const_ptr;
      context_mark : aliased yaml_mark_t;
      read_handler : aliased yaml_read_handler_t_ptr;
      read_handler_data : aliased void_ptr;
      input : aliased union_0206ae30;
      eof : aliased signed_int;
      buffer : aliased struct_c1bbaff3;
      unread : aliased stddef.size_t;
      raw_buffer : aliased struct_49a60013;
      encoding : aliased yaml_encoding_t;
      offset : aliased stddef.size_t;
      mark : aliased yaml_mark_t;
      stream_start_produced : aliased signed_int;
      stream_end_produced : aliased signed_int;
      flow_level : aliased signed_int;
      tokens : aliased struct_28c7a211;
      tokens_parsed : aliased stddef.size_t;
      token_available : aliased signed_int;
      indents : aliased struct_80631006;
      indent : aliased signed_int;
      simple_key_allowed : aliased signed_int;
      simple_keys : aliased struct_0cb2899a;
      states : aliased struct_f4d68d71;
      state : aliased yaml_parser_state_t;
      marks : aliased struct_b103af9f;
      tag_directives : aliased struct_7af2cfb2;
      aliases : aliased struct_6a9a0745;
      document : aliased yaml_document_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_yaml_parser_s);
   type struct_yaml_parser_s_ptr is access all struct_yaml_parser_s;
   for struct_yaml_parser_s_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_yaml_parser_s_ptr);
   pragma Convention (C, struct_yaml_parser_s_ptr);
   subtype yaml_parser_t is struct_yaml_parser_s;
   subtype yaml_parser_t_ptr is struct_yaml_parser_s_ptr;
   function yaml_parser_initialize (parser : access yaml_parser_t)
      return signed_int;
   pragma Import (C, yaml_parser_initialize, "yaml_parser_initialize");
   procedure yaml_parser_delete (parser : access yaml_parser_t);
   pragma Import (C, yaml_parser_delete, "yaml_parser_delete");
   procedure yaml_parser_set_input_string (parser : access yaml_parser_t;
      input : access constant unsigned_char; size : stddef.size_t);
   pragma Import (C, yaml_parser_set_input_string,
      "yaml_parser_set_input_string");
   procedure yaml_parser_set_input_file (parser : access yaml_parser_t;
      file : access stdio.FILE);
   pragma Import (C, yaml_parser_set_input_file,
      "yaml_parser_set_input_file");
   procedure yaml_parser_set_input (parser : access yaml_parser_t;
      handler : yaml_read_handler_t_ptr; data : void_ptr);
   pragma Import (C, yaml_parser_set_input, "yaml_parser_set_input");
   procedure yaml_parser_set_encoding (parser : access yaml_parser_t;
      encoding : yaml_encoding_t);
   pragma Import (C, yaml_parser_set_encoding, "yaml_parser_set_encoding");
   function yaml_parser_scan (parser : access yaml_parser_t;
      token : access yaml_token_t) return signed_int;
   pragma Import (C, yaml_parser_scan, "yaml_parser_scan");
   function yaml_parser_parse (parser : access yaml_parser_t;
      event : access yaml_event_t) return signed_int;
   pragma Import (C, yaml_parser_parse, "yaml_parser_parse");
   function yaml_parser_load (parser : access yaml_parser_t;
      document : access yaml_document_t) return signed_int;
   pragma Import (C, yaml_parser_load, "yaml_parser_load");
   type access_bd4d720b is access function (data : void_ptr;
      buffer : access unsigned_char; size : stddef.size_t) return signed_int;
   pragma Convention (C, access_bd4d720b);
   --  subtype yaml_write_handler_t is ... (function type)
   subtype yaml_write_handler_t_ptr is access_bd4d720b;
   type enum_yaml_emitter_state_e;
   type enum_yaml_emitter_state_e is (YAML_EMIT_STREAM_START_STATE,
      YAML_EMIT_FIRST_DOCUMENT_START_STATE, YAML_EMIT_DOCUMENT_START_STATE,
      YAML_EMIT_DOCUMENT_CONTENT_STATE, YAML_EMIT_DOCUMENT_END_STATE,
      YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE,
      YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE,
      YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE,
      YAML_EMIT_FLOW_MAPPING_KEY_STATE,
      YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE,
      YAML_EMIT_FLOW_MAPPING_VALUE_STATE,
      YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE,
      YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE,
      YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE,
      YAML_EMIT_BLOCK_MAPPING_KEY_STATE,
      YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE,
      YAML_EMIT_BLOCK_MAPPING_VALUE_STATE, YAML_EMIT_END_STATE);
   for enum_yaml_emitter_state_e use (YAML_EMIT_STREAM_START_STATE => 0,
      YAML_EMIT_FIRST_DOCUMENT_START_STATE => 1,
      YAML_EMIT_DOCUMENT_START_STATE => 2,
      YAML_EMIT_DOCUMENT_CONTENT_STATE => 3,
      YAML_EMIT_DOCUMENT_END_STATE => 4,
      YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE => 5,
      YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE => 6,
      YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE => 7,
      YAML_EMIT_FLOW_MAPPING_KEY_STATE => 8,
      YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE => 9,
      YAML_EMIT_FLOW_MAPPING_VALUE_STATE => 10,
      YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE => 11,
      YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE => 12,
      YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE => 13,
      YAML_EMIT_BLOCK_MAPPING_KEY_STATE => 14,
      YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE => 15,
      YAML_EMIT_BLOCK_MAPPING_VALUE_STATE => 16, YAML_EMIT_END_STATE => 17);
   pragma Convention (C, enum_yaml_emitter_state_e);
   type enum_yaml_emitter_state_e_ptr is
      access all enum_yaml_emitter_state_e;
   for enum_yaml_emitter_state_e_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (enum_yaml_emitter_state_e_ptr);
   pragma Convention (C, enum_yaml_emitter_state_e_ptr);
   subtype yaml_emitter_state_t is enum_yaml_emitter_state_e;
   subtype yaml_emitter_state_t_ptr is enum_yaml_emitter_state_e_ptr;
   type struct_yaml_emitter_s;
   type struct_a62ac790 is record
      buffer : aliased unsigned_char_ptr;
      size : aliased stddef.size_t;
      size_written : aliased stddef.size_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_a62ac790);
   type union_44e760a2 (Unchecked_Tag : unsigned_int := 0) is record
      case Unchecked_Tag is
         when 0 =>
            string : struct_a62ac790;
         when others =>
            file : stdio.FILE_ptr;
      end case;
   end record;
   pragma Unchecked_Union (union_44e760a2);
   pragma Convention (C_Pass_By_Copy, union_44e760a2);
   type struct_551cb869 is record
      start : aliased yaml_char_t_ptr;
      F_end : aliased yaml_char_t_ptr;
      pointer : aliased yaml_char_t_ptr;
      last : aliased yaml_char_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_551cb869);
   type struct_01364ca5 is record
      start : aliased unsigned_char_ptr;
      F_end : aliased unsigned_char_ptr;
      pointer : aliased unsigned_char_ptr;
      last : aliased unsigned_char_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_01364ca5);
   type struct_73f3adb7 is record
      start : aliased yaml_emitter_state_t_ptr;
      F_end : aliased yaml_emitter_state_t_ptr;
      top : aliased yaml_emitter_state_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_73f3adb7);
   type struct_a0aacc03 is record
      start : aliased yaml_event_t_ptr;
      F_end : aliased yaml_event_t_ptr;
      head : aliased yaml_event_t_ptr;
      tail : aliased yaml_event_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_a0aacc03);
   type struct_c26f5e20 is record
      start : aliased signed_int_ptr;
      F_end : aliased signed_int_ptr;
      top : aliased signed_int_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_c26f5e20);
   type struct_9fdac2c3 is record
      start : aliased yaml_tag_directive_t_ptr;
      F_end : aliased yaml_tag_directive_t_ptr;
      top : aliased yaml_tag_directive_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_9fdac2c3);
   type struct_04737e83 is record
      anchor : aliased yaml_char_t_ptr;
      anchor_length : aliased stddef.size_t;
      alias : aliased signed_int;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_04737e83);
   type struct_16277eb4 is record
      handle : aliased yaml_char_t_ptr;
      handle_length : aliased stddef.size_t;
      suffix : aliased yaml_char_t_ptr;
      suffix_length : aliased stddef.size_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_16277eb4);
   type struct_072d33df is record
      value : aliased yaml_char_t_ptr;
      length : aliased stddef.size_t;
      multiline : aliased signed_int;
      flow_plain_allowed : aliased signed_int;
      block_plain_allowed : aliased signed_int;
      single_quoted_allowed : aliased signed_int;
      block_allowed : aliased signed_int;
      style : aliased yaml_scalar_style_t;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_072d33df);
   type struct_003bfd05 is record
      references : aliased signed_int;
      anchor : aliased signed_int;
      serialized : aliased signed_int;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_003bfd05);
   type struct_003bfd05_ptr is access all struct_003bfd05;
   for struct_003bfd05_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_003bfd05_ptr);
   pragma Convention (C, struct_003bfd05_ptr);
   type struct_yaml_emitter_s is record
      error : aliased yaml_error_type_t;
      problem : aliased char_const_ptr;
      write_handler : aliased yaml_write_handler_t_ptr;
      write_handler_data : aliased void_ptr;
      output : aliased union_44e760a2;
      buffer : aliased struct_551cb869;
      raw_buffer : aliased struct_01364ca5;
      encoding : aliased yaml_encoding_t;
      canonical : aliased signed_int;
      best_indent : aliased signed_int;
      best_width : aliased signed_int;
      unicode : aliased signed_int;
      line_break : aliased yaml_break_t;
      states : aliased struct_73f3adb7;
      state : aliased yaml_emitter_state_t;
      events : aliased struct_a0aacc03;
      indents : aliased struct_c26f5e20;
      tag_directives : aliased struct_9fdac2c3;
      indent : aliased signed_int;
      flow_level : aliased signed_int;
      root_context : aliased signed_int;
      sequence_context : aliased signed_int;
      mapping_context : aliased signed_int;
      simple_key_context : aliased signed_int;
      line : aliased signed_int;
      column : aliased signed_int;
      whitespace : aliased signed_int;
      indention : aliased signed_int;
      open_ended : aliased signed_int;
      anchor_data : aliased struct_04737e83;
      tag_data : aliased struct_16277eb4;
      scalar_data : aliased struct_072d33df;
      opened : aliased signed_int;
      closed : aliased signed_int;
      anchors : aliased struct_003bfd05_ptr;
      last_anchor_id : aliased signed_int;
      document : aliased yaml_document_t_ptr;
   end record;
   pragma Convention (C_Pass_By_Copy, struct_yaml_emitter_s);
   type struct_yaml_emitter_s_ptr is access all struct_yaml_emitter_s;
   for struct_yaml_emitter_s_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (struct_yaml_emitter_s_ptr);
   pragma Convention (C, struct_yaml_emitter_s_ptr);
   subtype yaml_emitter_t is struct_yaml_emitter_s;
   subtype yaml_emitter_t_ptr is struct_yaml_emitter_s_ptr;
   function yaml_emitter_initialize (emitter : access yaml_emitter_t)
      return signed_int;
   pragma Import (C, yaml_emitter_initialize, "yaml_emitter_initialize");
   procedure yaml_emitter_delete (emitter : access yaml_emitter_t);
   pragma Import (C, yaml_emitter_delete, "yaml_emitter_delete");
   procedure yaml_emitter_set_output_string (emitter : access yaml_emitter_t;
      output : access unsigned_char; size : stddef.size_t;
      size_written : access stddef.size_t);
   pragma Import (C, yaml_emitter_set_output_string,
      "yaml_emitter_set_output_string");
   procedure yaml_emitter_set_output_file (emitter : access yaml_emitter_t;
      file : access stdio.FILE);
   pragma Import (C, yaml_emitter_set_output_file,
      "yaml_emitter_set_output_file");
   procedure yaml_emitter_set_output (emitter : access yaml_emitter_t;
      handler : yaml_write_handler_t_ptr; data : void_ptr);
   pragma Import (C, yaml_emitter_set_output, "yaml_emitter_set_output");
   procedure yaml_emitter_set_encoding (emitter : access yaml_emitter_t;
      encoding : yaml_encoding_t);
   pragma Import (C, yaml_emitter_set_encoding, "yaml_emitter_set_encoding");
   procedure yaml_emitter_set_canonical (emitter : access yaml_emitter_t;
      canonical : signed_int);
   pragma Import (C, yaml_emitter_set_canonical,
      "yaml_emitter_set_canonical");
   procedure yaml_emitter_set_indent (emitter : access yaml_emitter_t;
      indent : signed_int);
   pragma Import (C, yaml_emitter_set_indent, "yaml_emitter_set_indent");
   procedure yaml_emitter_set_width (emitter : access yaml_emitter_t;
      width : signed_int);
   pragma Import (C, yaml_emitter_set_width, "yaml_emitter_set_width");
   procedure yaml_emitter_set_unicode (emitter : access yaml_emitter_t;
      unicode : signed_int);
   pragma Import (C, yaml_emitter_set_unicode, "yaml_emitter_set_unicode");
   procedure yaml_emitter_set_break (emitter : access yaml_emitter_t;
      line_break : yaml_break_t);
   pragma Import (C, yaml_emitter_set_break, "yaml_emitter_set_break");
   function yaml_emitter_emit (emitter : access yaml_emitter_t;
      event : access yaml_event_t) return signed_int;
   pragma Import (C, yaml_emitter_emit, "yaml_emitter_emit");
   function yaml_emitter_open (emitter : access yaml_emitter_t)
      return signed_int;
   pragma Import (C, yaml_emitter_open, "yaml_emitter_open");
   function yaml_emitter_close (emitter : access yaml_emitter_t)
      return signed_int;
   pragma Import (C, yaml_emitter_close, "yaml_emitter_close");
   function yaml_emitter_dump (emitter : access yaml_emitter_t;
      document : access yaml_document_t) return signed_int;
   pragma Import (C, yaml_emitter_dump, "yaml_emitter_dump");
   function yaml_emitter_flush (emitter : access yaml_emitter_t)
      return signed_int;
   pragma Import (C, yaml_emitter_flush, "yaml_emitter_flush");
   YAML_BOOL_TAG : constant char_array (0 .. 22) := "tag:yaml.org,2002:bool"
      & char'Val (0);
   --  YAML_DECLARE (function macro)
   YAML_DEFAULT_MAPPING_TAG : constant char_array (0 .. 21) :=
      "tag:yaml.org,2002:map" & char'Val (0);
   YAML_DEFAULT_SCALAR_TAG : constant char_array (0 .. 21) :=
      "tag:yaml.org,2002:str" & char'Val (0);
   YAML_DEFAULT_SEQUENCE_TAG : constant char_array (0 .. 21) :=
      "tag:yaml.org,2002:seq" & char'Val (0);
   YAML_FLOAT_TAG : constant char_array (0 .. 23) :=
      "tag:yaml.org,2002:float" & char'Val (0);
   --  YAML_H (empty)
   YAML_INT_TAG : constant char_array (0 .. 21) := "tag:yaml.org,2002:int"
      & char'Val (0);
   YAML_MAP_TAG : constant char_array (0 .. 21) := "tag:yaml.org,2002:map"
      & char'Val (0);
   YAML_NULL_TAG : constant char_array (0 .. 22) := "tag:yaml.org,2002:null"
      & char'Val (0);
   YAML_SEQ_TAG : constant char_array (0 .. 21) := "tag:yaml.org,2002:seq"
      & char'Val (0);
   YAML_STR_TAG : constant char_array (0 .. 21) := "tag:yaml.org,2002:str"
      & char'Val (0);
   YAML_TIMESTAMP_TAG : constant char_array (0 .. 27) :=
      "tag:yaml.org,2002:timestamp" & char'Val (0);
end C.yaml;

c.ads

--  This file is translated by "headmaster" version 0.30-e83b81d (devel).
--  The original C header's license should be applied to this file.
--  All conditional-directives are expanded for the exclusive use of your
--    environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with System;
package C is
   pragma Preelaborate;
   --  type void (<>) is limited private;
   type bool is new Boolean;
   pragma Convention (C, bool);
   type signed_char is new Short_Short_Integer;
   pragma Convention (C, signed_char);
   type unsigned_char is mod 2 ** signed_char'Size;
   pragma Convention (C, unsigned_char);
   type signed_short is new Short_Integer;
   pragma Convention (C, signed_short);
   type unsigned_short is mod 2 ** signed_short'Size;
   pragma Convention (C, unsigned_short);
   type signed_int is new Integer;
   pragma Convention (C, signed_int);
   type unsigned_int is mod 2 ** signed_int'Size;
   pragma Convention (C, unsigned_int);
   type signed_long is new Long_Integer;
   pragma Convention (C, signed_long);
   type unsigned_long is mod 2 ** signed_long'Size;
   pragma Convention (C, unsigned_long);
   type signed_long_long is new Long_Long_Integer;
   pragma Convention (C, signed_long_long);
   type unsigned_long_long is mod 2 ** signed_long_long'Size;
   pragma Convention (C, unsigned_long_long);
   type float is new Standard.Float;
   pragma Convention (C, float);
   type double is new Long_Float;
   pragma Convention (C, double);
   type long_double is new Long_Long_Float;
   pragma Convention (C, long_double);
   --  type Float32 is ...
   --  type Float64 is ...
   --  type Float128 is ...
   --  type Float32x is ...
   --  type Float64x is ...
   --  type Decimal32 is ...
   --  type Decimal64 is ...
   --  type Decimal128 is ...
   type float_imaginary is new float;
   pragma Convention (C, float_imaginary);
   type double_imaginary is new double;
   pragma Convention (C, double_imaginary);
   type long_double_imaginary is new long_double;
   pragma Convention (C, long_double_imaginary);
   --  type Float32_imaginary is ...
   --  type Float32x_imaginary is ...
   --  type Float64_imaginary is ...
   --  type Float64x_imaginary is ...
   --  type Float128_imaginary is ...
   type float_complex is record
      Re, Im : float'Base;
   end record;
   pragma Complex_Representation (float_complex);
   pragma Convention (C, float_complex);
   type double_complex is record
      Re, Im : double'Base;
   end record;
   pragma Complex_Representation (double_complex);
   pragma Convention (C, double_complex);
   type long_double_complex is record
      Re, Im : long_double'Base;
   end record;
   pragma Complex_Representation (long_double_complex);
   pragma Convention (C, long_double_complex);
   --  type Float32_complex is ...
   --  type Float32x_complex is ...
   --  type Float64_complex is ...
   --  type Float64x_complex is ...
   --  type Float128_complex is ...
   type char is new Character;
   type int128_t is record
      Lo, Hi : unsigned_long_long;
   end record;
   pragma Convention (C_Pass_By_Copy, int128_t);
   type uint128_t is record
      Lo, Hi : unsigned_long_long;
   end record;
   pragma Convention (C_Pass_By_Copy, uint128_t);
   subtype builtin_va_list is System.Address;
   type ptrdiff_t is new signed_long;
   type size_t is new unsigned_long;
   type wchar_t is new signed_int;
   subtype void_ptr is System.Address;
   type void_ptr_ptr is access all void_ptr;
   for void_ptr_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (void_ptr_ptr);
   pragma Convention (C, void_ptr_ptr);
   subtype void_const_ptr is System.Address;
   type unsigned_char_array is array (size_t range <>) of
      aliased unsigned_char;
   pragma Convention (C, unsigned_char_array);
   type unsigned_char_ptr is access all unsigned_char;
   for unsigned_char_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (unsigned_char_ptr);
   pragma Convention (C, unsigned_char_ptr);
   type unsigned_char_const_ptr is access constant unsigned_char;
   for unsigned_char_const_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (unsigned_char_const_ptr);
   pragma Convention (C, unsigned_char_const_ptr);
   type unsigned_short_array is array (size_t range <>) of
      aliased unsigned_short;
   pragma Convention (C, unsigned_short_array);
   type unsigned_short_ptr is access all unsigned_short;
   for unsigned_short_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (unsigned_short_ptr);
   pragma Convention (C, unsigned_short_ptr);
   type unsigned_short_const_ptr is access constant unsigned_short;
   for unsigned_short_const_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (unsigned_short_const_ptr);
   pragma Convention (C, unsigned_short_const_ptr);
   type signed_int_array is array (size_t range <>) of aliased signed_int;
   pragma Convention (C, signed_int_array);
   type signed_int_ptr is access all signed_int;
   for signed_int_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (signed_int_ptr);
   pragma Convention (C, signed_int_ptr);
   type signed_int_volatile is new signed_int;
   pragma Volatile (signed_int_volatile);
   type signed_int_const_ptr is access constant signed_int;
   for signed_int_const_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (signed_int_const_ptr);
   pragma Convention (C, signed_int_const_ptr);
   type unsigned_int_ptr is access all unsigned_int;
   for unsigned_int_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (unsigned_int_ptr);
   pragma Convention (C, unsigned_int_ptr);
   type signed_long_ptr is access all signed_long;
   for signed_long_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (signed_long_ptr);
   pragma Convention (C, signed_long_ptr);
   type signed_long_array is array (size_t range <>) of aliased signed_long;
   pragma Convention (C, signed_long_array);
   type unsigned_long_array is array (size_t range <>) of
      aliased unsigned_long;
   pragma Convention (C, unsigned_long_array);
   type unsigned_long_ptr is access all unsigned_long;
   for unsigned_long_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (unsigned_long_ptr);
   pragma Convention (C, unsigned_long_ptr);
   type double_ptr is access all double;
   for double_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (double_ptr);
   pragma Convention (C, double_ptr);
   type double_array is array (size_t range <>) of aliased double;
   pragma Convention (C, double_array);
   type char_ptr is access all char;
   for char_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (char_ptr);
   pragma Convention (C, char_ptr);
   type char_ptr_ptr is access all char_ptr;
   for char_ptr_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (char_ptr_ptr);
   pragma Convention (C, char_ptr_ptr);
   type char_const_ptr is access constant char;
   for char_const_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (char_const_ptr);
   pragma Convention (C, char_const_ptr);
   type char_const_ptr_array is array (size_t range <>) of
      aliased char_const_ptr;
   pragma Convention (C, char_const_ptr_array);
   type char_array is array (size_t range <>) of aliased char;
   pragma Convention (C, char_array);
   function "=" (Left, Right : System.Address) return Boolean
      renames System."=";
   type size_t_ptr is access all size_t;
   for size_t_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (size_t_ptr);
   pragma Convention (C, size_t_ptr);
   type wchar_t_ptr is access all wchar_t;
   for wchar_t_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (wchar_t_ptr);
   pragma Convention (C, wchar_t_ptr);
   type wchar_t_const_ptr is access constant wchar_t;
   for wchar_t_const_ptr'Storage_Size use 0;
   pragma No_Strict_Aliasing (wchar_t_const_ptr);
   pragma Convention (C, wchar_t_const_ptr);
   function Shift_Left (Left : signed_char; Right : Natural)
      return signed_char;
   function Shift_Right_Arithmetic (Left : signed_char; Right : Natural)
      return signed_char;
   function Shift_Left (Left : unsigned_char; Right : Natural)
      return unsigned_char;
   function Shift_Right (Left : unsigned_char; Right : Natural)
      return unsigned_char;
   function Shift_Left (Left : signed_short; Right : Natural)
      return signed_short;
   function Shift_Right_Arithmetic (Left : signed_short; Right : Natural)
      return signed_short;
   function Shift_Left (Left : unsigned_short; Right : Natural)
      return unsigned_short;
   function Shift_Right (Left : unsigned_short; Right : Natural)
      return unsigned_short;
   function Shift_Left (Left : signed_int; Right : Natural)
      return signed_int;
   function Shift_Right_Arithmetic (Left : signed_int; Right : Natural)
      return signed_int;
   function Shift_Left (Left : unsigned_int; Right : Natural)
      return unsigned_int;
   function Shift_Right (Left : unsigned_int; Right : Natural)
      return unsigned_int;
   function Shift_Left (Left : signed_long; Right : Natural)
      return signed_long;
   function Shift_Right_Arithmetic (Left : signed_long; Right : Natural)
      return signed_long;
   function Shift_Left (Left : unsigned_long; Right : Natural)
      return unsigned_long;
   function Shift_Right (Left : unsigned_long; Right : Natural)
      return unsigned_long;
   function Shift_Left (Left : signed_long_long; Right : Natural)
      return signed_long_long;
   function Shift_Right_Arithmetic (Left : signed_long_long; Right : Natural)
      return signed_long_long;
   function Shift_Left (Left : unsigned_long_long; Right : Natural)
      return unsigned_long_long;
   function Shift_Right (Left : unsigned_long_long; Right : Natural)
      return unsigned_long_long;
   pragma Import (Intrinsic, Shift_Left);
   pragma Import (Intrinsic, Shift_Right);
   pragma Import (Intrinsic, Shift_Right_Arithmetic);
   LP64 : constant := 1;
   STDC_PREDEF_H : constant := 1;
   ATOMIC_ACQUIRE : constant := 2;
   ATOMIC_ACQ_REL : constant := 4;
   ATOMIC_CONSUME : constant := 1;
   ATOMIC_HLE_ACQUIRE : constant := 65536;
   ATOMIC_HLE_RELEASE : constant := 131072;
   ATOMIC_RELAXED : constant := 0;
   ATOMIC_RELEASE : constant := 3;
   ATOMIC_SEQ_CST : constant := 5;
   qqBIGGEST_ALIGNMENTqq : constant := 16;
   qqBYTE_ORDERqq : constant := 1234;
   subtype qqCHAR16_TYPEqq is unsigned_short;
   subtype qqCHAR32_TYPEqq is unsigned_int;
   qqCHAR_BITqq : constant := 8;
   qqDBL_DECIMAL_DIGqq : constant := 17;
   qqDBL_DENORM_MINqq : constant := 16#0.40000000000000000#e-268;
   qqDBL_DIGqq : constant := 15;
   qqDBL_EPSILONqq : constant := 16#0.10000000000000000#e-12;
   qqDBL_HAS_DENORMqq : constant := 1;
   qqDBL_HAS_INFINITYqq : constant := 1;
   qqDBL_HAS_QUIET_NANqq : constant := 1;
   qqDBL_MANT_DIGqq : constant := 53;
   qqDBL_MAX_10_EXPqq : constant := 308;
   qqDBL_MAX_EXPqq : constant := 1024;
   qqDBL_MAXqq : constant := 16#0.fffffffffffff8000#e+256;
   qqDBL_MIN_10_EXPqq : constant := -307;
   qqDBL_MIN_EXPqq : constant := -1021;
   qqDBL_MINqq : constant := 16#0.40000000000000000#e-255;
   --  qqDEC128_EPSILONqq (decimal)
   qqDEC128_MANT_DIGqq : constant := 34;
   qqDEC128_MAX_EXPqq : constant := 6145;
   --  qqDEC128_MAXqq (decimal)
   qqDEC128_MIN_EXPqq : constant := -6142;
   --  qqDEC128_MINqq (decimal)
   --  qqDEC128_SUBNORMAL_MINqq (decimal)
   --  qqDEC32_EPSILONqq (decimal)
   qqDEC32_MANT_DIGqq : constant := 7;
   qqDEC32_MAX_EXPqq : constant := 97;
   --  qqDEC32_MAXqq (decimal)
   qqDEC32_MIN_EXPqq : constant := -94;
   --  qqDEC32_MINqq (decimal)
   --  qqDEC32_SUBNORMAL_MINqq (decimal)
   --  qqDEC64_EPSILONqq (decimal)
   qqDEC64_MANT_DIGqq : constant := 16;
   qqDEC64_MAX_EXPqq : constant := 385;
   --  qqDEC64_MAXqq (decimal)
   qqDEC64_MIN_EXPqq : constant := -382;
   --  qqDEC64_MINqq (decimal)
   --  qqDEC64_SUBNORMAL_MINqq (decimal)
   qqDECIMAL_BID_FORMATqq : constant := 1;
   qqDECIMAL_DIGqq : constant := 21;
   qqDEC_EVAL_METHODqq : constant := 2;
   qqELFqq : constant := 1;
   qqFINITE_MATH_ONLYqq : constant := 0;
   qqFLOAT_WORD_ORDERqq : constant := 1234;
   qqFLT_DECIMAL_DIGqq : constant := 9;
   qqFLT_DENORM_MINqq : constant := 16#0.80000000000000000#e-37;
   qqFLT_DIGqq : constant := 6;
   qqFLT_EPSILONqq : constant := 16#0.20000000000000000#e-5;
   qqFLT_EVAL_METHODqq : constant := 0;
   qqFLT_HAS_DENORMqq : constant := 1;
   qqFLT_HAS_INFINITYqq : constant := 1;
   qqFLT_HAS_QUIET_NANqq : constant := 1;
   qqFLT_MANT_DIGqq : constant := 24;
   qqFLT_MAX_10_EXPqq : constant := 38;
   qqFLT_MAX_EXPqq : constant := 128;
   qqFLT_MAXqq : constant := 16#0.ffffff00000000000#e+32;
   qqFLT_MIN_10_EXPqq : constant := -37;
   qqFLT_MIN_EXPqq : constant := -125;
   qqFLT_MINqq : constant := 16#0.40000000000000000#e-31;
   qqFLT_RADIXqq : constant := 2;
   qqFXSRqq : constant := 1;
   qqGCC_ASM_FLAG_OUTPUTSqq : constant := 1;
   GCC_ATOMIC_BOOL_LOCK_FREE : constant := 2;
   GCC_ATOMIC_CHAR16_T_LOCK_FREE : constant := 2;
   GCC_ATOMIC_CHAR32_T_LOCK_FREE : constant := 2;
   GCC_ATOMIC_CHAR_LOCK_FREE : constant := 2;
   GCC_ATOMIC_INT_LOCK_FREE : constant := 2;
   GCC_ATOMIC_LLONG_LOCK_FREE : constant := 2;
   GCC_ATOMIC_LONG_LOCK_FREE : constant := 2;
   GCC_ATOMIC_POINTER_LOCK_FREE : constant := 2;
   GCC_ATOMIC_SHORT_LOCK_FREE : constant := 2;
   GCC_ATOMIC_TEST_AND_SET_TRUEVAL : constant := 1;
   GCC_ATOMIC_WCHAR_T_LOCK_FREE : constant := 2;
   GCC_HAVE_DWARF2_CFI_ASM : constant := 1;
   GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 : constant := 1;
   GCC_HAVE_SYNC_COMPARE_AND_SWAP_16 : constant := 1;
   GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 : constant := 1;
   GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 : constant := 1;
   GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 : constant := 1;
   GCC_IEC_559 : constant := 2;
   GCC_IEC_559_COMPLEX : constant := 2;
   qqGNUC_MINORqq : constant := 5;
   qqGNUC_PATCHLEVELqq : constant := 0;
   qqGNUC_STDC_INLINEqq : constant := 1;
   qqGNUCqq : constant := 6;
   GXX_ABI_VERSION : constant := 1010;
   --  __INT16_C (function macro)
   qqINT16_MAXqq : constant := 32767;
   subtype qqINT16_TYPEqq is signed_short;
   --  __INT32_C (function macro)
   qqINT32_MAXqq : constant := 2147483647;
   subtype qqINT32_TYPEqq is signed_int;
   --  __INT64_C (has # or ##)
   qqINT64_MAXqq : constant := 9223372036854775807;
   subtype qqINT64_TYPEqq is signed_long;
   --  __INT8_C (function macro)
   qqINT8_MAXqq : constant := 127;
   subtype qqINT8_TYPEqq is signed_char;
   --  __INTMAX_C (has # or ##)
   qqINTMAX_MAXqq : constant := 9223372036854775807;
   subtype qqINTMAX_TYPEqq is signed_long;
   qqINTPTR_MAXqq : constant := 9223372036854775807;
   subtype qqINTPTR_TYPEqq is signed_long;
   qqINT_FAST16_MAXqq : constant := 9223372036854775807;
   subtype qqINT_FAST16_TYPEqq is signed_long;
   qqINT_FAST32_MAXqq : constant := 9223372036854775807;
   subtype qqINT_FAST32_TYPEqq is signed_long;
   qqINT_FAST64_MAXqq : constant := 9223372036854775807;
   subtype qqINT_FAST64_TYPEqq is signed_long;
   qqINT_FAST8_MAXqq : constant := 127;
   subtype qqINT_FAST8_TYPEqq is signed_char;
   qqINT_LEAST16_MAXqq : constant := 32767;
   subtype qqINT_LEAST16_TYPEqq is signed_short;
   qqINT_LEAST32_MAXqq : constant := 2147483647;
   subtype qqINT_LEAST32_TYPEqq is signed_int;
   qqINT_LEAST64_MAXqq : constant := 9223372036854775807;
   subtype qqINT_LEAST64_TYPEqq is signed_long;
   qqINT_LEAST8_MAXqq : constant := 127;
   subtype qqINT_LEAST8_TYPEqq is signed_char;
   qqINT_MAXqq : constant := 2147483647;
   qqLDBL_DENORM_MINqq : constant := 16#0.80000000000000000#e-4111;
   qqLDBL_DIGqq : constant := 18;
   qqLDBL_EPSILONqq : constant := 16#0.20000000000000000#e-15;
   qqLDBL_HAS_DENORMqq : constant := 1;
   qqLDBL_HAS_INFINITYqq : constant := 1;
   qqLDBL_HAS_QUIET_NANqq : constant := 1;
   qqLDBL_MANT_DIGqq : constant := 64;
   qqLDBL_MAX_10_EXPqq : constant := 4932;
   qqLDBL_MAX_EXPqq : constant := 16384;
   qqLDBL_MAXqq : constant := 16#0.ffffffffffffffff0#e+4096;
   qqLDBL_MIN_10_EXPqq : constant := -4931;
   qqLDBL_MIN_EXPqq : constant := -16381;
   qqLDBL_MINqq : constant := 16#0.40000000000000000#e-4095;
   qqLONG_LONG_MAXqq : constant := 9223372036854775807;
   qqLONG_MAXqq : constant := 9223372036854775807;
   qqLP64qq : constant := 1;
   qqMMXqq : constant := 1;
   qqNO_INLINEqq : constant := 1;
   qqORDER_BIG_ENDIANqq : constant := 4321;
   qqORDER_LITTLE_ENDIANqq : constant := 1234;
   qqORDER_PDP_ENDIANqq : constant := 3412;
   PRAGMA_REDEFINE_EXTNAME : constant := 1;
   qqPTRDIFF_MAXqq : constant := 9223372036854775807;
   subtype qqPTRDIFF_TYPEqq is signed_long;
   --  __REGISTER_PREFIX__ (empty)
   qqSCHAR_MAXqq : constant := 127;
   SEG_FS : constant := 1;
   SEG_GS : constant := 1;
   qqSHRT_MAXqq : constant := 32767;
   qqSIG_ATOMIC_MAXqq : constant := 2147483647;
   qqSIG_ATOMIC_MINqq : constant := -2147483648;
   subtype qqSIG_ATOMIC_TYPEqq is signed_int;
   qqSIZEOF_DOUBLEqq : constant := 8;
   qqSIZEOF_FLOAT128qq : constant := 16;
   qqSIZEOF_FLOAT80qq : constant := 16;
   qqSIZEOF_FLOATqq : constant := 4;
   qqSIZEOF_INT128qq : constant := 16;
   qqSIZEOF_INTqq : constant := 4;
   qqSIZEOF_LONG_DOUBLEqq : constant := 16;
   qqSIZEOF_LONG_LONGqq : constant := 8;
   qqSIZEOF_LONGqq : constant := 8;
   qqSIZEOF_POINTERqq : constant := 8;
   qqSIZEOF_PTRDIFF_Tqq : constant := 8;
   qqSIZEOF_SHORTqq : constant := 2;
   qqSIZEOF_SIZE_Tqq : constant := 8;
   qqSIZEOF_WCHAR_Tqq : constant := 4;
   qqSIZEOF_WINT_Tqq : constant := 4;
   qqSIZE_MAXqq : constant := 18446744073709551615;
   subtype qqSIZE_TYPEqq is unsigned_long;
   qqSSE2_MATHqq : constant := 1;
   qqSSE2qq : constant := 1;
   qqSSE3qq : constant := 1;
   qqSSE_MATHqq : constant := 1;
   qqSSEqq : constant := 1;
   qqSSSE3qq : constant := 1;
   qqSTDC_HOSTEDqq : constant := 1;
   qqSTDC_NO_THREADSqq : constant := 1;
   qqSTDC_UTF_16qq : constant := 1;
   qqSTDC_UTF_32qq : constant := 1;
   --  __UINT16_C (function macro)
   qqUINT16_MAXqq : constant := 65535;
   subtype qqUINT16_TYPEqq is unsigned_short;
   --  __UINT32_C (has # or ##)
   qqUINT32_MAXqq : constant := 4294967295;
   subtype qqUINT32_TYPEqq is unsigned_int;
   --  __UINT64_C (has # or ##)
   qqUINT64_MAXqq : constant := 18446744073709551615;
   subtype qqUINT64_TYPEqq is unsigned_long;
   --  __UINT8_C (function macro)
   qqUINT8_MAXqq : constant := 255;
   subtype qqUINT8_TYPEqq is unsigned_char;
   --  __UINTMAX_C (has # or ##)
   qqUINTMAX_MAXqq : constant := 18446744073709551615;
   subtype qqUINTMAX_TYPEqq is unsigned_long;
   qqUINTPTR_MAXqq : constant := 18446744073709551615;
   subtype qqUINTPTR_TYPEqq is unsigned_long;
   qqUINT_FAST16_MAXqq : constant := 18446744073709551615;
   subtype qqUINT_FAST16_TYPEqq is unsigned_long;
   qqUINT_FAST32_MAXqq : constant := 18446744073709551615;
   subtype qqUINT_FAST32_TYPEqq is unsigned_long;
   qqUINT_FAST64_MAXqq : constant := 18446744073709551615;
   subtype qqUINT_FAST64_TYPEqq is unsigned_long;
   qqUINT_FAST8_MAXqq : constant := 255;
   subtype qqUINT_FAST8_TYPEqq is unsigned_char;
   qqUINT_LEAST16_MAXqq : constant := 65535;
   subtype qqUINT_LEAST16_TYPEqq is unsigned_short;
   qqUINT_LEAST32_MAXqq : constant := 4294967295;
   subtype qqUINT_LEAST32_TYPEqq is unsigned_int;
   qqUINT_LEAST64_MAXqq : constant := 18446744073709551615;
   subtype qqUINT_LEAST64_TYPEqq is unsigned_long;
   qqUINT_LEAST8_MAXqq : constant := 255;
   subtype qqUINT_LEAST8_TYPEqq is unsigned_char;
   --  __USER_LABEL_PREFIX__ (empty)
   qqVERSIONqq : constant char_array (0 .. 5) := "6.5.0" & char'Val (0);
   qqWCHAR_MAXqq : constant := 2147483647;
   qqWCHAR_MINqq : constant := -2147483648;
   subtype qqWCHAR_TYPEqq is signed_int;
   qqWINT_MAXqq : constant := 4294967295;
   qqWINT_MINqq : constant := 0;
   subtype qqWINT_TYPEqq is unsigned_int;
   amd64 : constant := 1;
   qqamd64qq : constant := 1;
   qqcode_model_smallqq : constant := 1;
   core2 : constant := 1;
   qqcore2qq : constant := 1;
   qqgnu_linuxqq : constant := 1;
   --  __has_include (has __has_include__ or __has_include_next__)
   --  __has_include_next (has __has_include__ or __has_include_next__)
   defined_qqlinux : constant := 1;
   qqlinuxqq : constant := 1;
   qqunix : constant := 1;
   qqunixqq : constant := 1;
   x86_64 : constant := 1;
   qqx86_64qq : constant := 1;
   defined_linux : constant := 1;
   unix : constant := 1;
   function builtin_alloca (a1 : size_t) return char_ptr;
   pragma Import (Intrinsic, builtin_alloca, "__builtin_alloca");
   function builtin_bswap16 (a1 : unsigned_short) return unsigned_short;
   pragma Import (Intrinsic, builtin_bswap16, "__builtin_bswap16");
   function builtin_bswap32 (a1 : unsigned_int) return unsigned_int;
   pragma Import (Intrinsic, builtin_bswap32, "__builtin_bswap32");
   function builtin_bswap64 (a1 : unsigned_long_long)
      return unsigned_long_long;
   pragma Import (Intrinsic, builtin_bswap64, "__builtin_bswap64");
   procedure builtin_bzero (a1 : access char; a2 : size_t);
   pragma Import (Intrinsic, builtin_bzero, "__builtin_bzero");
   function builtin_extract_return_addr (a1 : access char) return char_ptr;
   pragma Import (Intrinsic, builtin_extract_return_addr,
      "__builtin_extract_return_addr");
   function builtin_fabsf (a1 : float) return float;
   pragma Import (Intrinsic, builtin_fabsf, "__builtin_fabsf");
   function builtin_fabs (a1 : double) return double;
   pragma Import (Intrinsic, builtin_fabs, "__builtin_fabs");
   function builtin_fabsl (a1 : long_double) return long_double;
   pragma Import (Intrinsic, builtin_fabsl, "__builtin_fabsl");
   function builtin_flt_rounds return signed_int;
   pragma Import (Intrinsic, builtin_flt_rounds, "__builtin_flt_rounds");
   function builtin_frame_address (a1 : unsigned_int) return char_ptr;
   pragma Import (Intrinsic, builtin_frame_address,
      "__builtin_frame_address");
   function builtin_huge_valf return float;
   pragma Import (Intrinsic, builtin_huge_valf, "__builtin_huge_valf");
   function builtin_huge_val return double;
   pragma Import (Intrinsic, builtin_huge_val, "__builtin_huge_val");
   function builtin_huge_vall return long_double;
   pragma Import (Intrinsic, builtin_huge_vall, "__builtin_huge_vall");
   function builtin_inff return float;
   pragma Import (Intrinsic, builtin_inff, "__builtin_inff");
   function builtin_inf return double;
   pragma Import (Intrinsic, builtin_inf, "__builtin_inf");
   function builtin_infl return long_double;
   pragma Import (Intrinsic, builtin_infl, "__builtin_infl");
   function builtin_llabs (a1 : signed_long_long) return signed_long_long;
   pragma Import (Intrinsic, builtin_llabs, "__builtin_llabs");
   function builtin_memcmp (a1 : access char; a2 : access char; a3 : size_t)
      return signed_int;
   pragma Import (Intrinsic, builtin_memcmp, "__builtin_memcmp");
   function builtin_memset (a1 : access char; a2 : signed_int; a3 : size_t)
      return char_ptr;
   pragma Import (Intrinsic, builtin_memset, "__builtin_memset");
   function builtin_memcpy_chk (a1 : access char; a2 : access constant char;
      a3 : size_t; a4 : size_t) return char_ptr;
   pragma Import (Intrinsic, builtin_memcpy_chk, "__builtin___memcpy_chk");
   function builtin_memmove_chk (a1 : access char; a2 : access constant char;
      a3 : size_t; a4 : size_t) return char_ptr;
   pragma Import (Intrinsic, builtin_memmove_chk, "__builtin___memmove_chk");
   function builtin_memset_chk (a1 : access char; a2 : signed_int;
      a3 : size_t; a4 : size_t) return char_ptr;
   pragma Import (Intrinsic, builtin_memset_chk, "__builtin___memset_chk");
   function builtin_nanf (a1 : access constant char) return float;
   pragma Import (Intrinsic, builtin_nanf, "__builtin_nanf");
   function builtin_nan (a1 : access constant char) return double;
   pragma Import (Intrinsic, builtin_nan, "__builtin_nan");
   function builtin_nanl (a1 : access constant char) return long_double;
   pragma Import (Intrinsic, builtin_nanl, "__builtin_nanl");
   function builtin_return_address (a1 : unsigned_int) return char_ptr;
   pragma Import (Intrinsic, builtin_return_address,
      "__builtin_return_address");
   function builtin_stpcpy_chk (a1 : access char; a2 : access constant char;
      a3 : size_t) return char_ptr;
   pragma Import (Intrinsic, builtin_stpcpy_chk, "__builtin___stpcpy_chk");
   function builtin_stpncpy_chk (a1 : access char; a2 : access constant char;
      a3 : size_t; a4 : size_t) return char_ptr;
   pragma Import (Intrinsic, builtin_stpncpy_chk, "__builtin___stpncpy_chk");
   function builtin_strcat_chk (a1 : access char; a2 : access constant char;
      a3 : size_t) return char_ptr;
   pragma Import (Intrinsic, builtin_strcat_chk, "__builtin___strcat_chk");
   function builtin_strcpy_chk (a1 : access char; a2 : access constant char;
      a3 : size_t) return char_ptr;
   pragma Import (Intrinsic, builtin_strcpy_chk, "__builtin___strcpy_chk");
   function builtin_strncat_chk (a1 : access char; a2 : access constant char;
      a3 : size_t; a4 : size_t) return char_ptr;
   pragma Import (Intrinsic, builtin_strncat_chk, "__builtin___strncat_chk");
   function builtin_strncpy_chk (a1 : access char; a2 : access constant char;
      a3 : size_t; a4 : size_t) return char_ptr;
   pragma Import (Intrinsic, builtin_strncpy_chk, "__builtin___strncpy_chk");
end C;