// /usr/libexec/gcc/powerpc64-unknown-linux-gnu/3.4.3/cc1 -quiet -I. -I. -I. -D__unix__ -D__gnu_linux__ -D__linux__ -Dunix -D__unix -Dlinux -D__linux -Asystem=linux -Asystem=unix -Asystem=posix -DHAVE_CONFIG_H -DG_LOG_DOMAIN=g_log_domain_glib -D_REENTRANT testglib.c -fPIE -fstack-protector -fstack-protector-all -quiet -dumpbase testglib.c -auxbase testglib -O2 -Wall -o - -frandom-seed=0
# 1 "testglib.c"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "testglib.c"
# 29 "testglib.c"
# 1 "/usr/include/stdio.h" 1 3 4
# 28 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 314 "/usr/include/features.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 315 "/usr/include/features.h" 2 3 4
# 337 "/usr/include/features.h" 3 4
# 1 "/usr/include/gnu/stubs.h" 1 3 4
# 338 "/usr/include/features.h" 2 3 4
# 29 "/usr/include/stdio.h" 2 3 4





# 1 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/stddef.h" 1 3 4
# 213 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/stddef.h" 3 4
typedef long unsigned int size_t;
# 35 "/usr/include/stdio.h" 2 3 4

# 1 "/usr/include/bits/types.h" 1 3 4
# 28 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/usr/include/bits/types.h" 2 3 4


# 1 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/stddef.h" 1 3 4
# 32 "/usr/include/bits/types.h" 2 3 4


typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;


typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;

typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;







typedef long int __quad_t;
typedef unsigned long int __u_quad_t;
# 129 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/typesizes.h" 1 3 4
# 130 "/usr/include/bits/types.h" 2 3 4






__extension__ typedef unsigned long int __dev_t;
__extension__ typedef unsigned int __uid_t;
__extension__ typedef unsigned int __gid_t;
__extension__ typedef unsigned long int __ino_t;
__extension__ typedef unsigned long int __ino64_t;
__extension__ typedef unsigned int __mode_t;
__extension__ typedef unsigned long int __nlink_t;
__extension__ typedef long int __off_t;
__extension__ typedef long int __off64_t;
__extension__ typedef int __pid_t;
__extension__ typedef struct { int __val[2]; } __fsid_t;
__extension__ typedef long int __clock_t;
__extension__ typedef unsigned long int __rlim_t;
__extension__ typedef unsigned long int __rlim64_t;
__extension__ typedef unsigned int __id_t;
__extension__ typedef long int __time_t;
__extension__ typedef unsigned int __useconds_t;
__extension__ typedef long int __suseconds_t;

__extension__ typedef int __daddr_t;
__extension__ typedef long int __swblk_t;
__extension__ typedef int __key_t;


__extension__ typedef int __clockid_t;


__extension__ typedef int __timer_t;


__extension__ typedef long int __blksize_t;




__extension__ typedef long int __blkcnt_t;
__extension__ typedef long int __blkcnt64_t;


__extension__ typedef unsigned long int __fsblkcnt_t;
__extension__ typedef unsigned long int __fsblkcnt64_t;


__extension__ typedef unsigned long int __fsfilcnt_t;
__extension__ typedef unsigned long int __fsfilcnt64_t;

__extension__ typedef long int __ssize_t;



typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;


__extension__ typedef long int __intptr_t;


__extension__ typedef unsigned int __socklen_t;
# 37 "/usr/include/stdio.h" 2 3 4









typedef struct _IO_FILE FILE;





# 62 "/usr/include/stdio.h" 3 4
typedef struct _IO_FILE __FILE;
# 72 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/libio.h" 1 3 4
# 32 "/usr/include/libio.h" 3 4
# 1 "/usr/include/_G_config.h" 1 3 4
# 14 "/usr/include/_G_config.h" 3 4
# 1 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/stddef.h" 1 3 4
# 325 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/stddef.h" 3 4
typedef int wchar_t;
# 354 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/stddef.h" 3 4
typedef unsigned int wint_t;
# 15 "/usr/include/_G_config.h" 2 3 4
# 24 "/usr/include/_G_config.h" 3 4
# 1 "/usr/include/wchar.h" 1 3 4
# 48 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/stddef.h" 1 3 4
# 49 "/usr/include/wchar.h" 2 3 4

# 1 "/usr/include/bits/wchar.h" 1 3 4
# 51 "/usr/include/wchar.h" 2 3 4
# 76 "/usr/include/wchar.h" 3 4
typedef struct
{
  int __count;
  union
  {
    wint_t __wch;
    char __wchb[4];
  } __value;
} __mbstate_t;
# 25 "/usr/include/_G_config.h" 2 3 4

typedef struct
{
  __off_t __pos;
  __mbstate_t __state;
} _G_fpos_t;
typedef struct
{
  __off64_t __pos;
  __mbstate_t __state;
} _G_fpos64_t;
# 44 "/usr/include/_G_config.h" 3 4
# 1 "/usr/include/gconv.h" 1 3 4
# 28 "/usr/include/gconv.h" 3 4
# 1 "/usr/include/wchar.h" 1 3 4
# 48 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/stddef.h" 1 3 4
# 49 "/usr/include/wchar.h" 2 3 4
# 29 "/usr/include/gconv.h" 2 3 4


# 1 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/stddef.h" 1 3 4
# 32 "/usr/include/gconv.h" 2 3 4





enum
{
  __GCONV_OK = 0,
  __GCONV_NOCONV,
  __GCONV_NODB,
  __GCONV_NOMEM,

  __GCONV_EMPTY_INPUT,
  __GCONV_FULL_OUTPUT,
  __GCONV_ILLEGAL_INPUT,
  __GCONV_INCOMPLETE_INPUT,

  __GCONV_ILLEGAL_DESCRIPTOR,
  __GCONV_INTERNAL_ERROR
};



enum
{
  __GCONV_IS_LAST = 0x0001,
  __GCONV_IGNORE_ERRORS = 0x0002
};



struct __gconv_step;
struct __gconv_step_data;
struct __gconv_loaded_object;
struct __gconv_trans_data;



typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
       __const unsigned char **, __const unsigned char *,
       unsigned char **, size_t *, int, int);


typedef wint_t (*__gconv_btowc_fct) (struct __gconv_step *, unsigned char);


typedef int (*__gconv_init_fct) (struct __gconv_step *);
typedef void (*__gconv_end_fct) (struct __gconv_step *);



typedef int (*__gconv_trans_fct) (struct __gconv_step *,
      struct __gconv_step_data *, void *,
      __const unsigned char *,
      __const unsigned char **,
      __const unsigned char *, unsigned char **,
      size_t *);


typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
       __const unsigned char *,
       unsigned char *, unsigned char *);


typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***,
     size_t *);


typedef int (*__gconv_trans_init_fct) (void **, const char *);
typedef void (*__gconv_trans_end_fct) (void *);

struct __gconv_trans_data
{

  __gconv_trans_fct __trans_fct;
  __gconv_trans_context_fct __trans_context_fct;
  __gconv_trans_end_fct __trans_end_fct;
  void *__data;
  struct __gconv_trans_data *__next;
};



struct __gconv_step
{
  struct __gconv_loaded_object *__shlib_handle;
  __const char *__modname;

  int __counter;

  char *__from_name;
  char *__to_name;

  __gconv_fct __fct;
  __gconv_btowc_fct __btowc_fct;
  __gconv_init_fct __init_fct;
  __gconv_end_fct __end_fct;



  int __min_needed_from;
  int __max_needed_from;
  int __min_needed_to;
  int __max_needed_to;


  int __stateful;

  void *__data;
};



struct __gconv_step_data
{
  unsigned char *__outbuf;
  unsigned char *__outbufend;



  int __flags;



  int __invocation_counter;



  int __internal_use;

  __mbstate_t *__statep;
  __mbstate_t __state;



  struct __gconv_trans_data *__trans;
};



typedef struct __gconv_info
{
  size_t __nsteps;
  struct __gconv_step *__steps;
  __extension__ struct __gconv_step_data __data [];
} *__gconv_t;
# 45 "/usr/include/_G_config.h" 2 3 4
typedef union
{
  struct __gconv_info __cd;
  struct
  {
    struct __gconv_info __cd;
    struct __gconv_step_data __data;
  } __combined;
} _G_iconv_t;

typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
# 33 "/usr/include/libio.h" 2 3 4
# 53 "/usr/include/libio.h" 3 4
# 1 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/stdarg.h" 1 3 4
# 43 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 54 "/usr/include/libio.h" 2 3 4
# 166 "/usr/include/libio.h" 3 4
struct _IO_jump_t; struct _IO_FILE;
# 176 "/usr/include/libio.h" 3 4
typedef void _IO_lock_t;





struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;



  int _pos;
# 199 "/usr/include/libio.h" 3 4
};


enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};
# 267 "/usr/include/libio.h" 3 4
struct _IO_FILE {
  int _flags;




  char* _IO_read_ptr;
  char* _IO_read_end;
  char* _IO_read_base;
  char* _IO_write_base;
  char* _IO_write_ptr;
  char* _IO_write_end;
  char* _IO_buf_base;
  char* _IO_buf_end;

  char *_IO_save_base;
  char *_IO_backup_base;
  char *_IO_save_end;

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;



  int _flags2;

  __off_t _old_offset;



  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];



  _IO_lock_t *_lock;
# 315 "/usr/include/libio.h" 3 4
  __off64_t _offset;





  void *__pad1;
  void *__pad2;

  int _mode;

  char _unused2[15 * sizeof (int) - 2 * sizeof (void *)];

};


typedef struct _IO_FILE _IO_FILE;


struct _IO_FILE_plus;

extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
# 354 "/usr/include/libio.h" 3 4
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);







typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
     size_t __n);







typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);


typedef int __io_close_fn (void *__cookie);
# 406 "/usr/include/libio.h" 3 4
extern int __underflow (_IO_FILE *) __attribute__ ((__nothrow__));
extern int __uflow (_IO_FILE *) __attribute__ ((__nothrow__));
extern int __overflow (_IO_FILE *, int) __attribute__ ((__nothrow__));
extern wint_t __wunderflow (_IO_FILE *) __attribute__ ((__nothrow__));
extern wint_t __wuflow (_IO_FILE *) __attribute__ ((__nothrow__));
extern wint_t __woverflow (_IO_FILE *, wint_t) __attribute__ ((__nothrow__));
# 444 "/usr/include/libio.h" 3 4
extern int _IO_getc (_IO_FILE *__fp) __attribute__ ((__nothrow__));
extern int _IO_putc (int __c, _IO_FILE *__fp) __attribute__ ((__nothrow__));
extern int _IO_feof (_IO_FILE *__fp) __attribute__ ((__nothrow__));
extern int _IO_ferror (_IO_FILE *__fp) __attribute__ ((__nothrow__));

extern int _IO_peekc_locked (_IO_FILE *__fp) __attribute__ ((__nothrow__));





extern void _IO_flockfile (_IO_FILE *) __attribute__ ((__nothrow__));
extern void _IO_funlockfile (_IO_FILE *) __attribute__ ((__nothrow__));
extern int _IO_ftrylockfile (_IO_FILE *) __attribute__ ((__nothrow__));
# 474 "/usr/include/libio.h" 3 4
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
   __gnuc_va_list, int *__restrict) __attribute__ ((__nothrow__));
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
    __gnuc_va_list) __attribute__ ((__nothrow__));
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t) __attribute__ ((__nothrow__));
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t) __attribute__ ((__nothrow__));

extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int) __attribute__ ((__nothrow__));
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int) __attribute__ ((__nothrow__));

extern void _IO_free_backup_area (_IO_FILE *) __attribute__ ((__nothrow__));
# 73 "/usr/include/stdio.h" 2 3 4
# 86 "/usr/include/stdio.h" 3 4


typedef _G_fpos_t fpos_t;




# 138 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 139 "/usr/include/stdio.h" 2 3 4



extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;









extern int remove (__const char *__filename) __attribute__ ((__nothrow__));

extern int rename (__const char *__old, __const char *__new) __attribute__ ((__nothrow__));









extern FILE *tmpfile (void);
# 180 "/usr/include/stdio.h" 3 4
extern char *tmpnam (char *__s) __attribute__ ((__nothrow__));





extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__));
# 198 "/usr/include/stdio.h" 3 4
extern char *tempnam (__const char *__dir, __const char *__pfx)
     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));








extern int fclose (FILE *__stream);




extern int fflush (FILE *__stream);

# 223 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 237 "/usr/include/stdio.h" 3 4






extern FILE *fopen (__const char *__restrict __filename,
      __const char *__restrict __modes);




extern FILE *freopen (__const char *__restrict __filename,
        __const char *__restrict __modes,
        FILE *__restrict __stream);
# 264 "/usr/include/stdio.h" 3 4

# 275 "/usr/include/stdio.h" 3 4
extern FILE *fdopen (int __fd, __const char *__modes) __attribute__ ((__nothrow__));
# 296 "/usr/include/stdio.h" 3 4



extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__));



extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
      int __modes, size_t __n) __attribute__ ((__nothrow__));





extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
         size_t __size) __attribute__ ((__nothrow__));


extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__));








extern int fprintf (FILE *__restrict __stream,
      __const char *__restrict __format, ...);




extern int printf (__const char *__restrict __format, ...);

extern int sprintf (char *__restrict __s,
      __const char *__restrict __format, ...) __attribute__ ((__nothrow__));





extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
       __gnuc_va_list __arg);




extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg);

extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
       __gnuc_va_list __arg) __attribute__ ((__nothrow__));





extern int snprintf (char *__restrict __s, size_t __maxlen,
       __const char *__restrict __format, ...)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));

extern int vsnprintf (char *__restrict __s, size_t __maxlen,
        __const char *__restrict __format, __gnuc_va_list __arg)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));

# 390 "/usr/include/stdio.h" 3 4





extern int fscanf (FILE *__restrict __stream,
     __const char *__restrict __format, ...);




extern int scanf (__const char *__restrict __format, ...);

extern int sscanf (__const char *__restrict __s,
     __const char *__restrict __format, ...) __attribute__ ((__nothrow__));

# 432 "/usr/include/stdio.h" 3 4





extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);





extern int getchar (void);

# 456 "/usr/include/stdio.h" 3 4
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 467 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);











extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);





extern int putchar (int __c);

# 500 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);







extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);






extern int getw (FILE *__stream);


extern int putw (int __w, FILE *__stream);








extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream);






extern char *gets (char *__s);

# 580 "/usr/include/stdio.h" 3 4





extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);





extern int puts (__const char *__s);






extern int ungetc (int __c, FILE *__stream);






extern size_t fread (void *__restrict __ptr, size_t __size,
       size_t __n, FILE *__restrict __stream);




extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
        size_t __n, FILE *__restrict __s);

# 633 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
         size_t __n, FILE *__restrict __stream);
extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
          size_t __n, FILE *__restrict __stream);








extern int fseek (FILE *__stream, long int __off, int __whence);




extern long int ftell (FILE *__stream);




extern void rewind (FILE *__stream);

# 688 "/usr/include/stdio.h" 3 4






extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);




extern int fsetpos (FILE *__stream, __const fpos_t *__pos);
# 711 "/usr/include/stdio.h" 3 4

# 720 "/usr/include/stdio.h" 3 4


extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__));

extern int feof (FILE *__stream) __attribute__ ((__nothrow__));

extern int ferror (FILE *__stream) __attribute__ ((__nothrow__));




extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__));
extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__));
extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__));








extern void perror (__const char *__s);






# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
# 27 "/usr/include/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern __const char *__const sys_errlist[];
# 750 "/usr/include/stdio.h" 2 3 4




extern int fileno (FILE *__stream) __attribute__ ((__nothrow__));




extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__));
# 769 "/usr/include/stdio.h" 3 4
extern FILE *popen (__const char *__command, __const char *__modes);





extern int pclose (FILE *__stream);





extern char *ctermid (char *__s) __attribute__ ((__nothrow__));
# 809 "/usr/include/stdio.h" 3 4
extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__));



extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__));


extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__));
# 830 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio.h" 1 3 4
# 33 "/usr/include/bits/stdio.h" 3 4
extern __inline int
vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg)
{
  return vfprintf (stdout, __fmt, __arg);
}


extern __inline int
getchar (void)
{
  return _IO_getc (stdin);
}




extern __inline int
getc_unlocked (FILE *__fp)
{
  return (__builtin_expect ((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end, 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}


extern __inline int
getchar_unlocked (void)
{
  return (__builtin_expect ((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end, 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}




extern __inline int
putchar (int __c)
{
  return _IO_putc (__c, stdout);
}




extern __inline int
fputc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect ((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end, 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}





extern __inline int
putc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect ((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end, 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}


extern __inline int
putchar_unlocked (int __c)
{
  return (__builtin_expect ((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end, 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}
# 111 "/usr/include/bits/stdio.h" 3 4
extern __inline int
__attribute__ ((__nothrow__)) feof_unlocked (FILE *__stream)
{
  return (((__stream)->_flags & 0x10) != 0);
}


extern __inline int
__attribute__ ((__nothrow__)) ferror_unlocked (FILE *__stream)
{
  return (((__stream)->_flags & 0x20) != 0);
}
# 831 "/usr/include/stdio.h" 2 3 4






# 30 "testglib.c" 2
# 1 "/usr/include/string.h" 1 3 4
# 28 "/usr/include/string.h" 3 4





# 1 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/stddef.h" 1 3 4
# 34 "/usr/include/string.h" 2 3 4




extern void *memcpy (void *__restrict __dest,
       __const void *__restrict __src, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));


extern void *memmove (void *__dest, __const void *__src, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));






extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
        int __c, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));





extern void *memset (void *__s, int __c, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern void *memchr (__const void *__s, int __c, size_t __n)
      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

# 82 "/usr/include/string.h" 3 4


extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strncpy (char *__restrict __dest,
        __const char *__restrict __src, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));


extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
        size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strcmp (__const char *__s1, __const char *__s2)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strcoll (__const char *__s1, __const char *__s2)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern size_t strxfrm (char *__restrict __dest,
         __const char *__restrict __src, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));

# 130 "/usr/include/string.h" 3 4
extern char *strdup (__const char *__s)
     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
# 165 "/usr/include/string.h" 3 4


extern char *strchr (__const char *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern char *strrchr (__const char *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

# 181 "/usr/include/string.h" 3 4



extern size_t strcspn (__const char *__s, __const char *__reject)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern size_t strspn (__const char *__s, __const char *__accept)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strpbrk (__const char *__s, __const char *__accept)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strstr (__const char *__haystack, __const char *__needle)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));




extern char *__strtok_r (char *__restrict __s,
    __const char *__restrict __delim,
    char **__restrict __save_ptr)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));

extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
         char **__restrict __save_ptr)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
# 240 "/usr/include/string.h" 3 4


extern size_t strlen (__const char *__s)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

# 254 "/usr/include/string.h" 3 4


extern char *strerror (int __errnum) __attribute__ ((__nothrow__));

# 281 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));





extern void __bzero (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));



extern void bcopy (__const void *__src, void *__dest, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));


extern void bzero (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern char *index (__const char *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern char *rindex (__const char *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));



extern int ffs (int __i) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
# 325 "/usr/include/string.h" 3 4
extern int strcasecmp (__const char *__s1, __const char *__s2)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 348 "/usr/include/string.h" 3 4
extern char *strsep (char **__restrict __stringp,
       __const char *__restrict __delim)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
# 414 "/usr/include/string.h" 3 4
# 1 "/usr/include/bits/string.h" 1 3 4
# 415 "/usr/include/string.h" 2 3 4


# 1 "/usr/include/bits/string2.h" 1 3 4
# 80 "/usr/include/bits/string2.h" 3 4
typedef struct { unsigned char __arr[2]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR2;
typedef struct { unsigned char __arr[3]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR3;
typedef struct { unsigned char __arr[4]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR4;
typedef struct { unsigned char __arr[5]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR5;
typedef struct { unsigned char __arr[6]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR6;
typedef struct { unsigned char __arr[7]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR7;
typedef struct { unsigned char __arr[8]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR8;
# 394 "/usr/include/bits/string2.h" 3 4
extern void *__rawmemchr (const void *__s, int __c);
# 969 "/usr/include/bits/string2.h" 3 4
extern __inline size_t __strcspn_c1 (__const char *__s, int __reject);
extern __inline size_t
__strcspn_c1 (__const char *__s, int __reject)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject)
    ++__result;
  return __result;
}

extern __inline size_t __strcspn_c2 (__const char *__s, int __reject1,
         int __reject2);
extern __inline size_t
__strcspn_c2 (__const char *__s, int __reject1, int __reject2)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject1
  && __s[__result] != __reject2)
    ++__result;
  return __result;
}

extern __inline size_t __strcspn_c3 (__const char *__s, int __reject1,
         int __reject2, int __reject3);
extern __inline size_t
__strcspn_c3 (__const char *__s, int __reject1, int __reject2,
       int __reject3)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject1
  && __s[__result] != __reject2 && __s[__result] != __reject3)
    ++__result;
  return __result;
}
# 1045 "/usr/include/bits/string2.h" 3 4
extern __inline size_t __strspn_c1 (__const char *__s, int __accept);
extern __inline size_t
__strspn_c1 (__const char *__s, int __accept)
{
  register size_t __result = 0;

  while (__s[__result] == __accept)
    ++__result;
  return __result;
}

extern __inline size_t __strspn_c2 (__const char *__s, int __accept1,
        int __accept2);
extern __inline size_t
__strspn_c2 (__const char *__s, int __accept1, int __accept2)
{
  register size_t __result = 0;

  while (__s[__result] == __accept1 || __s[__result] == __accept2)
    ++__result;
  return __result;
}

extern __inline size_t __strspn_c3 (__const char *__s, int __accept1,
        int __accept2, int __accept3);
extern __inline size_t
__strspn_c3 (__const char *__s, int __accept1, int __accept2, int __accept3)
{
  register size_t __result = 0;

  while (__s[__result] == __accept1 || __s[__result] == __accept2
  || __s[__result] == __accept3)
    ++__result;
  return __result;
}
# 1121 "/usr/include/bits/string2.h" 3 4
extern __inline char *__strpbrk_c2 (__const char *__s, int __accept1,
         int __accept2);
extern __inline char *
__strpbrk_c2 (__const char *__s, int __accept1, int __accept2)
{

  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2)
    ++__s;
  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
}

extern __inline char *__strpbrk_c3 (__const char *__s, int __accept1,
         int __accept2, int __accept3);
extern __inline char *
__strpbrk_c3 (__const char *__s, int __accept1, int __accept2,
       int __accept3)
{

  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
  && *__s != __accept3)
    ++__s;
  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
}
# 1173 "/usr/include/bits/string2.h" 3 4
extern __inline char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
extern __inline char *
__strtok_r_1c (char *__s, char __sep, char **__nextp)
{
  char *__result;
  if (__s == ((void *)0))
    __s = *__nextp;
  while (*__s == __sep)
    ++__s;
  __result = ((void *)0);
  if (*__s != '\0')
    {
      __result = __s++;
      while (*__s != '\0')
 if (*__s++ == __sep)
   {
     __s[-1] = '\0';
     break;
   }
      *__nextp = __s;
    }
  return __result;
}
# 1205 "/usr/include/bits/string2.h" 3 4
extern char *__strsep_g (char **__stringp, __const char *__delim);
# 1223 "/usr/include/bits/string2.h" 3 4
extern __inline char *__strsep_1c (char **__s, char __reject);
extern __inline char *
__strsep_1c (char **__s, char __reject)
{
  register char *__retval = *__s;
  if (__retval != ((void *)0) && (*__s = (__extension__ (__builtin_constant_p (__reject) && !__builtin_constant_p (__retval) && (__reject) == '\0' ? (char *) __rawmemchr (__retval, __reject) : __builtin_strchr (__retval, __reject)))) != ((void *)0))
    *(*__s)++ = '\0';
  return __retval;
}

extern __inline char *__strsep_2c (char **__s, char __reject1, char __reject2);
extern __inline char *
__strsep_2c (char **__s, char __reject1, char __reject2)
{
  register char *__retval = *__s;
  if (__retval != ((void *)0))
    {
      register char *__cp = __retval;
      while (1)
 {
   if (*__cp == '\0')
     {
       __cp = ((void *)0);
   break;
     }
   if (*__cp == __reject1 || *__cp == __reject2)
     {
       *__cp++ = '\0';
       break;
     }
   ++__cp;
 }
      *__s = __cp;
    }
  return __retval;
}

extern __inline char *__strsep_3c (char **__s, char __reject1, char __reject2,
       char __reject3);
extern __inline char *
__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
{
  register char *__retval = *__s;
  if (__retval != ((void *)0))
    {
      register char *__cp = __retval;
      while (1)
 {
   if (*__cp == '\0')
     {
       __cp = ((void *)0);
   break;
     }
   if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3)
     {
       *__cp++ = '\0';
       break;
     }
   ++__cp;
 }
      *__s = __cp;
    }
  return __retval;
}
# 1299 "/usr/include/bits/string2.h" 3 4
# 1 "/usr/include/stdlib.h" 1 3 4
# 33 "/usr/include/stdlib.h" 3 4
# 1 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/stddef.h" 1 3 4
# 34 "/usr/include/stdlib.h" 2 3 4


# 582 "/usr/include/stdlib.h" 3 4


extern void *malloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));

extern void *calloc (size_t __nmemb, size_t __size)
     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));

# 961 "/usr/include/stdlib.h" 3 4

# 1300 "/usr/include/bits/string2.h" 2 3 4




extern char *__strdup (__const char *__string) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
# 1323 "/usr/include/bits/string2.h" 3 4
extern char *__strndup (__const char *__string, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
# 418 "/usr/include/string.h" 2 3 4
# 426 "/usr/include/string.h" 3 4

# 31 "testglib.c" 2
# 1 "glib.h" 1
# 66 "glib.h"
# 1 "./glibconfig.h" 1
# 13 "./glibconfig.h"
# 1 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/limits.h" 1 3 4
# 11 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/limits.h" 3 4
# 1 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/syslimits.h" 1 3 4






# 1 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/limits.h" 1 3 4
# 122 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 144 "/usr/include/limits.h" 3 4
# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
# 153 "/usr/include/bits/posix1_lim.h" 3 4
# 1 "/usr/include/bits/local_lim.h" 1 3 4
# 36 "/usr/include/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 37 "/usr/include/bits/local_lim.h" 2 3 4
# 154 "/usr/include/bits/posix1_lim.h" 2 3 4
# 145 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
# 149 "/usr/include/limits.h" 2 3 4
# 123 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/limits.h" 2 3 4
# 8 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/syslimits.h" 2 3 4
# 12 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/limits.h" 2 3 4
# 14 "./glibconfig.h" 2
# 1 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/float.h" 1 3 4
# 15 "./glibconfig.h" 2
# 28 "./glibconfig.h"
typedef signed char gint8;
typedef unsigned char guint8;
typedef signed short gint16;
typedef unsigned short guint16;
typedef signed int gint32;
typedef unsigned int guint32;


typedef signed long gint64;
typedef unsigned long guint64;
# 72 "./glibconfig.h"
typedef struct _GStaticMutex GStaticMutex;
struct _GStaticMutex
{
  struct _GMutex *runtime_mutex;
  union {
    char pad[40];
    double dummy_double;
    void *dummy_pointer;
    long dummy_long;
  } aligned_pad_u;
};
# 67 "glib.h" 2



# 1 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/stdarg.h" 1 3 4
# 105 "/usr/lib/gcc/powerpc64-unknown-linux-gnu/3.4.3/include/stdarg.h" 3 4
typedef __gnuc_va_list va_list;
# 71 "glib.h" 2
# 473 "glib.h"
typedef char gchar;
typedef short gshort;
typedef long glong;
typedef int gint;
typedef gint gboolean;

typedef unsigned char guchar;
typedef unsigned short gushort;
typedef unsigned long gulong;
typedef unsigned int guint;

typedef float gfloat;
typedef double gdouble;
# 498 "glib.h"
typedef void* gpointer;
typedef const void *gconstpointer;


typedef gint32 gssize;
typedef guint32 gsize;
typedef guint32 GQuark;
typedef gint32 GTime;
# 676 "glib.h"
extern const guint glib_major_version;
extern const guint glib_minor_version;
extern const guint glib_micro_version;
extern const guint glib_interface_age;
extern const guint glib_binary_age;
# 690 "glib.h"
typedef struct _GAllocator GAllocator;
typedef struct _GArray GArray;
typedef struct _GByteArray GByteArray;
typedef struct _GCache GCache;
typedef struct _GCompletion GCompletion;
typedef struct _GData GData;
typedef struct _GDebugKey GDebugKey;
typedef struct _GHashTable GHashTable;
typedef struct _GHook GHook;
typedef struct _GHookList GHookList;
typedef struct _GList GList;
typedef struct _GMemChunk GMemChunk;
typedef struct _GNode GNode;
typedef struct _GPtrArray GPtrArray;
typedef struct _GRelation GRelation;
typedef struct _GScanner GScanner;
typedef struct _GScannerConfig GScannerConfig;
typedef struct _GSList GSList;
typedef struct _GString GString;
typedef struct _GStringChunk GStringChunk;
typedef struct _GTimer GTimer;
typedef struct _GTree GTree;
typedef struct _GTuples GTuples;
typedef union _GTokenValue GTokenValue;
typedef struct _GIOChannel GIOChannel;


typedef enum
{
  G_TRAVERSE_LEAFS = 1 << 0,
  G_TRAVERSE_NON_LEAFS = 1 << 1,
  G_TRAVERSE_ALL = G_TRAVERSE_LEAFS | G_TRAVERSE_NON_LEAFS,
  G_TRAVERSE_MASK = 0x03
} GTraverseFlags;


typedef enum
{
  G_IN_ORDER,
  G_PRE_ORDER,
  G_POST_ORDER,
  G_LEVEL_ORDER
} GTraverseType;
# 741 "glib.h"
typedef enum
{

  G_LOG_FLAG_RECURSION = 1 << 0,
  G_LOG_FLAG_FATAL = 1 << 1,


  G_LOG_LEVEL_ERROR = 1 << 2,
  G_LOG_LEVEL_CRITICAL = 1 << 3,
  G_LOG_LEVEL_WARNING = 1 << 4,
  G_LOG_LEVEL_MESSAGE = 1 << 5,
  G_LOG_LEVEL_INFO = 1 << 6,
  G_LOG_LEVEL_DEBUG = 1 << 7,

  G_LOG_LEVEL_MASK = ~(G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL)
} GLogLevelFlags;





typedef gpointer (*GCacheNewFunc) (gpointer key);
typedef gpointer (*GCacheDupFunc) (gpointer value);
typedef void (*GCacheDestroyFunc) (gpointer value);
typedef gint (*GCompareFunc) (gconstpointer a,
       gconstpointer b);
typedef gchar* (*GCompletionFunc) (gpointer);
typedef void (*GDestroyNotify) (gpointer data);
typedef void (*GDataForeachFunc) (GQuark key_id,
       gpointer data,
       gpointer user_data);
typedef void (*GFunc) (gpointer data,
       gpointer user_data);
typedef guint (*GHashFunc) (gconstpointer key);
typedef void (*GFreeFunc) (gpointer data);
typedef void (*GHFunc) (gpointer key,
       gpointer value,
       gpointer user_data);
typedef gboolean (*GHRFunc) (gpointer key,
       gpointer value,
       gpointer user_data);
typedef gint (*GHookCompareFunc) (GHook *new_hook,
       GHook *sibling);
typedef gboolean (*GHookFindFunc) (GHook *hook,
       gpointer data);
typedef void (*GHookMarshaller) (GHook *hook,
       gpointer data);
typedef gboolean (*GHookCheckMarshaller) (GHook *hook,
       gpointer data);
typedef void (*GHookFunc) (gpointer data);
typedef gboolean (*GHookCheckFunc) (gpointer data);
typedef void (*GHookFreeFunc) (GHookList *hook_list,
       GHook *hook);
typedef void (*GLogFunc) (const gchar *log_domain,
       GLogLevelFlags log_level,
       const gchar *message,
       gpointer user_data);
typedef gboolean (*GNodeTraverseFunc) (GNode *node,
       gpointer data);
typedef void (*GNodeForeachFunc) (GNode *node,
       gpointer data);
typedef gint (*GSearchFunc) (gpointer key,
       gpointer data);
typedef void (*GScannerMsgFunc) (GScanner *scanner,
       gchar *message,
       gint error);
typedef gint (*GTraverseFunc) (gpointer key,
       gpointer value,
       gpointer data);
typedef void (*GVoidFunc) (void);


struct _GList
{
  gpointer data;
  GList *next;
  GList *prev;
};

struct _GSList
{
  gpointer data;
  GSList *next;
};

struct _GString
{
  gchar *str;
  gint len;
};

struct _GArray
{
  gchar *data;
  guint len;
};

struct _GByteArray
{
  guint8 *data;
  guint len;
};

struct _GPtrArray
{
  gpointer *pdata;
  guint len;
};

struct _GTuples
{
  guint len;
};

struct _GDebugKey
{
  gchar *key;
  guint value;
};




void g_list_push_allocator (GAllocator *allocator);
void g_list_pop_allocator (void);
GList* g_list_alloc (void);
void g_list_free (GList *list);
void g_list_free_1 (GList *list);
GList* g_list_append (GList *list,
     gpointer data);
GList* g_list_prepend (GList *list,
     gpointer data);
GList* g_list_insert (GList *list,
     gpointer data,
     gint position);
GList* g_list_insert_sorted (GList *list,
     gpointer data,
     GCompareFunc func);
GList* g_list_concat (GList *list1,
     GList *list2);
GList* g_list_remove (GList *list,
     gpointer data);
GList* g_list_remove_link (GList *list,
     GList *llink);
GList* g_list_reverse (GList *list);
GList* g_list_copy (GList *list);
GList* g_list_nth (GList *list,
     guint n);
GList* g_list_find (GList *list,
     gpointer data);
GList* g_list_find_custom (GList *list,
     gpointer data,
     GCompareFunc func);
gint g_list_position (GList *list,
     GList *llink);
gint g_list_index (GList *list,
     gpointer data);
GList* g_list_last (GList *list);
GList* g_list_first (GList *list);
guint g_list_length (GList *list);
void g_list_foreach (GList *list,
     GFunc func,
     gpointer user_data);
GList* g_list_sort (GList *list,
                   GCompareFunc compare_func);
gpointer g_list_nth_data (GList *list,
     guint n);






void g_slist_push_allocator (GAllocator *allocator);
void g_slist_pop_allocator (void);
GSList* g_slist_alloc (void);
void g_slist_free (GSList *list);
void g_slist_free_1 (GSList *list);
GSList* g_slist_append (GSList *list,
     gpointer data);
GSList* g_slist_prepend (GSList *list,
     gpointer data);
GSList* g_slist_insert (GSList *list,
     gpointer data,
     gint position);
GSList* g_slist_insert_sorted (GSList *list,
     gpointer data,
     GCompareFunc func);
GSList* g_slist_concat (GSList *list1,
     GSList *list2);
GSList* g_slist_remove (GSList *list,
     gpointer data);
GSList* g_slist_remove_link (GSList *list,
     GSList *llink);
GSList* g_slist_reverse (GSList *list);
GSList* g_slist_copy (GSList *list);
GSList* g_slist_nth (GSList *list,
     guint n);
GSList* g_slist_find (GSList *list,
     gpointer data);
GSList* g_slist_find_custom (GSList *list,
     gpointer data,
     GCompareFunc func);
gint g_slist_position (GSList *list,
     GSList *llink);
gint g_slist_index (GSList *list,
     gpointer data);
GSList* g_slist_last (GSList *list);
guint g_slist_length (GSList *list);
void g_slist_foreach (GSList *list,
     GFunc func,
     gpointer user_data);
GSList* g_slist_sort (GSList *list,
                   GCompareFunc compare_func);
gpointer g_slist_nth_data (GSList *list,
     guint n);





GHashTable* g_hash_table_new (GHashFunc hash_func,
      GCompareFunc key_compare_func);
void g_hash_table_destroy (GHashTable *hash_table);
void g_hash_table_insert (GHashTable *hash_table,
      gpointer key,
      gpointer value);
void g_hash_table_remove (GHashTable *hash_table,
      gconstpointer key);
gpointer g_hash_table_lookup (GHashTable *hash_table,
      gconstpointer key);
gboolean g_hash_table_lookup_extended(GHashTable *hash_table,
      gconstpointer lookup_key,
      gpointer *orig_key,
      gpointer *value);
void g_hash_table_freeze (GHashTable *hash_table);
void g_hash_table_thaw (GHashTable *hash_table);
void g_hash_table_foreach (GHashTable *hash_table,
      GHFunc func,
      gpointer user_data);
guint g_hash_table_foreach_remove (GHashTable *hash_table,
      GHRFunc func,
      gpointer user_data);
guint g_hash_table_size (GHashTable *hash_table);




GCache* g_cache_new (GCacheNewFunc value_new_func,
    GCacheDestroyFunc value_destroy_func,
    GCacheDupFunc key_dup_func,
    GCacheDestroyFunc key_destroy_func,
    GHashFunc hash_key_func,
    GHashFunc hash_value_func,
    GCompareFunc key_compare_func);
void g_cache_destroy (GCache *cache);
gpointer g_cache_insert (GCache *cache,
    gpointer key);
void g_cache_remove (GCache *cache,
    gpointer value);
void g_cache_key_foreach (GCache *cache,
    GHFunc func,
    gpointer user_data);
void g_cache_value_foreach (GCache *cache,
    GHFunc func,
    gpointer user_data);




GTree* g_tree_new (GCompareFunc key_compare_func);
void g_tree_destroy (GTree *tree);
void g_tree_insert (GTree *tree,
     gpointer key,
     gpointer value);
void g_tree_remove (GTree *tree,
     gpointer key);
gpointer g_tree_lookup (GTree *tree,
     gpointer key);
void g_tree_traverse (GTree *tree,
     GTraverseFunc traverse_func,
     GTraverseType traverse_type,
     gpointer data);
gpointer g_tree_search (GTree *tree,
     GSearchFunc search_func,
     gpointer data);
gint g_tree_height (GTree *tree);
gint g_tree_nnodes (GTree *tree);





struct _GNode
{
  gpointer data;
  GNode *next;
  GNode *prev;
  GNode *parent;
  GNode *children;
};






void g_node_push_allocator (GAllocator *allocator);
void g_node_pop_allocator (void);
GNode* g_node_new (gpointer data);
void g_node_destroy (GNode *root);
void g_node_unlink (GNode *node);
GNode* g_node_insert (GNode *parent,
     gint position,
     GNode *node);
GNode* g_node_insert_before (GNode *parent,
     GNode *sibling,
     GNode *node);
GNode* g_node_prepend (GNode *parent,
     GNode *node);
guint g_node_n_nodes (GNode *root,
     GTraverseFlags flags);
GNode* g_node_get_root (GNode *node);
gboolean g_node_is_ancestor (GNode *node,
     GNode *descendant);
guint g_node_depth (GNode *node);
GNode* g_node_find (GNode *root,
     GTraverseType order,
     GTraverseFlags flags,
     gpointer data);
# 1089 "glib.h"
void g_node_traverse (GNode *root,
     GTraverseType order,
     GTraverseFlags flags,
     gint max_depth,
     GNodeTraverseFunc func,
     gpointer data);






guint g_node_max_height (GNode *root);

void g_node_children_foreach (GNode *node,
      GTraverseFlags flags,
      GNodeForeachFunc func,
      gpointer data);
void g_node_reverse_children (GNode *node);
guint g_node_n_children (GNode *node);
GNode* g_node_nth_child (GNode *node,
      guint n);
GNode* g_node_last_child (GNode *node);
GNode* g_node_find_child (GNode *node,
      GTraverseFlags flags,
      gpointer data);
gint g_node_child_position (GNode *node,
      GNode *child);
gint g_node_child_index (GNode *node,
      gpointer data);

GNode* g_node_first_sibling (GNode *node);
GNode* g_node_last_sibling (GNode *node);
# 1134 "glib.h"
typedef enum
{
  G_HOOK_FLAG_ACTIVE = 1 << 0,
  G_HOOK_FLAG_IN_CALL = 1 << 1,
  G_HOOK_FLAG_MASK = 0x0f
} GHookFlagMask;



struct _GHookList
{
  guint seq_id;
  guint hook_size;
  guint is_setup : 1;
  GHook *hooks;
  GMemChunk *hook_memchunk;
  GHookFreeFunc hook_free;
  GHookFreeFunc hook_destroy;
};

struct _GHook
{
  gpointer data;
  GHook *next;
  GHook *prev;
  guint ref_count;
  guint hook_id;
  guint flags;
  gpointer func;
  GDestroyNotify destroy;
};
# 1177 "glib.h"
void g_hook_list_init (GHookList *hook_list,
      guint hook_size);
void g_hook_list_clear (GHookList *hook_list);
GHook* g_hook_alloc (GHookList *hook_list);
void g_hook_free (GHookList *hook_list,
      GHook *hook);
void g_hook_ref (GHookList *hook_list,
      GHook *hook);
void g_hook_unref (GHookList *hook_list,
      GHook *hook);
gboolean g_hook_destroy (GHookList *hook_list,
      guint hook_id);
void g_hook_destroy_link (GHookList *hook_list,
      GHook *hook);
void g_hook_prepend (GHookList *hook_list,
      GHook *hook);
void g_hook_insert_before (GHookList *hook_list,
      GHook *sibling,
      GHook *hook);
void g_hook_insert_sorted (GHookList *hook_list,
      GHook *hook,
      GHookCompareFunc func);
GHook* g_hook_get (GHookList *hook_list,
      guint hook_id);
GHook* g_hook_find (GHookList *hook_list,
      gboolean need_valids,
      GHookFindFunc func,
      gpointer data);
GHook* g_hook_find_data (GHookList *hook_list,
      gboolean need_valids,
      gpointer data);
GHook* g_hook_find_func (GHookList *hook_list,
      gboolean need_valids,
      gpointer func);
GHook* g_hook_find_func_data (GHookList *hook_list,
      gboolean need_valids,
      gpointer func,
      gpointer data);

GHook* g_hook_first_valid (GHookList *hook_list,
      gboolean may_be_in_call);



GHook* g_hook_next_valid (GHookList *hook_list,
      GHook *hook,
      gboolean may_be_in_call);


gint g_hook_compare_ids (GHook *new_hook,
      GHook *sibling);







void g_hook_list_invoke (GHookList *hook_list,
      gboolean may_recurse);



void g_hook_list_invoke_check (GHookList *hook_list,
      gboolean may_recurse);


void g_hook_list_marshal (GHookList *hook_list,
      gboolean may_recurse,
      GHookMarshaller marshaller,
      gpointer data);
void g_hook_list_marshal_check (GHookList *hook_list,
      gboolean may_recurse,
      GHookCheckMarshaller marshaller,
      gpointer data);
# 1263 "glib.h"
void g_on_error_query (const gchar *prg_name);
void g_on_error_stack_trace (const gchar *prg_name);




extern const gchar *g_log_domain_glib;
guint g_log_set_handler (const gchar *log_domain,
      GLogLevelFlags log_levels,
      GLogFunc log_func,
      gpointer user_data);
void g_log_remove_handler (const gchar *log_domain,
      guint handler_id);
void g_log_default_handler (const gchar *log_domain,
      GLogLevelFlags log_level,
      const gchar *message,
      gpointer unused_data);
void g_log (const gchar *log_domain,
      GLogLevelFlags log_level,
      const gchar *format,
      ...) __attribute__((format (printf, 3, 4)));
void g_logv (const gchar *log_domain,
      GLogLevelFlags log_level,
      const gchar *format,
      va_list args);
GLogLevelFlags g_log_set_fatal_mask (const gchar *log_domain,
      GLogLevelFlags fatal_mask);
GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask);
# 1334 "glib.h"
typedef void (*GPrintFunc) (const gchar *string);
void g_print (const gchar *format,
      ...) __attribute__((format (printf, 1, 2)));
GPrintFunc g_set_print_handler (GPrintFunc func);
void g_printerr (const gchar *format,
      ...) __attribute__((format (printf, 1, 2)));
GPrintFunc g_set_printerr_handler (GPrintFunc func);


typedef void (*GErrorFunc) (const gchar *str);
typedef void (*GWarningFunc) (const gchar *str);
GErrorFunc g_set_error_handler (GErrorFunc func);
GWarningFunc g_set_warning_handler (GWarningFunc func);
GPrintFunc g_set_message_handler (GPrintFunc func);
# 1361 "glib.h"
gpointer g_malloc (gulong size);
gpointer g_malloc0 (gulong size);
gpointer g_realloc (gpointer mem,
   gulong size);
void g_free (gpointer mem);



void g_mem_profile (void);
void g_mem_check (gpointer mem);



GAllocator* g_allocator_new (const gchar *name,
          guint n_preallocs);
void g_allocator_free (GAllocator *allocator);
# 1405 "glib.h"
GMemChunk* g_mem_chunk_new (gchar *name,
    gint atom_size,
    gulong area_size,
    gint type);
void g_mem_chunk_destroy (GMemChunk *mem_chunk);
gpointer g_mem_chunk_alloc (GMemChunk *mem_chunk);
gpointer g_mem_chunk_alloc0 (GMemChunk *mem_chunk);
void g_mem_chunk_free (GMemChunk *mem_chunk,
    gpointer mem);
void g_mem_chunk_clean (GMemChunk *mem_chunk);
void g_mem_chunk_reset (GMemChunk *mem_chunk);
void g_mem_chunk_print (GMemChunk *mem_chunk);
void g_mem_chunk_info (void);
# 1427 "glib.h"
void g_blow_chunks (void);




GTimer* g_timer_new (void);
void g_timer_destroy (GTimer *timer);
void g_timer_start (GTimer *timer);
void g_timer_stop (GTimer *timer);
void g_timer_reset (GTimer *timer);
gdouble g_timer_elapsed (GTimer *timer,
    gulong *microseconds);






gchar* g_strdelimit (gchar *string,
     const gchar *delimiters,
     gchar new_delimiter);
gdouble g_strtod (const gchar *nptr,
     gchar **endptr);
gchar* g_strerror (gint errnum);
gchar* g_strsignal (gint signum);
gint g_strcasecmp (const gchar *s1,
     const gchar *s2);
gint g_strncasecmp (const gchar *s1,
     const gchar *s2,
     guint n);
void g_strdown (gchar *string);
void g_strup (gchar *string);
void g_strreverse (gchar *string);

gchar* g_strchug (gchar *string);

gchar* g_strchomp (gchar *string);






gchar* g_strdup (const gchar *str);
gchar* g_strdup_printf (const gchar *format,
     ...) __attribute__((format (printf, 1, 2)));
gchar* g_strdup_vprintf (const gchar *format,
     va_list args);
gchar* g_strndup (const gchar *str,
     guint n);
gchar* g_strnfill (guint length,
     gchar fill_char);
gchar* g_strconcat (const gchar *string1,
     ...);
gchar* g_strjoin (const gchar *separator,
     ...);
gchar* g_strescape (gchar *string);
gpointer g_memdup (gconstpointer mem,
     guint byte_size);
# 1494 "glib.h"
gchar** g_strsplit (const gchar *string,
     const gchar *delimiter,
     gint max_tokens);
gchar* g_strjoinv (const gchar *separator,
     gchar **str_array);
void g_strfreev (gchar **str_array);





guint g_printf_string_upper_bound (const gchar* format,
         va_list args);




gchar* g_get_user_name (void);
gchar* g_get_real_name (void);
gchar* g_get_home_dir (void);
gchar* g_get_tmp_dir (void);
gchar* g_get_prgname (void);
void g_set_prgname (const gchar *prgname);




guint g_parse_debug_string (const gchar *string,
     GDebugKey *keys,
     guint nkeys);
gint g_snprintf (gchar *string,
     gulong n,
     gchar const *format,
     ...) __attribute__((format (printf, 3, 4)));
gint g_vsnprintf (gchar *string,
     gulong n,
     gchar const *format,
     va_list args);
gchar* g_basename (const gchar *file_name);

gboolean g_path_is_absolute (const gchar *file_name);

gchar* g_path_skip_root (gchar *file_name);


gchar* g_dirname (const gchar *file_name);
gchar* g_get_current_dir (void);
gchar* g_getenv (const gchar *variable);







void g_atexit (GVoidFunc func);




extern inline gint g_bit_nth_lsf (guint32 mask,
           gint nth_bit);

extern inline gint
g_bit_nth_lsf (guint32 mask,
        gint nth_bit)
{
  do
    {
      nth_bit++;
      if (mask & (1 << (guint) nth_bit))
 return nth_bit;
    }
  while (nth_bit < 32);
  return -1;
}


extern inline gint g_bit_nth_msf (guint32 mask,
           gint nth_bit);

extern inline gint
g_bit_nth_msf (guint32 mask,
        gint nth_bit)
{
  if (nth_bit < 0)
    nth_bit = 32;
  do
    {
      nth_bit--;
      if (mask & (1 << (guint) nth_bit))
 return nth_bit;
    }
  while (nth_bit > 0);
  return -1;
}


extern inline guint g_bit_storage (guint number);

extern inline guint
g_bit_storage (guint number)
{
  register guint n_bits = 0;

  do
    {
      n_bits++;
      number >>= 1;
    }
  while (number);
  return n_bits;
}




GStringChunk* g_string_chunk_new (gint size);
void g_string_chunk_free (GStringChunk *chunk);
gchar* g_string_chunk_insert (GStringChunk *chunk,
         const gchar *string);
gchar* g_string_chunk_insert_const (GStringChunk *chunk,
         const gchar *string);




GString* g_string_new (const gchar *init);
GString* g_string_sized_new (guint dfl_size);
void g_string_free (GString *string,
        gint free_segment);
GString* g_string_assign (GString *lval,
        const gchar *rval);
GString* g_string_truncate (GString *string,
        gint len);
GString* g_string_append (GString *string,
        const gchar *val);
GString* g_string_append_c (GString *string,
        gchar c);
GString* g_string_prepend (GString *string,
        const gchar *val);
GString* g_string_prepend_c (GString *string,
        gchar c);
GString* g_string_insert (GString *string,
        gint pos,
        const gchar *val);
GString* g_string_insert_c (GString *string,
        gint pos,
        gchar c);
GString* g_string_erase (GString *string,
        gint pos,
        gint len);
GString* g_string_down (GString *string);
GString* g_string_up (GString *string);
void g_string_sprintf (GString *string,
        const gchar *format,
        ...) __attribute__((format (printf, 2, 3)));
void g_string_sprintfa (GString *string,
        const gchar *format,
        ...) __attribute__((format (printf, 2, 3)));
# 1666 "glib.h"
GArray* g_array_new (gboolean zero_terminated,
       gboolean clear,
       guint element_size);
void g_array_free (GArray *array,
       gboolean free_segment);
GArray* g_array_append_vals (GArray *array,
       gconstpointer data,
       guint len);
GArray* g_array_prepend_vals (GArray *array,
       gconstpointer data,
       guint len);
GArray* g_array_insert_vals (GArray *array,
       guint index,
       gconstpointer data,
       guint len);
GArray* g_array_set_size (GArray *array,
       guint length);
GArray* g_array_remove_index (GArray *array,
       guint index);
GArray* g_array_remove_index_fast (GArray *array,
       guint index);







GPtrArray* g_ptr_array_new (void);
void g_ptr_array_free (GPtrArray *array,
         gboolean free_seg);
void g_ptr_array_set_size (GPtrArray *array,
         gint length);
gpointer g_ptr_array_remove_index (GPtrArray *array,
         guint index);
gpointer g_ptr_array_remove_index_fast (GPtrArray *array,
         guint index);
gboolean g_ptr_array_remove (GPtrArray *array,
         gpointer data);
gboolean g_ptr_array_remove_fast (GPtrArray *array,
         gpointer data);
void g_ptr_array_add (GPtrArray *array,
         gpointer data);





GByteArray* g_byte_array_new (void);
void g_byte_array_free (GByteArray *array,
         gboolean free_segment);
GByteArray* g_byte_array_append (GByteArray *array,
         const guint8 *data,
         guint len);
GByteArray* g_byte_array_prepend (GByteArray *array,
         const guint8 *data,
         guint len);
GByteArray* g_byte_array_set_size (GByteArray *array,
         guint length);
GByteArray* g_byte_array_remove_index (GByteArray *array,
         guint index);
GByteArray* g_byte_array_remove_index_fast (GByteArray *array,
         guint index);




gint g_str_equal (gconstpointer v,
     gconstpointer v2);
guint g_str_hash (gconstpointer v);

gint g_int_equal (gconstpointer v,
     gconstpointer v2);
guint g_int_hash (gconstpointer v);







guint g_direct_hash (gconstpointer v);
gint g_direct_equal (gconstpointer v,
        gconstpointer v2);




GQuark g_quark_try_string (const gchar *string);
GQuark g_quark_from_static_string (const gchar *string);
GQuark g_quark_from_string (const gchar *string);
gchar* g_quark_to_string (GQuark quark);





void g_datalist_init (GData **datalist);
void g_datalist_clear (GData **datalist);
gpointer g_datalist_id_get_data (GData **datalist,
       GQuark key_id);
void g_datalist_id_set_data_full (GData **datalist,
       GQuark key_id,
       gpointer data,
       GDestroyNotify destroy_func);
void g_datalist_id_remove_no_notify (GData **datalist,
       GQuark key_id);
void g_datalist_foreach (GData **datalist,
       GDataForeachFunc func,
       gpointer user_data);
# 1795 "glib.h"
void g_dataset_destroy (gconstpointer dataset_location);
gpointer g_dataset_id_get_data (gconstpointer dataset_location,
      GQuark key_id);
void g_dataset_id_set_data_full (gconstpointer dataset_location,
      GQuark key_id,
      gpointer data,
      GDestroyNotify destroy_func);
void g_dataset_id_remove_no_notify (gconstpointer dataset_location,
      GQuark key_id);
void g_dataset_foreach (gconstpointer dataset_location,
      GDataForeachFunc func,
      gpointer user_data);
# 1839 "glib.h"
typedef enum
{
  G_ERR_UNKNOWN,
  G_ERR_UNEXP_EOF,
  G_ERR_UNEXP_EOF_IN_STRING,
  G_ERR_UNEXP_EOF_IN_COMMENT,
  G_ERR_NON_DIGIT_IN_CONST,
  G_ERR_DIGIT_RADIX,
  G_ERR_FLOAT_RADIX,
  G_ERR_FLOAT_MALFORMED
} GErrorType;


typedef enum
{
  G_TOKEN_EOF = 0,

  G_TOKEN_LEFT_PAREN = '(',
  G_TOKEN_RIGHT_PAREN = ')',
  G_TOKEN_LEFT_CURLY = '{',
  G_TOKEN_RIGHT_CURLY = '}',
  G_TOKEN_LEFT_BRACE = '[',
  G_TOKEN_RIGHT_BRACE = ']',
  G_TOKEN_EQUAL_SIGN = '=',
  G_TOKEN_COMMA = ',',

  G_TOKEN_NONE = 256,

  G_TOKEN_ERROR,

  G_TOKEN_CHAR,
  G_TOKEN_BINARY,
  G_TOKEN_OCTAL,
  G_TOKEN_INT,
  G_TOKEN_HEX,
  G_TOKEN_FLOAT,
  G_TOKEN_STRING,

  G_TOKEN_SYMBOL,
  G_TOKEN_IDENTIFIER,
  G_TOKEN_IDENTIFIER_NULL,

  G_TOKEN_COMMENT_SINGLE,
  G_TOKEN_COMMENT_MULTI,
  G_TOKEN_LAST
} GTokenType;

union _GTokenValue
{
  gpointer v_symbol;
  gchar *v_identifier;
  gulong v_binary;
  gulong v_octal;
  gulong v_int;
  gdouble v_float;
  gulong v_hex;
  gchar *v_string;
  gchar *v_comment;
  guchar v_char;
  guint v_error;
};

struct _GScannerConfig
{


  gchar *cset_skip_characters;
  gchar *cset_identifier_first;
  gchar *cset_identifier_nth;
  gchar *cpair_comment_single;



  guint case_sensitive : 1;




  guint skip_comment_multi : 1;
  guint skip_comment_single : 1;
  guint scan_comment_multi : 1;
  guint scan_identifier : 1;
  guint scan_identifier_1char : 1;
  guint scan_identifier_NULL : 1;
  guint scan_symbols : 1;
  guint scan_binary : 1;
  guint scan_octal : 1;
  guint scan_float : 1;
  guint scan_hex : 1;
  guint scan_hex_dollar : 1;
  guint scan_string_sq : 1;
  guint scan_string_dq : 1;
  guint numbers_2_int : 1;
  guint int_2_float : 1;
  guint identifier_2_string : 1;
  guint char_2_token : 1;
  guint symbol_2_token : 1;
  guint scope_0_fallback : 1;
};

struct _GScanner
{

  gpointer user_data;
  guint max_parse_errors;


  guint parse_errors;


  const gchar *input_name;


  gpointer derived_data;


  GScannerConfig *config;


  GTokenType token;
  GTokenValue value;
  guint line;
  guint position;


  GTokenType next_token;
  GTokenValue next_value;
  guint next_line;
  guint next_position;


  GHashTable *symbol_table;
  gint input_fd;
  const gchar *text;
  const gchar *text_end;
  gchar *buffer;
  guint scope_id;


  GScannerMsgFunc msg_handler;
};

GScanner* g_scanner_new (GScannerConfig *config_templ);
void g_scanner_destroy (GScanner *scanner);
void g_scanner_input_file (GScanner *scanner,
       gint input_fd);
void g_scanner_sync_file_offset (GScanner *scanner);
void g_scanner_input_text (GScanner *scanner,
       const gchar *text,
       guint text_len);
GTokenType g_scanner_get_next_token (GScanner *scanner);
GTokenType g_scanner_peek_next_token (GScanner *scanner);
GTokenType g_scanner_cur_token (GScanner *scanner);
GTokenValue g_scanner_cur_value (GScanner *scanner);
guint g_scanner_cur_line (GScanner *scanner);
guint g_scanner_cur_position (GScanner *scanner);
gboolean g_scanner_eof (GScanner *scanner);
guint g_scanner_set_scope (GScanner *scanner,
       guint scope_id);
void g_scanner_scope_add_symbol (GScanner *scanner,
       guint scope_id,
       const gchar *symbol,
       gpointer value);
void g_scanner_scope_remove_symbol (GScanner *scanner,
       guint scope_id,
       const gchar *symbol);
gpointer g_scanner_scope_lookup_symbol (GScanner *scanner,
       guint scope_id,
       const gchar *symbol);
void g_scanner_scope_foreach_symbol (GScanner *scanner,
       guint scope_id,
       GHFunc func,
       gpointer user_data);
gpointer g_scanner_lookup_symbol (GScanner *scanner,
       const gchar *symbol);
void g_scanner_freeze_symbol_table (GScanner *scanner);
void g_scanner_thaw_symbol_table (GScanner *scanner);
void g_scanner_unexp_token (GScanner *scanner,
       GTokenType expected_token,
       const gchar *identifier_spec,
       const gchar *symbol_spec,
       const gchar *symbol_name,
       const gchar *message,
       gint is_error);
void g_scanner_error (GScanner *scanner,
       const gchar *format,
       ...) __attribute__((format (printf, 2, 3)));
void g_scanner_warn (GScanner *scanner,
       const gchar *format,
       ...) __attribute__((format (printf, 2, 3)));
gint g_scanner_stat_mode (const gchar *filename);
# 2045 "glib.h"
struct _GCompletion
{
  GList* items;
  GCompletionFunc func;

  gchar* prefix;
  GList* cache;
};

GCompletion* g_completion_new (GCompletionFunc func);
void g_completion_add_items (GCompletion* cmp,
     GList* items);
void g_completion_remove_items (GCompletion* cmp,
     GList* items);
void g_completion_clear_items (GCompletion* cmp);
GList* g_completion_complete (GCompletion* cmp,
     gchar* prefix,
     gchar** new_prefix);
void g_completion_free (GCompletion* cmp);
# 2075 "glib.h"
typedef guint16 GDateYear;
typedef guint8 GDateDay;
typedef struct _GDate GDate;

struct tm;


typedef enum
{
  G_DATE_DAY = 0,
  G_DATE_MONTH = 1,
  G_DATE_YEAR = 2
} GDateDMY;


typedef enum
{
  G_DATE_BAD_WEEKDAY = 0,
  G_DATE_MONDAY = 1,
  G_DATE_TUESDAY = 2,
  G_DATE_WEDNESDAY = 3,
  G_DATE_THURSDAY = 4,
  G_DATE_FRIDAY = 5,
  G_DATE_SATURDAY = 6,
  G_DATE_SUNDAY = 7
} GDateWeekday;
typedef enum
{
  G_DATE_BAD_MONTH = 0,
  G_DATE_JANUARY = 1,
  G_DATE_FEBRUARY = 2,
  G_DATE_MARCH = 3,
  G_DATE_APRIL = 4,
  G_DATE_MAY = 5,
  G_DATE_JUNE = 6,
  G_DATE_JULY = 7,
  G_DATE_AUGUST = 8,
  G_DATE_SEPTEMBER = 9,
  G_DATE_OCTOBER = 10,
  G_DATE_NOVEMBER = 11,
  G_DATE_DECEMBER = 12
} GDateMonth;
# 2127 "glib.h"
struct _GDate
{
  guint julian_days : 32;





  guint julian : 1;
  guint dmy : 1;


  guint day : 6;
  guint month : 4;
  guint year : 16;
};





GDate* g_date_new (void);
GDate* g_date_new_dmy (GDateDay day,
                                           GDateMonth month,
                                           GDateYear year);
GDate* g_date_new_julian (guint32 julian_day);
void g_date_free (GDate *date);






gboolean g_date_valid (GDate *date);
gboolean g_date_valid_day (GDateDay day);
gboolean g_date_valid_month (GDateMonth month);
gboolean g_date_valid_year (GDateYear year);
gboolean g_date_valid_weekday (GDateWeekday weekday);
gboolean g_date_valid_julian (guint32 julian_date);
gboolean g_date_valid_dmy (GDateDay day,
                                           GDateMonth month,
                                           GDateYear year);

GDateWeekday g_date_weekday (GDate *date);
GDateMonth g_date_month (GDate *date);
GDateYear g_date_year (GDate *date);
GDateDay g_date_day (GDate *date);
guint32 g_date_julian (GDate *date);
guint g_date_day_of_year (GDate *date);







guint g_date_monday_week_of_year (GDate *date);
guint g_date_sunday_week_of_year (GDate *date);





void g_date_clear (GDate *date,
                                           guint n_dates);





void g_date_set_parse (GDate *date,
                                           const gchar *str);
void g_date_set_time (GDate *date,
                                           GTime time);
void g_date_set_month (GDate *date,
                                           GDateMonth month);
void g_date_set_day (GDate *date,
                                           GDateDay day);
void g_date_set_year (GDate *date,
                                           GDateYear year);
void g_date_set_dmy (GDate *date,
                                           GDateDay day,
                                           GDateMonth month,
                                           GDateYear y);
void g_date_set_julian (GDate *date,
                                           guint32 julian_date);
gboolean g_date_is_first_of_month (GDate *date);
gboolean g_date_is_last_of_month (GDate *date);


void g_date_add_days (GDate *date,
                                           guint n_days);
void g_date_subtract_days (GDate *date,
                                           guint n_days);


void g_date_add_months (GDate *date,
                                           guint n_months);
void g_date_subtract_months (GDate *date,
                                           guint n_months);


void g_date_add_years (GDate *date,
                                           guint n_years);
void g_date_subtract_years (GDate *date,
                                           guint n_years);
gboolean g_date_is_leap_year (GDateYear year);
guint8 g_date_days_in_month (GDateMonth month,
                                           GDateYear year);
guint8 g_date_monday_weeks_in_year (GDateYear year);
guint8 g_date_sunday_weeks_in_year (GDateYear year);


gint g_date_compare (GDate *lhs,
                                           GDate *rhs);
void g_date_to_struct_tm (GDate *date,
                                           struct tm *tm);




gsize g_date_strftime (gchar *s,
                                           gsize slen,
                                           const gchar *format,
                                           GDate *date);
# 2277 "glib.h"
GRelation* g_relation_new (gint fields);
void g_relation_destroy (GRelation *relation);
void g_relation_index (GRelation *relation,
          gint field,
          GHashFunc hash_func,
          GCompareFunc key_compare_func);
void g_relation_insert (GRelation *relation,
          ...);
gint g_relation_delete (GRelation *relation,
          gconstpointer key,
          gint field);
GTuples* g_relation_select (GRelation *relation,
          gconstpointer key,
          gint field);
gint g_relation_count (GRelation *relation,
          gconstpointer key,
          gint field);
gboolean g_relation_exists (GRelation *relation,
          ...);
void g_relation_print (GRelation *relation);

void g_tuples_destroy (GTuples *tuples);
gpointer g_tuples_index (GTuples *tuples,
          gint index,
          gint field);
# 2313 "glib.h"
guint g_spaced_primes_closest (guint num);





typedef struct _GIOFuncs GIOFuncs;
typedef enum
{
  G_IO_ERROR_NONE,
  G_IO_ERROR_AGAIN,
  G_IO_ERROR_INVAL,
  G_IO_ERROR_UNKNOWN
} GIOError;
typedef enum
{
  G_SEEK_CUR,
  G_SEEK_SET,
  G_SEEK_END
} GSeekType;
typedef enum
{
  G_IO_IN =1,
  G_IO_OUT =4,
  G_IO_PRI =2,
  G_IO_ERR =8,
  G_IO_HUP =16,
  G_IO_NVAL =32
} GIOCondition;

struct _GIOChannel
{
  guint channel_flags;
  guint ref_count;
  GIOFuncs *funcs;
};

typedef gboolean (*GIOFunc) (GIOChannel *source,
        GIOCondition condition,
        gpointer data);
struct _GIOFuncs
{
  GIOError (*io_read) (GIOChannel *channel,
           gchar *buf,
           guint count,
    guint *bytes_read);
  GIOError (*io_write) (GIOChannel *channel,
     gchar *buf,
    guint count,
    guint *bytes_written);
  GIOError (*io_seek) (GIOChannel *channel,
     gint offset,
      GSeekType type);
  void (*io_close) (GIOChannel *channel);
  guint (*io_add_watch) (GIOChannel *channel,
    gint priority,
    GIOCondition condition,
    GIOFunc func,
    gpointer user_data,
    GDestroyNotify notify);
  void (*io_free) (GIOChannel *channel);
};

void g_io_channel_init (GIOChannel *channel);
void g_io_channel_ref (GIOChannel *channel);
void g_io_channel_unref (GIOChannel *channel);
GIOError g_io_channel_read (GIOChannel *channel,
            gchar *buf,
            guint count,
            guint *bytes_read);
GIOError g_io_channel_write (GIOChannel *channel,
            gchar *buf,
            guint count,
            guint *bytes_written);
GIOError g_io_channel_seek (GIOChannel *channel,
            gint offset,
            GSeekType type);
void g_io_channel_close (GIOChannel *channel);
guint g_io_add_watch_full (GIOChannel *channel,
            gint priority,
            GIOCondition condition,
            GIOFunc func,
            gpointer user_data,
            GDestroyNotify notify);
guint g_io_add_watch (GIOChannel *channel,
            GIOCondition condition,
            GIOFunc func,
            gpointer user_data);




typedef struct _GTimeVal GTimeVal;
typedef struct _GSourceFuncs GSourceFuncs;
typedef struct _GMainLoop GMainLoop;

struct _GTimeVal
{
  glong tv_sec;
  glong tv_usec;
};
struct _GSourceFuncs
{
  gboolean (*prepare) (gpointer source_data,
   GTimeVal *current_time,
   gint *timeout,
   gpointer user_data);
  gboolean (*check) (gpointer source_data,
   GTimeVal *current_time,
   gpointer user_data);
  gboolean (*dispatch) (gpointer source_data,
   GTimeVal *dispatch_time,
   gpointer user_data);
  GDestroyNotify destroy;
};
# 2437 "glib.h"
typedef gboolean (*GSourceFunc) (gpointer data);


guint g_source_add (gint priority,
           gboolean can_recurse,
           GSourceFuncs *funcs,
           gpointer source_data,
           gpointer user_data,
           GDestroyNotify notify);
gboolean g_source_remove (guint tag);
gboolean g_source_remove_by_user_data (gpointer user_data);
gboolean g_source_remove_by_source_data (gpointer source_data);
gboolean g_source_remove_by_funcs_user_data (GSourceFuncs *funcs,
           gpointer user_data);

void g_get_current_time (GTimeVal *result);


GMainLoop* g_main_new (gboolean is_running);
void g_main_run (GMainLoop *loop);
void g_main_quit (GMainLoop *loop);
void g_main_destroy (GMainLoop *loop);
gboolean g_main_is_running (GMainLoop *loop);




gboolean g_main_iteration (gboolean may_block);


gboolean g_main_pending (void);


guint g_timeout_add_full (gint priority,
      guint interval,
      GSourceFunc function,
      gpointer data,
      GDestroyNotify notify);
guint g_timeout_add (guint interval,
      GSourceFunc function,
      gpointer data);
guint g_idle_add (GSourceFunc function,
      gpointer data);
guint g_idle_add_full (gint priority,
      GSourceFunc function,
      gpointer data,
      GDestroyNotify destroy);
gboolean g_idle_remove_by_data (gpointer data);
# 2510 "glib.h"
typedef struct _GPollFD GPollFD;
typedef gint (*GPollFunc) (GPollFD *ufds,
     guint nfsd,
     gint timeout);
struct _GPollFD
{
  gint fd;
  gushort events;
  gushort revents;
};

void g_main_add_poll (GPollFD *fd,
          gint priority);
void g_main_remove_poll (GPollFD *fd);
void g_main_set_poll_func (GPollFunc func);
# 2537 "glib.h"
GIOChannel* g_io_channel_unix_new (int fd);
gint g_io_channel_unix_get_fd (GIOChannel *channel);
# 2658 "glib.h"
typedef struct _GMutex GMutex;
typedef struct _GCond GCond;
typedef struct _GPrivate GPrivate;
typedef struct _GStaticPrivate GStaticPrivate;
typedef struct _GThreadFunctions GThreadFunctions;
struct _GThreadFunctions
{
  GMutex* (*mutex_new) (void);
  void (*mutex_lock) (GMutex *mutex);
  gboolean (*mutex_trylock) (GMutex *mutex);
  void (*mutex_unlock) (GMutex *mutex);
  void (*mutex_free) (GMutex *mutex);
  GCond* (*cond_new) (void);
  void (*cond_signal) (GCond *cond);
  void (*cond_broadcast) (GCond *cond);
  void (*cond_wait) (GCond *cond,
          GMutex *mutex);
  gboolean (*cond_timed_wait) (GCond *cond,
          GMutex *mutex,
          GTimeVal *end_time);
  void (*cond_free) (GCond *cond);
  GPrivate* (*private_new) (GDestroyNotify destructor);
  gpointer (*private_get) (GPrivate *private_key);
  void (*private_set) (GPrivate *private_key,
          gpointer data);
};

extern GThreadFunctions g_thread_functions_for_glib_use;
extern gboolean g_thread_use_default_impl;
extern gboolean g_threads_got_initialized;





void g_thread_init (GThreadFunctions *vtable);


GMutex* g_static_mutex_get_mutex_impl (GMutex **mutex);
# 2741 "glib.h"
struct _GStaticPrivate
{
  guint index;
};

gpointer g_static_private_get (GStaticPrivate *private_key);
void g_static_private_set (GStaticPrivate *private_key,
          gpointer data,
          GDestroyNotify notify);
# 2760 "glib.h"
extern void glib_dummy_decl (void);
# 32 "testglib.c" 2

int array[10000];
gboolean failed = (0);
# 53 "testglib.c"
static gboolean
node_build_string (GNode *node,
     gpointer data)
{
  gchar **p = data;
  gchar *string;
  gchar c[2] = "_";

  c[0] = ((gchar) ((long) (node->data)));

  string = g_strconcat (*p ? *p : "", c, ((void *)0));
  g_free (*p);
  *p = string;

  return (0);
}

static void
g_node_test (void)
{
  GNode *root;
  GNode *node;
  GNode *node_B;
  GNode *node_F;
  GNode *node_G;
  GNode *node_J;
  guint i;
  gchar *tstring;

  g_print ("checking n-way trees: ");
  failed = (0);

  root = g_node_new (((gpointer) ((long) ('A'))));
  (void)( { failed = !(g_node_depth (root) == 1 && g_node_max_height (root) == 1); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 86, ( "g_node_depth (root) == 1 && g_node_max_height (root) == 1" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 86, ( "g_node_depth (root) == 1 && g_node_max_height (root) == 1" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );

  node_B = g_node_new (((gpointer) ((long) ('B'))));
  g_node_insert_before ((root), ((void *)0), (node_B));
  (void)( { failed = !(root->children == node_B); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 90, ( "root->children == node_B" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 90, ( "root->children == node_B" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );

  g_node_insert_before ((node_B), ((void *)0), g_node_new (((gpointer) ((long) ('E')))));
  g_node_prepend ((node_B), g_node_new (((gpointer) ((long) ('C')))));
  g_node_insert (node_B, 1, g_node_new (((gpointer) ((long) ('D')))));

  node_F = g_node_new (((gpointer) ((long) ('F'))));
  g_node_insert_before ((root), ((void *)0), (node_F));
  (void)( { failed = !(root->children->next == node_F); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 98, ( "root->children->next == node_F" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 98, ( "root->children->next == node_F" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );

  node_G = g_node_new (((gpointer) ((long) ('G'))));
  g_node_insert_before ((node_F), ((void *)0), (node_G));
  node_J = g_node_new (((gpointer) ((long) ('J'))));
  g_node_prepend (node_G, node_J);
  g_node_insert (node_G, 42, g_node_new (((gpointer) ((long) ('K')))));
  g_node_insert ((node_G), (0), g_node_new (((gpointer) ((long) ('H')))));
  g_node_insert (node_G, 1, g_node_new (((gpointer) ((long) ('I')))));

  (void)( { failed = !(g_node_depth (root) == 1); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 108, ( "g_node_depth (root) == 1" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 108, ( "g_node_depth (root) == 1" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );
  (void)( { failed = !(g_node_max_height (root) == 4); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 109, ( "g_node_max_height (root) == 4" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 109, ( "g_node_max_height (root) == 4" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );
  (void)( { failed = !(g_node_depth (node_G->children->next) == 4); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 110, ( "g_node_depth (node_G->children->next) == 4" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 110, ( "g_node_depth (node_G->children->next) == 4" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );
  (void)( { failed = !(g_node_n_nodes (root, G_TRAVERSE_LEAFS) == 7); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 111, ( "g_node_n_nodes (root, G_TRAVERSE_LEAFS) == 7" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 111, ( "g_node_n_nodes (root, G_TRAVERSE_LEAFS) == 7" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );
  (void)( { failed = !(g_node_n_nodes (root, G_TRAVERSE_NON_LEAFS) == 4); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 112, ( "g_node_n_nodes (root, G_TRAVERSE_NON_LEAFS) == 4" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 112, ( "g_node_n_nodes (root, G_TRAVERSE_NON_LEAFS) == 4" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );
  (void)( { failed = !(g_node_n_nodes (root, G_TRAVERSE_ALL) == 11); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 113, ( "g_node_n_nodes (root, G_TRAVERSE_ALL) == 11" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 113, ( "g_node_n_nodes (root, G_TRAVERSE_ALL) == 11" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );
  (void)( { failed = !(g_node_max_height (node_F) == 3); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 114, ( "g_node_max_height (node_F) == 3" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 114, ( "g_node_max_height (node_F) == 3" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );
  (void)( { failed = !(g_node_n_children (node_G) == 4); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 115, ( "g_node_n_children (node_G) == 4" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 115, ( "g_node_n_children (node_G) == 4" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );
  (void)( { failed = !(g_node_find_child (root, G_TRAVERSE_ALL, ((gpointer) ((long) ('F')))) == node_F); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 116, ( "g_node_find_child (root, G_TRAVERSE_ALL, C2P ('F')) == node_F" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 116, ( "g_node_find_child (root, G_TRAVERSE_ALL, C2P ('F')) == node_F" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );
  (void)( { failed = !(g_node_find (root, G_LEVEL_ORDER, G_TRAVERSE_NON_LEAFS, ((gpointer) ((long) ('I')))) == ((void *)0)); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 117, ( "g_node_find (root, G_LEVEL_ORDER, G_TRAVERSE_NON_LEAFS, C2P ('I')) == NULL" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 117, ( "g_node_find (root, G_LEVEL_ORDER, G_TRAVERSE_NON_LEAFS, C2P ('I')) == NULL" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );
  (void)( { failed = !(g_node_find (root, G_IN_ORDER, G_TRAVERSE_LEAFS, ((gpointer) ((long) ('J')))) == node_J); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 118, ( "g_node_find (root, G_IN_ORDER, G_TRAVERSE_LEAFS, C2P ('J')) == node_J" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 118, ( "g_node_find (root, G_IN_ORDER, G_TRAVERSE_LEAFS, C2P ('J')) == node_J" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );

  for (i = 0; i < g_node_n_children (node_B); i++)
    {
      node = g_node_nth_child (node_B, i);
      (void)( { failed = !(((gchar) ((long) (node->data))) == ('C' + i)); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 123, ( "P2C (node->data) == ('C' + i)" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 123, ( "P2C (node->data) == ('C' + i)" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );
    }

  for (i = 0; i < g_node_n_children (node_G); i++)
    (void)( { failed = !(g_node_child_position (node_G, g_node_nth_child (node_G, i)) == i); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 127, ( "g_node_child_position (node_G, g_node_nth_child (node_G, i)) == i" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 127, ( "g_node_child_position (node_G, g_node_nth_child (node_G, i)) == i" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );
# 141 "testglib.c"
  tstring = ((void *)0);
  g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
  (void)( { failed = !(__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (tstring) && __builtin_constant_p ("ABCDEFGHIJK") && (__s1_len = strlen (tstring), __s2_len = strlen ("ABCDEFGHIJK"), (!((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("ABCDEFGHIJK") + 1) - (size_t)(const void *)("ABCDEFGHIJK") == 1) || __s2_len >= 4)) ? __builtin_strcmp (tstring, "ABCDEFGHIJK") : (__builtin_constant_p (tstring) && ((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) && (__s1_len = strlen (tstring), __s1_len < 4) ? (__builtin_constant_p ("ABCDEFGHIJK") && ((size_t)(const void *)(("ABCDEFGHIJK") + 1) - (size_t)(const void *)("ABCDEFGHIJK") == 1) ? __builtin_strcmp (tstring, "ABCDEFGHIJK") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("ABCDEFGHIJK"); register int __result = (((__const unsigned char *) (__const char *) (tstring))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tstring))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tstring))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (tstring))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("ABCDEFGHIJK") && ((size_t)(const void *)(("ABCDEFGHIJK") + 1) - (size_t)(const void *)("ABCDEFGHIJK") == 1) && (__s2_len = strlen ("ABCDEFGHIJK"), __s2_len < 4) ? (__builtin_constant_p (tstring) && ((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) ? __builtin_strcmp (tstring, "ABCDEFGHIJK") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (tstring); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("ABCDEFGHIJK"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("ABCDEFGHIJK"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("ABCDEFGHIJK"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("ABCDEFGHIJK"))[3]); } } __result; }))) : __builtin_strcmp (tstring, "ABCDEFGHIJK")))); }) == 0); if (failed) { if (!tstring) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 143, ( "strcmp (tstring, \"ABCDEFGHIJK\") == 0" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 143, ( "strcmp (tstring, \"ABCDEFGHIJK\") == 0" ), (gchar*)tstring); } else g_print ("."); fflush (stdout); } );
  g_free (tstring); tstring = ((void *)0);
  g_node_traverse (root, G_POST_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
  (void)( { failed = !(__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (tstring) && __builtin_constant_p ("CDEBHIJKGFA") && (__s1_len = strlen (tstring), __s2_len = strlen ("CDEBHIJKGFA"), (!((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("CDEBHIJKGFA") + 1) - (size_t)(const void *)("CDEBHIJKGFA") == 1) || __s2_len >= 4)) ? __builtin_strcmp (tstring, "CDEBHIJKGFA") : (__builtin_constant_p (tstring) && ((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) && (__s1_len = strlen (tstring), __s1_len < 4) ? (__builtin_constant_p ("CDEBHIJKGFA") && ((size_t)(const void *)(("CDEBHIJKGFA") + 1) - (size_t)(const void *)("CDEBHIJKGFA") == 1) ? __builtin_strcmp (tstring, "CDEBHIJKGFA") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("CDEBHIJKGFA"); register int __result = (((__const unsigned char *) (__const char *) (tstring))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tstring))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tstring))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (tstring))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("CDEBHIJKGFA") && ((size_t)(const void *)(("CDEBHIJKGFA") + 1) - (size_t)(const void *)("CDEBHIJKGFA") == 1) && (__s2_len = strlen ("CDEBHIJKGFA"), __s2_len < 4) ? (__builtin_constant_p (tstring) && ((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) ? __builtin_strcmp (tstring, "CDEBHIJKGFA") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (tstring); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("CDEBHIJKGFA"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("CDEBHIJKGFA"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("CDEBHIJKGFA"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("CDEBHIJKGFA"))[3]); } } __result; }))) : __builtin_strcmp (tstring, "CDEBHIJKGFA")))); }) == 0); if (failed) { if (!tstring) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 146, ( "strcmp (tstring, \"CDEBHIJKGFA\") == 0" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 146, ( "strcmp (tstring, \"CDEBHIJKGFA\") == 0" ), (gchar*)tstring); } else g_print ("."); fflush (stdout); } );
  g_free (tstring); tstring = ((void *)0);
  g_node_traverse (root, G_IN_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
  (void)( { failed = !(__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (tstring) && __builtin_constant_p ("CBDEAHGIJKF") && (__s1_len = strlen (tstring), __s2_len = strlen ("CBDEAHGIJKF"), (!((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("CBDEAHGIJKF") + 1) - (size_t)(const void *)("CBDEAHGIJKF") == 1) || __s2_len >= 4)) ? __builtin_strcmp (tstring, "CBDEAHGIJKF") : (__builtin_constant_p (tstring) && ((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) && (__s1_len = strlen (tstring), __s1_len < 4) ? (__builtin_constant_p ("CBDEAHGIJKF") && ((size_t)(const void *)(("CBDEAHGIJKF") + 1) - (size_t)(const void *)("CBDEAHGIJKF") == 1) ? __builtin_strcmp (tstring, "CBDEAHGIJKF") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("CBDEAHGIJKF"); register int __result = (((__const unsigned char *) (__const char *) (tstring))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tstring))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tstring))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (tstring))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("CBDEAHGIJKF") && ((size_t)(const void *)(("CBDEAHGIJKF") + 1) - (size_t)(const void *)("CBDEAHGIJKF") == 1) && (__s2_len = strlen ("CBDEAHGIJKF"), __s2_len < 4) ? (__builtin_constant_p (tstring) && ((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) ? __builtin_strcmp (tstring, "CBDEAHGIJKF") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (tstring); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("CBDEAHGIJKF"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("CBDEAHGIJKF"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("CBDEAHGIJKF"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("CBDEAHGIJKF"))[3]); } } __result; }))) : __builtin_strcmp (tstring, "CBDEAHGIJKF")))); }) == 0); if (failed) { if (!tstring) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 149, ( "strcmp (tstring, \"CBDEAHGIJKF\") == 0" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 149, ( "strcmp (tstring, \"CBDEAHGIJKF\") == 0" ), (gchar*)tstring); } else g_print ("."); fflush (stdout); } );
  g_free (tstring); tstring = ((void *)0);
  g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
  (void)( { failed = !(__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (tstring) && __builtin_constant_p ("ABFCDEGHIJK") && (__s1_len = strlen (tstring), __s2_len = strlen ("ABFCDEGHIJK"), (!((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("ABFCDEGHIJK") + 1) - (size_t)(const void *)("ABFCDEGHIJK") == 1) || __s2_len >= 4)) ? __builtin_strcmp (tstring, "ABFCDEGHIJK") : (__builtin_constant_p (tstring) && ((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) && (__s1_len = strlen (tstring), __s1_len < 4) ? (__builtin_constant_p ("ABFCDEGHIJK") && ((size_t)(const void *)(("ABFCDEGHIJK") + 1) - (size_t)(const void *)("ABFCDEGHIJK") == 1) ? __builtin_strcmp (tstring, "ABFCDEGHIJK") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("ABFCDEGHIJK"); register int __result = (((__const unsigned char *) (__const char *) (tstring))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tstring))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tstring))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (tstring))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("ABFCDEGHIJK") && ((size_t)(const void *)(("ABFCDEGHIJK") + 1) - (size_t)(const void *)("ABFCDEGHIJK") == 1) && (__s2_len = strlen ("ABFCDEGHIJK"), __s2_len < 4) ? (__builtin_constant_p (tstring) && ((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) ? __builtin_strcmp (tstring, "ABFCDEGHIJK") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (tstring); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("ABFCDEGHIJK"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("ABFCDEGHIJK"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("ABFCDEGHIJK"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("ABFCDEGHIJK"))[3]); } } __result; }))) : __builtin_strcmp (tstring, "ABFCDEGHIJK")))); }) == 0); if (failed) { if (!tstring) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 152, ( "strcmp (tstring, \"ABFCDEGHIJK\") == 0" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 152, ( "strcmp (tstring, \"ABFCDEGHIJK\") == 0" ), (gchar*)tstring); } else g_print ("."); fflush (stdout); } );
  g_free (tstring); tstring = ((void *)0);

  g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_LEAFS, -1, node_build_string, &tstring);
  (void)( { failed = !(__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (tstring) && __builtin_constant_p ("CDEHIJK") && (__s1_len = strlen (tstring), __s2_len = strlen ("CDEHIJK"), (!((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("CDEHIJK") + 1) - (size_t)(const void *)("CDEHIJK") == 1) || __s2_len >= 4)) ? __builtin_strcmp (tstring, "CDEHIJK") : (__builtin_constant_p (tstring) && ((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) && (__s1_len = strlen (tstring), __s1_len < 4) ? (__builtin_constant_p ("CDEHIJK") && ((size_t)(const void *)(("CDEHIJK") + 1) - (size_t)(const void *)("CDEHIJK") == 1) ? __builtin_strcmp (tstring, "CDEHIJK") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("CDEHIJK"); register int __result = (((__const unsigned char *) (__const char *) (tstring))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tstring))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tstring))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (tstring))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("CDEHIJK") && ((size_t)(const void *)(("CDEHIJK") + 1) - (size_t)(const void *)("CDEHIJK") == 1) && (__s2_len = strlen ("CDEHIJK"), __s2_len < 4) ? (__builtin_constant_p (tstring) && ((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) ? __builtin_strcmp (tstring, "CDEHIJK") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (tstring); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("CDEHIJK"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("CDEHIJK"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("CDEHIJK"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("CDEHIJK"))[3]); } } __result; }))) : __builtin_strcmp (tstring, "CDEHIJK")))); }) == 0); if (failed) { if (!tstring) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 156, ( "strcmp (tstring, \"CDEHIJK\") == 0" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 156, ( "strcmp (tstring, \"CDEHIJK\") == 0" ), (gchar*)tstring); } else g_print ("."); fflush (stdout); } );
  g_free (tstring); tstring = ((void *)0);
  g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_NON_LEAFS, -1, node_build_string, &tstring);
  (void)( { failed = !(__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (tstring) && __builtin_constant_p ("ABFG") && (__s1_len = strlen (tstring), __s2_len = strlen ("ABFG"), (!((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("ABFG") + 1) - (size_t)(const void *)("ABFG") == 1) || __s2_len >= 4)) ? __builtin_strcmp (tstring, "ABFG") : (__builtin_constant_p (tstring) && ((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) && (__s1_len = strlen (tstring), __s1_len < 4) ? (__builtin_constant_p ("ABFG") && ((size_t)(const void *)(("ABFG") + 1) - (size_t)(const void *)("ABFG") == 1) ? __builtin_strcmp (tstring, "ABFG") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("ABFG"); register int __result = (((__const unsigned char *) (__const char *) (tstring))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tstring))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tstring))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (tstring))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("ABFG") && ((size_t)(const void *)(("ABFG") + 1) - (size_t)(const void *)("ABFG") == 1) && (__s2_len = strlen ("ABFG"), __s2_len < 4) ? (__builtin_constant_p (tstring) && ((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) ? __builtin_strcmp (tstring, "ABFG") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (tstring); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("ABFG"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("ABFG"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("ABFG"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("ABFG"))[3]); } } __result; }))) : __builtin_strcmp (tstring, "ABFG")))); }) == 0); if (failed) { if (!tstring) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 159, ( "strcmp (tstring, \"ABFG\") == 0" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 159, ( "strcmp (tstring, \"ABFG\") == 0" ), (gchar*)tstring); } else g_print ("."); fflush (stdout); } );
  g_free (tstring); tstring = ((void *)0);

  g_node_reverse_children (node_B);
  g_node_reverse_children (node_G);

  g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
  (void)( { failed = !(__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (tstring) && __builtin_constant_p ("ABFEDCGKJIH") && (__s1_len = strlen (tstring), __s2_len = strlen ("ABFEDCGKJIH"), (!((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("ABFEDCGKJIH") + 1) - (size_t)(const void *)("ABFEDCGKJIH") == 1) || __s2_len >= 4)) ? __builtin_strcmp (tstring, "ABFEDCGKJIH") : (__builtin_constant_p (tstring) && ((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) && (__s1_len = strlen (tstring), __s1_len < 4) ? (__builtin_constant_p ("ABFEDCGKJIH") && ((size_t)(const void *)(("ABFEDCGKJIH") + 1) - (size_t)(const void *)("ABFEDCGKJIH") == 1) ? __builtin_strcmp (tstring, "ABFEDCGKJIH") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("ABFEDCGKJIH"); register int __result = (((__const unsigned char *) (__const char *) (tstring))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tstring))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tstring))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (tstring))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("ABFEDCGKJIH") && ((size_t)(const void *)(("ABFEDCGKJIH") + 1) - (size_t)(const void *)("ABFEDCGKJIH") == 1) && (__s2_len = strlen ("ABFEDCGKJIH"), __s2_len < 4) ? (__builtin_constant_p (tstring) && ((size_t)(const void *)((tstring) + 1) - (size_t)(const void *)(tstring) == 1) ? __builtin_strcmp (tstring, "ABFEDCGKJIH") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (tstring); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("ABFEDCGKJIH"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("ABFEDCGKJIH"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("ABFEDCGKJIH"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("ABFEDCGKJIH"))[3]); } } __result; }))) : __builtin_strcmp (tstring, "ABFEDCGKJIH")))); }) == 0); if (failed) { if (!tstring) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 166, ( "strcmp (tstring, \"ABFEDCGKJIH\") == 0" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 166, ( "strcmp (tstring, \"ABFEDCGKJIH\") == 0" ), (gchar*)tstring); } else g_print ("."); fflush (stdout); } );
  g_free (tstring); tstring = ((void *)0);

  g_node_destroy (root);



  root = g_node_new (((void *)0));
  node = root;

  for (i = 0; i < 2048; i++)
    {
      g_node_insert_before ((node), ((void *)0), (g_node_new (((void *)0))));
      if ((i%5) == 4)
 node = node->children->next;
    }
  (void)( { failed = !(g_node_max_height (root) > 100); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 182, ( "g_node_max_height (root) > 100" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 182, ( "g_node_max_height (root) > 100" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );
  (void)( { failed = !(g_node_n_nodes (root, G_TRAVERSE_ALL) == 1 + 2048); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 183, ( "g_node_n_nodes (root, G_TRAVERSE_ALL) == 1 + 2048" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 183, ( "g_node_n_nodes (root, G_TRAVERSE_ALL) == 1 + 2048" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );

  g_node_destroy (root);

  if (!failed)
    g_print ("ok\n");
}

static gboolean
my_hash_callback_remove (gpointer key,
    gpointer value,
    gpointer user_data)
{
  int *d = value;

  if ((*d) % 2)
    return (!(0));

  return (0);
}

static void
my_hash_callback_remove_test (gpointer key,
         gpointer value,
         gpointer user_data)
{
  int *d = value;

  if ((*d) % 2)
    g_print ("bad!\n");
}

static void
my_hash_callback (gpointer key,
    gpointer value,
    gpointer user_data)
{
  int *d = value;
  *d = 1;
}

static guint
my_hash (gconstpointer key)
{
  return (guint) *((const gint*) key);
}

static gint
my_hash_compare (gconstpointer a,
   gconstpointer b)
{
  return *((const gint*) a) == *((const gint*) b);
}

static gint
my_list_compare_one (gconstpointer a, gconstpointer b)
{
  gint one = *((const gint*)a);
  gint two = *((const gint*)b);
  return one-two;
}

static gint
my_list_compare_two (gconstpointer a, gconstpointer b)
{
  gint one = *((const gint*)a);
  gint two = *((const gint*)b);
  return two-one;
}
# 260 "testglib.c"
static gint
my_compare (gconstpointer a,
     gconstpointer b)
{
  const char *cha = a;
  const char *chb = b;

  return *cha - *chb;
}

static gint
my_traverse (gpointer key,
      gpointer value,
      gpointer data)
{
  char *ch = key;
  g_print ("%c ", *ch);
  return (0);
}

int
main (int argc,
      char *argv[])
{
  GList *list, *t;
  GSList *slist, *st;
  GHashTable *hash_table;
  GMemChunk *mem_chunk;
  GStringChunk *string_chunk;
  GTimer *timer;
  gint nums[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  gint morenums[10] = { 8, 9, 7, 0, 3, 2, 5, 1, 4, 6};
  gchar *string;

  gchar *mem[10000], *tmp_string = ((void *)0), *tmp_string_2;
  gint i, j;
  GArray *garray;
  GPtrArray *gparray;
  GByteArray *gbarray;
  GString *string1, *string2;
  GTree *tree;
  char chars[62];
  GRelation *relation;
  GTuples *tuples;
  gint data [1024];
  struct {
    gchar *filename;
    gchar *dirname;
  } dirname_checks[] = {

    { "/", "/" },
    { "////", "/" },
    { ".////", "." },
    { ".", "." },
    { "..", "." },
    { "../", ".." },
    { "..////", ".." },
    { "", "." },
    { "a/b", "a" },
    { "a/b/", "a/b" },
    { "c///", "c" },
# 333 "testglib.c"
  };
  guint n_dirname_checks = sizeof (dirname_checks) / sizeof (dirname_checks[0]);
  guint16 gu16t1 = 0x44afU, gu16t2 = 0xaf44U;
  guint32 gu32t1 = 0x02a7f109U, gu32t2 = 0x09f1a702U;

  guint64 gu64t1 = (0x1d636b02300a7aa7UL),
   gu64t2 = (0xa77a0a30026b631dUL);


  g_print ("TestGLib v%u.%u.%u (i:%u b:%u)\n",
    glib_major_version,
    glib_minor_version,
    glib_micro_version,
    glib_interface_age,
    glib_binary_age);

  string = g_get_current_dir ();
  g_print ("cwd: %s\n", string);
  g_free (string);
  g_print ("user: %s\n", g_get_user_name ());
  g_print ("real: %s\n", g_get_real_name ());
  g_print ("home: %s\n", g_get_home_dir ());
  g_print ("tmp-dir: %s\n", g_get_tmp_dir ());


  g_print ("checking size of gint8: %d", (int)sizeof (gint8));
  (void)( { failed = !(sizeof (gint8) == 1); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 359, ( "sizeof (gint8) == 1" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 359, ( "sizeof (gint8) == 1" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );
  g_print ("\nchecking size of gint16: %d", (int)sizeof (gint16));
  (void)( { failed = !(sizeof (gint16) == 2); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 361, ( "sizeof (gint16) == 2" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 361, ( "sizeof (gint16) == 2" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );
  g_print ("\nchecking size of gint32: %d", (int)sizeof (gint32));
  (void)( { failed = !(sizeof (gint32) == 4); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 363, ( "sizeof (gint32) == 4" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 363, ( "sizeof (gint32) == 4" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );

  g_print ("\nchecking size of gint64: %d", (int)sizeof (gint64));
  (void)( { failed = !(sizeof (gint64) == 8); if (failed) { if (!((void *)0)) g_print ("\n(%s:%d) failed for: %s\n", "testglib.c", 366, ( "sizeof (gint64) == 8" )); else g_print ("\n(%s:%d) failed for: %s: (%s)\n", "testglib.c", 366, ( "sizeof (gint64) == 8" ), (gchar*)((void *)0)); } else g_print ("."); fflush (stdout); } );

  g_print ("\n");

  g_print ("checking g_dirname()...");
  for (i = 0; i < n_dirname_checks; i++)
    {
      gchar *dirname;

      dirname = g_dirname (dirname_checks[i].filename);
      if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (dirname) && __builtin_constant_p (dirname_checks[i].dirname) && (__s1_len = strlen (dirname), __s2_len = strlen (dirname_checks[i].dirname), (!((size_t)(const void *)((dirname) + 1) - (size_t)(const void *)(dirname) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((dirname_checks[i].dirname) + 1) - (size_t)(const void *)(dirname_checks[i].dirname) == 1) || __s2_len >= 4)) ? __builtin_strcmp (dirname, dirname_checks[i].dirname) : (__builtin_constant_p (dirname) && ((size_t)(const void *)((dirname) + 1) - (size_t)(const void *)(dirname) == 1) && (__s1_len = strlen (dirname), __s1_len < 4) ? (__builtin_constant_p (dirname_checks[i].dirname) && ((size_t)(const void *)((dirname_checks[i].dirname) + 1) - (size_t)(const void *)(dirname_checks[i].dirname) == 1) ? __builtin_strcmp (dirname, dirname_checks[i].dirname) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (dirname_checks[i].dirname); register int __result = (((__const unsigned char *) (__const char *) (dirname))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (dirname))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (dirname))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (dirname))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (dirname_checks[i].dirname) && ((size_t)(const void *)((dirname_checks[i].dirname) + 1) - (size_t)(const void *)(dirname_checks[i].dirname) == 1) && (__s2_len = strlen (dirname_checks[i].dirname), __s2_len < 4) ? (__builtin_constant_p (dirname) && ((size_t)(const void *)((dirname) + 1) - (size_t)(const void *)(dirname) == 1) ? __builtin_strcmp (dirname, dirname_checks[i].dirname) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (dirname); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (dirname_checks[i].dirname))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (dirname_checks[i].dirname))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (dirname_checks[i].dirname))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (dirname_checks[i].dirname))[3]); } } __result; }))) : __builtin_strcmp (dirname, dirname_checks[i].dirname)))); }) != 0)
 {
   g_print ("\nfailed for \"%s\"==\"%s\" (returned: \"%s\")\n",
     dirname_checks[i].filename,
     dirname_checks[i].dirname,
     dirname);
   n_dirname_checks = 0;
 }
      g_free (dirname);
    }
  if (n_dirname_checks)
    g_print ("ok\n");

  g_print ("checking doubly linked lists...");

  list = ((void *)0);
  for (i = 0; i < 10; i++)
    list = g_list_append (list, &nums[i]);
  list = g_list_reverse (list);

  for (i = 0; i < 10; i++)
    {
      t = g_list_nth (list, i);
      if (*((gint*) t->data) != (9 - i))
 g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "Regular insert failed");
    }

  for (i = 0; i < 10; i++)
    if(g_list_position(list, g_list_nth (list, i)) != i)
      g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "g_list_position does not seem to be the inverse of g_list_nth\n");

  g_list_free (list);
  list = ((void *)0);

  for (i = 0; i < 10; i++)
    list = g_list_insert_sorted (list, &morenums[i], my_list_compare_one);






  for (i = 0; i < 10; i++)
    {
      t = g_list_nth (list, i);
      if (*((gint*) t->data) != i)
         g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "Sorted insert failed");
    }

  g_list_free (list);
  list = ((void *)0);

  for (i = 0; i < 10; i++)
    list = g_list_insert_sorted (list, &morenums[i], my_list_compare_two);






  for (i = 0; i < 10; i++)
    {
      t = g_list_nth (list, i);
      if (*((gint*) t->data) != (9 - i))
         g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "Sorted insert failed");
    }

  g_list_free (list);
  list = ((void *)0);

  for (i = 0; i < 10; i++)
    list = g_list_prepend (list, &morenums[i]);

  list = g_list_sort (list, my_list_compare_two);






  for (i = 0; i < 10; i++)
    {
      t = g_list_nth (list, i);
      if (*((gint*) t->data) != (9 - i))
         g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "Merge sort failed");
    }

  g_list_free (list);

  g_print ("ok\n");


  g_print ("checking singly linked lists...");

  slist = ((void *)0);
  for (i = 0; i < 10; i++)
    slist = g_slist_append (slist, &nums[i]);
  slist = g_slist_reverse (slist);

  for (i = 0; i < 10; i++)
    {
      st = g_slist_nth (slist, i);
      if (*((gint*) st->data) != (9 - i))
 g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "failed");
    }

  g_slist_free (slist);
  slist = ((void *)0);

  for (i = 0; i < 10; i++)
    slist = g_slist_insert_sorted (slist, &morenums[i], my_list_compare_one);






  for (i = 0; i < 10; i++)
    {
      st = g_slist_nth (slist, i);
      if (*((gint*) st->data) != i)
         g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "Sorted insert failed");
    }

  g_slist_free(slist);
  slist = ((void *)0);

  for (i = 0; i < 10; i++)
    slist = g_slist_insert_sorted (slist, &morenums[i], my_list_compare_two);






  for (i = 0; i < 10; i++)
    {
      st = g_slist_nth (slist, i);
      if (*((gint*) st->data) != (9 - i))
         g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "Sorted insert failed");
    }

  g_slist_free(slist);
  slist = ((void *)0);

  for (i = 0; i < 10; i++)
    slist = g_slist_prepend (slist, &morenums[i]);

  slist = g_slist_sort (slist, my_list_compare_two);






  for (i = 0; i < 10; i++)
    {
      st = g_slist_nth (slist, i);
      if (*((gint*) st->data) != (9 - i))
         g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "Sorted insert failed");
    }

  g_slist_free(slist);

  g_print ("ok\n");


  g_print ("checking binary trees...\n");

  tree = g_tree_new (my_compare);
  i = 0;
  for (j = 0; j < 10; j++, i++)
    {
      chars[i] = '0' + j;
      g_tree_insert (tree, &chars[i], &chars[i]);
    }
  for (j = 0; j < 26; j++, i++)
    {
      chars[i] = 'A' + j;
      g_tree_insert (tree, &chars[i], &chars[i]);
    }
  for (j = 0; j < 26; j++, i++)
    {
      chars[i] = 'a' + j;
      g_tree_insert (tree, &chars[i], &chars[i]);
    }

  g_print ("tree height: %d\n", g_tree_height (tree));
  g_print ("tree nnodes: %d\n", g_tree_nnodes (tree));

  g_print ("tree: ");
  g_tree_traverse (tree, my_traverse, G_IN_ORDER, ((void *)0));
  g_print ("\n");

  for (i = 0; i < 10; i++)
    g_tree_remove (tree, &chars[i]);

  g_print ("tree height: %d\n", g_tree_height (tree));
  g_print ("tree nnodes: %d\n", g_tree_nnodes (tree));

  g_print ("tree: ");
  g_tree_traverse (tree, my_traverse, G_IN_ORDER, ((void *)0));
  g_print ("\n");

  g_print ("ok\n");



  g_node_test ();

  g_print ("checking mem chunks...");

  mem_chunk = g_mem_chunk_new ("test mem chunk", 50, 100, 2);

  for (i = 0; i < 10000; i++)
    {
      mem[i] = ( (gchar *) g_mem_chunk_alloc (mem_chunk) );

      for (j = 0; j < 50; j++)
 mem[i][j] = i * j;
    }

  for (i = 0; i < 10000; i++)
    {
      g_mem_chunk_free (mem_chunk, mem[i]);
    }

  g_print ("ok\n");


  g_print ("checking hash tables...");

  hash_table = g_hash_table_new (my_hash, my_hash_compare);
  for (i = 0; i < 10000; i++)
    {
      array[i] = i;
      g_hash_table_insert (hash_table, &array[i], &array[i]);
    }
  g_hash_table_foreach (hash_table, my_hash_callback, ((void *)0));

  for (i = 0; i < 10000; i++)
    if (array[i] == 0)
      g_print ("%d\n", i);

  for (i = 0; i < 10000; i++)
    g_hash_table_remove (hash_table, &array[i]);

  for (i = 0; i < 10000; i++)
    {
      array[i] = i;
      g_hash_table_insert (hash_table, &array[i], &array[i]);
    }

  if (g_hash_table_foreach_remove (hash_table, my_hash_callback_remove, ((void *)0)) != 5000 ||
      g_hash_table_size (hash_table) != 5000)
    g_print ("bad!\n");

  g_hash_table_foreach (hash_table, my_hash_callback_remove_test, ((void *)0));


  g_hash_table_destroy (hash_table);

  g_print ("ok\n");


  g_print ("checking string chunks...");

  string_chunk = g_string_chunk_new (1024);

  for (i = 0; i < 100000; i ++)
    {
      tmp_string = g_string_chunk_insert (string_chunk, "hi pete");

      if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p ("hi pete") && __builtin_constant_p (tmp_string) && (__s1_len = strlen ("hi pete"), __s2_len = strlen (tmp_string), (!((size_t)(const void *)(("hi pete") + 1) - (size_t)(const void *)("hi pete") == 1) || __s1_len >= 4) && (!((size_t)(const void *)((tmp_string) + 1) - (size_t)(const void *)(tmp_string) == 1) || __s2_len >= 4)) ? __builtin_strcmp ("hi pete", tmp_string) : (__builtin_constant_p ("hi pete") && ((size_t)(const void *)(("hi pete") + 1) - (size_t)(const void *)("hi pete") == 1) && (__s1_len = strlen ("hi pete"), __s1_len < 4) ? (__builtin_constant_p (tmp_string) && ((size_t)(const void *)((tmp_string) + 1) - (size_t)(const void *)(tmp_string) == 1) ? __builtin_strcmp ("hi pete", tmp_string) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (tmp_string); register int __result = (((__const unsigned char *) (__const char *) ("hi pete"))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ("hi pete"))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ("hi pete"))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) ("hi pete"))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (tmp_string) && ((size_t)(const void *)((tmp_string) + 1) - (size_t)(const void *)(tmp_string) == 1) && (__s2_len = strlen (tmp_string), __s2_len < 4) ? (__builtin_constant_p ("hi pete") && ((size_t)(const void *)(("hi pete") + 1) - (size_t)(const void *)("hi pete") == 1) ? __builtin_strcmp ("hi pete", tmp_string) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) ("hi pete"); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (tmp_string))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (tmp_string))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (tmp_string))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (tmp_string))[3]); } } __result; }))) : __builtin_strcmp ("hi pete", tmp_string)))); }) != 0)
 g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "string chunks are broken.\n");
    }

  tmp_string_2 = g_string_chunk_insert_const (string_chunk, tmp_string);

  (void)({ if (!(tmp_string_2 != tmp_string && __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (tmp_string_2) && __builtin_constant_p (tmp_string) && (__s1_len = strlen (tmp_string_2), __s2_len = strlen (tmp_string), (!((size_t)(const void *)((tmp_string_2) + 1) - (size_t)(const void *)(tmp_string_2) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((tmp_string) + 1) - (size_t)(const void *)(tmp_string) == 1) || __s2_len >= 4)) ? __builtin_strcmp (tmp_string_2, tmp_string) : (__builtin_constant_p (tmp_string_2) && ((size_t)(const void *)((tmp_string_2) + 1) - (size_t)(const void *)(tmp_string_2) == 1) && (__s1_len = strlen (tmp_string_2), __s1_len < 4) ? (__builtin_constant_p (tmp_string) && ((size_t)(const void *)((tmp_string) + 1) - (size_t)(const void *)(tmp_string) == 1) ? __builtin_strcmp (tmp_string_2, tmp_string) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (tmp_string); register int __result = (((__const unsigned char *) (__const char *) (tmp_string_2))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tmp_string_2))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (tmp_string_2))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (tmp_string_2))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (tmp_string) && ((size_t)(const void *)((tmp_string) + 1) - (size_t)(const void *)(tmp_string) == 1) && (__s2_len = strlen (tmp_string), __s2_len < 4) ? (__builtin_constant_p (tmp_string_2) && ((size_t)(const void *)((tmp_string_2) + 1) - (size_t)(const void *)(tmp_string_2) == 1) ? __builtin_strcmp (tmp_string_2, tmp_string) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (tmp_string_2); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (tmp_string))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (tmp_string))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (tmp_string))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (tmp_string))[3]); } } __result; }))) : __builtin_strcmp (tmp_string_2, tmp_string)))); }) == 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 656, __PRETTY_FUNCTION__, "tmp_string_2 != tmp_string && strcmp(tmp_string_2, tmp_string) == 0"); });


  tmp_string = g_string_chunk_insert_const (string_chunk, tmp_string);

  (void)({ if (!(tmp_string_2 == tmp_string)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 660, __PRETTY_FUNCTION__, "tmp_string_2 == tmp_string"); });

  g_string_chunk_free (string_chunk);

  g_print ("ok\n");


  g_print ("checking arrays...");

  garray = g_array_new ((0), (0), sizeof (gint));
  for (i = 0; i < 10000; i++)
    g_array_append_vals (garray, &i, 1);

  for (i = 0; i < 10000; i++)
    if ((((gint*) (garray)->data) [(i)]) != i)
      g_print ("uh oh: %d ( %d )\n", (((gint*) (garray)->data) [(i)]), i);

  g_array_free (garray, (!(0)));

  garray = g_array_new ((0), (0), sizeof (gint));
  for (i = 0; i < 100; i++)
    g_array_prepend_vals (garray, &i, 1);

  for (i = 0; i < 100; i++)
    if ((((gint*) (garray)->data) [(i)]) != (100 - i - 1))
      g_print ("uh oh: %d ( %d )\n", (((gint*) (garray)->data) [(i)]), 100 - i - 1);

  g_array_free (garray, (!(0)));

  g_print ("ok\n");


  g_print ("checking strings...");

  string1 = g_string_new ("hi pete!");
  string2 = g_string_new ("");

  (void)({ if (!(__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p ("hi pete!") && __builtin_constant_p (string1->str) && (__s1_len = strlen ("hi pete!"), __s2_len = strlen (string1->str), (!((size_t)(const void *)(("hi pete!") + 1) - (size_t)(const void *)("hi pete!") == 1) || __s1_len >= 4) && (!((size_t)(const void *)((string1->str) + 1) - (size_t)(const void *)(string1->str) == 1) || __s2_len >= 4)) ? __builtin_strcmp ("hi pete!", string1->str) : (__builtin_constant_p ("hi pete!") && ((size_t)(const void *)(("hi pete!") + 1) - (size_t)(const void *)("hi pete!") == 1) && (__s1_len = strlen ("hi pete!"), __s1_len < 4) ? (__builtin_constant_p (string1->str) && ((size_t)(const void *)((string1->str) + 1) - (size_t)(const void *)(string1->str) == 1) ? __builtin_strcmp ("hi pete!", string1->str) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (string1->str); register int __result = (((__const unsigned char *) (__const char *) ("hi pete!"))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ("hi pete!"))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ("hi pete!"))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) ("hi pete!"))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (string1->str) && ((size_t)(const void *)((string1->str) + 1) - (size_t)(const void *)(string1->str) == 1) && (__s2_len = strlen (string1->str), __s2_len < 4) ? (__builtin_constant_p ("hi pete!") && ((size_t)(const void *)(("hi pete!") + 1) - (size_t)(const void *)("hi pete!") == 1) ? __builtin_strcmp ("hi pete!", string1->str) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) ("hi pete!"); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (string1->str))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (string1->str))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (string1->str))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (string1->str))[3]); } } __result; }))) : __builtin_strcmp ("hi pete!", string1->str)))); }) == 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 697, __PRETTY_FUNCTION__, "strcmp (\"hi pete!\", string1->str) == 0"); });

  for (i = 0; i < 10000; i++)
    g_string_append_c (string1, 'a'+(i%26));




  g_string_sprintf (string2, "%s|%0100d|%s|%s|%0*d|%*.*f|%10000.10000f",
      "this pete guy sure is a wuss, like he's the number ",
      1,
      " wuss.  everyone agrees.\n",
      string1->str,
      10, 666, 15, 15, 666.666666666, 666.666666666);
# 720 "testglib.c"
  g_print ("string2 length = %d...\n", string2->len);
  string2->str[70] = '\0';
  g_print ("first 70 chars:\n%s\n", string2->str);
  string2->str[141] = '\0';
  g_print ("next 70 chars:\n%s\n", string2->str+71);
  string2->str[212] = '\0';
  g_print ("and next 70:\n%s\n", string2->str+142);
  g_print ("last 70 chars:\n%s\n", string2->str+string2->len - 70);

  g_print ("ok\n");

  g_print ("checking timers...\n");

  timer = g_timer_new ();
  g_print ("  spinning for 3 seconds...\n");

  g_timer_start (timer);
  while (g_timer_elapsed (timer, ((void *)0)) < 3)
    ;

  g_timer_stop (timer);
  g_timer_destroy (timer);

  g_print ("ok\n");

  g_print ("checking g_strcasecmp...");
  (void)({ if (!(g_strcasecmp ("FroboZZ", "frobozz") == 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 746, __PRETTY_FUNCTION__, "g_strcasecmp (\"FroboZZ\", \"frobozz\") == 0"); });
  (void)({ if (!(g_strcasecmp ("frobozz", "frobozz") == 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 747, __PRETTY_FUNCTION__, "g_strcasecmp (\"frobozz\", \"frobozz\") == 0"); });
  (void)({ if (!(g_strcasecmp ("frobozz", "FROBOZZ") == 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 748, __PRETTY_FUNCTION__, "g_strcasecmp (\"frobozz\", \"FROBOZZ\") == 0"); });
  (void)({ if (!(g_strcasecmp ("FROBOZZ", "froboz") != 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 749, __PRETTY_FUNCTION__, "g_strcasecmp (\"FROBOZZ\", \"froboz\") != 0"); });
  (void)({ if (!(g_strcasecmp ("", "") == 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 750, __PRETTY_FUNCTION__, "g_strcasecmp (\"\", \"\") == 0"); });
  (void)({ if (!(g_strcasecmp ("!#%&/()", "!#%&/()") == 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 751, __PRETTY_FUNCTION__, "g_strcasecmp (\"!#%&/()\", \"!#%&/()\") == 0"); });
  (void)({ if (!(g_strcasecmp ("a", "b") < 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 752, __PRETTY_FUNCTION__, "g_strcasecmp (\"a\", \"b\") < 0"); });
  (void)({ if (!(g_strcasecmp ("a", "B") < 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 753, __PRETTY_FUNCTION__, "g_strcasecmp (\"a\", \"B\") < 0"); });
  (void)({ if (!(g_strcasecmp ("A", "b") < 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 754, __PRETTY_FUNCTION__, "g_strcasecmp (\"A\", \"b\") < 0"); });
  (void)({ if (!(g_strcasecmp ("A", "B") < 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 755, __PRETTY_FUNCTION__, "g_strcasecmp (\"A\", \"B\") < 0"); });
  (void)({ if (!(g_strcasecmp ("b", "a") > 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 756, __PRETTY_FUNCTION__, "g_strcasecmp (\"b\", \"a\") > 0"); });
  (void)({ if (!(g_strcasecmp ("b", "A") > 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 757, __PRETTY_FUNCTION__, "g_strcasecmp (\"b\", \"A\") > 0"); });
  (void)({ if (!(g_strcasecmp ("B", "a") > 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 758, __PRETTY_FUNCTION__, "g_strcasecmp (\"B\", \"a\") > 0"); });
  (void)({ if (!(g_strcasecmp ("B", "A") > 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 759, __PRETTY_FUNCTION__, "g_strcasecmp (\"B\", \"A\") > 0"); });

  g_print ("ok\n");

  g_print ("checking g_strdup...");
  (void)({ if (!(g_strdup(((void *)0)) == ((void *)0))) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 764, __PRETTY_FUNCTION__, "g_strdup(NULL) == NULL"); });
  string = g_strdup("el dorado ");
  (void)({ if (!(string != ((void *)0))) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 766, __PRETTY_FUNCTION__, "string != NULL"); });
  (void)({ if (!(__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (string) && __builtin_constant_p ("el dorado ") && (__s1_len = strlen (string), __s2_len = strlen ("el dorado "), (!((size_t)(const void *)((string) + 1) - (size_t)(const void *)(string) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("el dorado ") + 1) - (size_t)(const void *)("el dorado ") == 1) || __s2_len >= 4)) ? __builtin_strcmp (string, "el dorado ") : (__builtin_constant_p (string) && ((size_t)(const void *)((string) + 1) - (size_t)(const void *)(string) == 1) && (__s1_len = strlen (string), __s1_len < 4) ? (__builtin_constant_p ("el dorado ") && ((size_t)(const void *)(("el dorado ") + 1) - (size_t)(const void *)("el dorado ") == 1) ? __builtin_strcmp (string, "el dorado ") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("el dorado "); register int __result = (((__const unsigned char *) (__const char *) (string))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (string))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (string))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (string))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("el dorado ") && ((size_t)(const void *)(("el dorado ") + 1) - (size_t)(const void *)("el dorado ") == 1) && (__s2_len = strlen ("el dorado "), __s2_len < 4) ? (__builtin_constant_p (string) && ((size_t)(const void *)((string) + 1) - (size_t)(const void *)(string) == 1) ? __builtin_strcmp (string, "el dorado ") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (string); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("el dorado "))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("el dorado "))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("el dorado "))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("el dorado "))[3]); } } __result; }))) : __builtin_strcmp (string, "el dorado ")))); }) == 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 767, __PRETTY_FUNCTION__, "strcmp(string, GLIB_TEST_STRING) == 0"); });
  g_free(string);

  g_print ("ok\n");

  g_print ("checking g_strconcat...");
  string = g_strconcat("el dorado ", ((void *)0));
  (void)({ if (!(string != ((void *)0))) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 774, __PRETTY_FUNCTION__, "string != NULL"); });
  (void)({ if (!(__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (string) && __builtin_constant_p ("el dorado ") && (__s1_len = strlen (string), __s2_len = strlen ("el dorado "), (!((size_t)(const void *)((string) + 1) - (size_t)(const void *)(string) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("el dorado ") + 1) - (size_t)(const void *)("el dorado ") == 1) || __s2_len >= 4)) ? __builtin_strcmp (string, "el dorado ") : (__builtin_constant_p (string) && ((size_t)(const void *)((string) + 1) - (size_t)(const void *)(string) == 1) && (__s1_len = strlen (string), __s1_len < 4) ? (__builtin_constant_p ("el dorado ") && ((size_t)(const void *)(("el dorado ") + 1) - (size_t)(const void *)("el dorado ") == 1) ? __builtin_strcmp (string, "el dorado ") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("el dorado "); register int __result = (((__const unsigned char *) (__const char *) (string))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (string))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (string))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (string))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("el dorado ") && ((size_t)(const void *)(("el dorado ") + 1) - (size_t)(const void *)("el dorado ") == 1) && (__s2_len = strlen ("el dorado "), __s2_len < 4) ? (__builtin_constant_p (string) && ((size_t)(const void *)((string) + 1) - (size_t)(const void *)(string) == 1) ? __builtin_strcmp (string, "el dorado ") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (string); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("el dorado "))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("el dorado "))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("el dorado "))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("el dorado "))[3]); } } __result; }))) : __builtin_strcmp (string, "el dorado ")))); }) == 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 775, __PRETTY_FUNCTION__, "strcmp(string, GLIB_TEST_STRING) == 0"); });
  g_free(string);
  string = g_strconcat("el dorado ", "el dorado ",
           "el dorado ", ((void *)0));
  (void)({ if (!(string != ((void *)0))) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 779, __PRETTY_FUNCTION__, "string != NULL"); });
  (void)({ if (!(__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (string) && __builtin_constant_p ("el dorado " "el dorado " "el dorado ") && (__s1_len = strlen (string), __s2_len = strlen ("el dorado " "el dorado " "el dorado "), (!((size_t)(const void *)((string) + 1) - (size_t)(const void *)(string) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("el dorado " "el dorado " "el dorado ") + 1) - (size_t)(const void *)("el dorado " "el dorado " "el dorado ") == 1) || __s2_len >= 4)) ? __builtin_strcmp (string, "el dorado " "el dorado " "el dorado ") : (__builtin_constant_p (string) && ((size_t)(const void *)((string) + 1) - (size_t)(const void *)(string) == 1) && (__s1_len = strlen (string), __s1_len < 4) ? (__builtin_constant_p ("el dorado " "el dorado " "el dorado ") && ((size_t)(const void *)(("el dorado " "el dorado " "el dorado ") + 1) - (size_t)(const void *)("el dorado " "el dorado " "el dorado ") == 1) ? __builtin_strcmp (string, "el dorado " "el dorado " "el dorado ") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("el dorado " "el dorado " "el dorado "); register int __result = (((__const unsigned char *) (__const char *) (string))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (string))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (string))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (string))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("el dorado " "el dorado " "el dorado ") && ((size_t)(const void *)(("el dorado " "el dorado " "el dorado ") + 1) - (size_t)(const void *)("el dorado " "el dorado " "el dorado ") == 1) && (__s2_len = strlen ("el dorado " "el dorado " "el dorado "), __s2_len < 4) ? (__builtin_constant_p (string) && ((size_t)(const void *)((string) + 1) - (size_t)(const void *)(string) == 1) ? __builtin_strcmp (string, "el dorado " "el dorado " "el dorado ") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (string); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("el dorado " "el dorado " "el dorado "))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("el dorado " "el dorado " "el dorado "))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("el dorado " "el dorado " "el dorado "))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("el dorado " "el dorado " "el dorado "))[3]); } } __result; }))) : __builtin_strcmp (string, "el dorado " "el dorado " "el dorado ")))); }) == 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 781, __PRETTY_FUNCTION__, "strcmp(string, GLIB_TEST_STRING GLIB_TEST_STRING GLIB_TEST_STRING) == 0"); });

  g_free(string);

  g_print ("ok\n");

  g_print ("checking g_strdup_printf...");
  string = g_strdup_printf ("%05d %-5s", 21, "test");
  (void)({ if (!(string != ((void *)0))) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 788, __PRETTY_FUNCTION__, "string != NULL"); });
  (void)({ if (!(__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (string) && __builtin_constant_p ("00021 test ") && (__s1_len = strlen (string), __s2_len = strlen ("00021 test "), (!((size_t)(const void *)((string) + 1) - (size_t)(const void *)(string) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("00021 test ") + 1) - (size_t)(const void *)("00021 test ") == 1) || __s2_len >= 4)) ? __builtin_strcmp (string, "00021 test ") : (__builtin_constant_p (string) && ((size_t)(const void *)((string) + 1) - (size_t)(const void *)(string) == 1) && (__s1_len = strlen (string), __s1_len < 4) ? (__builtin_constant_p ("00021 test ") && ((size_t)(const void *)(("00021 test ") + 1) - (size_t)(const void *)("00021 test ") == 1) ? __builtin_strcmp (string, "00021 test ") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("00021 test "); register int __result = (((__const unsigned char *) (__const char *) (string))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (string))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (string))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (string))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("00021 test ") && ((size_t)(const void *)(("00021 test ") + 1) - (size_t)(const void *)("00021 test ") == 1) && (__s2_len = strlen ("00021 test "), __s2_len < 4) ? (__builtin_constant_p (string) && ((size_t)(const void *)((string) + 1) - (size_t)(const void *)(string) == 1) ? __builtin_strcmp (string, "00021 test ") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (string); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("00021 test "))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("00021 test "))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("00021 test "))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("00021 test "))[3]); } } __result; }))) : __builtin_strcmp (string, "00021 test ")))); }) == 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 789, __PRETTY_FUNCTION__, "strcmp(string, \"00021 test \") == 0"); });
  g_free (string);

  g_print ("ok\n");





  g_print ("checking relations...");

  relation = g_relation_new (2);

  g_relation_index (relation, 0, g_int_hash, g_int_equal);
  g_relation_index (relation, 1, g_int_hash, g_int_equal);

  for (i = 0; i < 1024; i += 1)
    data[i] = i;

  for (i = 1; i < 1023; i += 1)
    {
      g_relation_insert (relation, data + i, data + i + 1);
      g_relation_insert (relation, data + i, data + i - 1);
    }

  for (i = 2; i < 1022; i += 1)
    {
      (void)({ if (!(! g_relation_exists (relation, data + i, data + i))) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 816, __PRETTY_FUNCTION__, "! g_relation_exists (relation, data + i, data + i)"); });
      (void)({ if (!(! g_relation_exists (relation, data + i, data + i + 2))) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 817, __PRETTY_FUNCTION__, "! g_relation_exists (relation, data + i, data + i + 2)"); });
      (void)({ if (!(! g_relation_exists (relation, data + i, data + i - 2))) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 818, __PRETTY_FUNCTION__, "! g_relation_exists (relation, data + i, data + i - 2)"); });
    }

  for (i = 1; i < 1023; i += 1)
    {
      (void)({ if (!(g_relation_exists (relation, data + i, data + i + 1))) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 823, __PRETTY_FUNCTION__, "g_relation_exists (relation, data + i, data + i + 1)"); });
      (void)({ if (!(g_relation_exists (relation, data + i, data + i - 1))) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 824, __PRETTY_FUNCTION__, "g_relation_exists (relation, data + i, data + i - 1)"); });
    }

  for (i = 2; i < 1022; i += 1)
    {
      (void)({ if (!(g_relation_count (relation, data + i, 0) == 2)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 829, __PRETTY_FUNCTION__, "g_relation_count (relation, data + i, 0) == 2"); });
      (void)({ if (!(g_relation_count (relation, data + i, 1) == 2)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 830, __PRETTY_FUNCTION__, "g_relation_count (relation, data + i, 1) == 2"); });
    }

  (void)({ if (!(g_relation_count (relation, data, 0) == 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 833, __PRETTY_FUNCTION__, "g_relation_count (relation, data, 0) == 0"); });

  (void)({ if (!(g_relation_count (relation, data + 42, 0) == 2)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 835, __PRETTY_FUNCTION__, "g_relation_count (relation, data + 42, 0) == 2"); });
  (void)({ if (!(g_relation_count (relation, data + 43, 1) == 2)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 836, __PRETTY_FUNCTION__, "g_relation_count (relation, data + 43, 1) == 2"); });
  (void)({ if (!(g_relation_count (relation, data + 41, 1) == 2)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 837, __PRETTY_FUNCTION__, "g_relation_count (relation, data + 41, 1) == 2"); });
  g_relation_delete (relation, data + 42, 0);
  (void)({ if (!(g_relation_count (relation, data + 42, 0) == 0)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 839, __PRETTY_FUNCTION__, "g_relation_count (relation, data + 42, 0) == 0"); });
  (void)({ if (!(g_relation_count (relation, data + 43, 1) == 1)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 840, __PRETTY_FUNCTION__, "g_relation_count (relation, data + 43, 1) == 1"); });
  (void)({ if (!(g_relation_count (relation, data + 41, 1) == 1)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 841, __PRETTY_FUNCTION__, "g_relation_count (relation, data + 41, 1) == 1"); });

  tuples = g_relation_select (relation, data + 200, 0);

  (void)({ if (!(tuples->len == 2)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 845, __PRETTY_FUNCTION__, "tuples->len == 2"); });
# 856 "testglib.c"
  (void)({ if (!(g_relation_exists (relation, data + 300, data + 301))) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 856, __PRETTY_FUNCTION__, "g_relation_exists (relation, data + 300, data + 301)"); });
  g_relation_delete (relation, data + 300, 0);
  (void)({ if (!(!g_relation_exists (relation, data + 300, data + 301))) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 858, __PRETTY_FUNCTION__, "!g_relation_exists (relation, data + 300, data + 301)"); });

  g_tuples_destroy (tuples);

  g_relation_destroy (relation);

  relation = ((void *)0);

  g_print ("ok\n");

  g_print ("checking pointer arrays...");

  gparray = g_ptr_array_new ();
  for (i = 0; i < 10000; i++)
    g_ptr_array_add (gparray, ((gpointer) (glong) (i)));

  for (i = 0; i < 10000; i++)
    if ((gparray->pdata)[i] != ((gpointer) (glong) (i)))
      g_print ("array fails: %p ( %p )\n", (gparray->pdata)[i], ((gpointer) (glong) (i)));

  g_ptr_array_free (gparray, (!(0)));

  g_print ("ok\n");


  g_print ("checking byte arrays...");

  gbarray = g_byte_array_new ();
  for (i = 0; i < 10000; i++)
    g_byte_array_append (gbarray, (guint8*) "abcd", 4);

  for (i = 0; i < 10000; i++)
    {
      (void)({ if (!(gbarray->data[4*i] == 'a')) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 891, __PRETTY_FUNCTION__, "gbarray->data[4*i] == 'a'"); });
      (void)({ if (!(gbarray->data[4*i+1] == 'b')) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 892, __PRETTY_FUNCTION__, "gbarray->data[4*i+1] == 'b'"); });
      (void)({ if (!(gbarray->data[4*i+2] == 'c')) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 893, __PRETTY_FUNCTION__, "gbarray->data[4*i+2] == 'c'"); });
      (void)({ if (!(gbarray->data[4*i+3] == 'd')) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 894, __PRETTY_FUNCTION__, "gbarray->data[4*i+3] == 'd'"); });
    }

  g_byte_array_free (gbarray, (!(0)));
  g_print ("ok\n");

  g_printerr ("g_log tests:");
  g_log (((gchar*) 0), G_LOG_LEVEL_WARNING, "harmless warning with parameters: %d %s %#x", 42, "Boo", 12345);
  g_log (((gchar*) 0), G_LOG_LEVEL_MESSAGE, "the next warning is a test:");
  string = ((void *)0);
  g_print (string);

  g_print ("checking endian macros (host is ");

  g_print ("big endian)...");



  (void)({ if (!((((guint16) ( (((guint16) (gu16t1) & (guint16) 0x00ffU) << 8) | (((guint16) (gu16t1) & (guint16) 0xff00U) >> 8)))) == gu16t2)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 912, __PRETTY_FUNCTION__, "GUINT16_SWAP_LE_BE (gu16t1) == gu16t2"); });
  (void)({ if (!((((guint32) ( (((guint32) (gu32t1) & (guint32) 0x000000ffU) << 24) | (((guint32) (gu32t1) & (guint32) 0x0000ff00U) << 8) | (((guint32) (gu32t1) & (guint32) 0x00ff0000U) >> 8) | (((guint32) (gu32t1) & (guint32) 0xff000000U) >> 24)))) == gu32t2)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 913, __PRETTY_FUNCTION__, "GUINT32_SWAP_LE_BE (gu32t1) == gu32t2"); });

  (void)({ if (!((((guint64) ( (((guint64) (gu64t1) & (guint64) (0x00000000000000ffUL)) << 56) | (((guint64) (gu64t1) & (guint64) (0x000000000000ff00UL)) << 40) | (((guint64) (gu64t1) & (guint64) (0x0000000000ff0000UL)) << 24) | (((guint64) (gu64t1) & (guint64) (0x00000000ff000000UL)) << 8) | (((guint64) (gu64t1) & (guint64) (0x000000ff00000000UL)) >> 8) | (((guint64) (gu64t1) & (guint64) (0x0000ff0000000000UL)) >> 24) | (((guint64) (gu64t1) & (guint64) (0x00ff000000000000UL)) >> 40) | (((guint64) (gu64t1) & (guint64) (0xff00000000000000UL)) >> 56)))) == gu64t2)) g_log (((gchar*) 0), G_LOG_LEVEL_ERROR, "file %s: line %d (%s): assertion failed: (%s)", "testglib.c", 915, __PRETTY_FUNCTION__, "GUINT64_SWAP_LE_BE (gu64t1) == gu64t2"); });

  g_print ("ok\n");

  return 0;
}