/* Generated by Frama-C */
#include "pthread.h"
#include "sched.h"
#include "signal.h"
#include "stddef.h"
#include "stdint.h"
#include "stdio.h"
#include "stdlib.h"
#include "time.h"
extern  __attribute__((__FC_BUILTIN__)) int __e_acsl_sound_verdict;

int A = 0;
int B;
void __e_acsl_globals_init(void)
{
  static char __e_acsl_already_run = 0;
  if (! __e_acsl_already_run) {
    __e_acsl_already_run = 1;
    __e_acsl_store_block((void *)(& B),4UL);
    __e_acsl_full_init((void *)(& B));
    __e_acsl_store_block((void *)(& A),4UL);
    __e_acsl_full_init((void *)(& A));
  }
  return;
}

void __e_acsl_globals_clean(void)
{
  __e_acsl_delete_block((void *)(& B));
  __e_acsl_delete_block((void *)(& A));
  return;
}

int main(void)
{
  int __retres;
  int b;
  long *r;
  long d[2];
  int dup[2];
  __e_acsl_memory_init((int *)0,(char ***)0,8UL);
  __e_acsl_globals_init();
  __e_acsl_store_block((void *)(d),16UL);
  __e_acsl_store_block((void *)(& r),8UL);
  __e_acsl_store_block((void *)(& b),4UL);
  int *p = & A;
  __e_acsl_store_block((void *)(& p),8UL);
  __e_acsl_full_init((void *)(& p));
  int *q = & B;
  __e_acsl_store_block((void *)(& q),8UL);
  __e_acsl_full_init((void *)(& q));
  {
    __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
    __gen_e_acsl_assert_data.blocking = 1;
    __gen_e_acsl_assert_data.kind = "Assertion";
    __gen_e_acsl_assert_data.pred_txt = "\\initialized(&A)";
    __gen_e_acsl_assert_data.file = "initialized.c";
    __gen_e_acsl_assert_data.fct = "main";
    __gen_e_acsl_assert_data.line = 16;
    __e_acsl_assert(1,& __gen_e_acsl_assert_data);
  }
  /*@ assert \initialized(&A); */ ;
  {
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
      {.values = (void *)0};
    __gen_e_acsl_assert_data_2.blocking = 1;
    __gen_e_acsl_assert_data_2.kind = "Assertion";
    __gen_e_acsl_assert_data_2.pred_txt = "\\initialized(&B)";
    __gen_e_acsl_assert_data_2.file = "initialized.c";
    __gen_e_acsl_assert_data_2.fct = "main";
    __gen_e_acsl_assert_data_2.line = 17;
    __e_acsl_assert(1,& __gen_e_acsl_assert_data_2);
  }
  /*@ assert \initialized(&B); */ ;
  {
    int __gen_e_acsl_initialized;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,"p",(void *)p);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_3,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized = __e_acsl_initialized((void *)p,sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
                                 "\\initialized(p)",0,
                                 __gen_e_acsl_initialized);
    __gen_e_acsl_assert_data_3.blocking = 1;
    __gen_e_acsl_assert_data_3.kind = "Assertion";
    __gen_e_acsl_assert_data_3.pred_txt = "\\initialized(p)";
    __gen_e_acsl_assert_data_3.file = "initialized.c";
    __gen_e_acsl_assert_data_3.fct = "main";
    __gen_e_acsl_assert_data_3.line = 18;
    __e_acsl_assert(__gen_e_acsl_initialized,& __gen_e_acsl_assert_data_3);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
  }
  /*@ assert \initialized(p); */ ;
  {
    int __gen_e_acsl_initialized_2;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_4,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_4,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)q,sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,
                                 "\\initialized(q)",0,
                                 __gen_e_acsl_initialized_2);
    __gen_e_acsl_assert_data_4.blocking = 1;
    __gen_e_acsl_assert_data_4.kind = "Assertion";
    __gen_e_acsl_assert_data_4.pred_txt = "\\initialized(q)";
    __gen_e_acsl_assert_data_4.file = "initialized.c";
    __gen_e_acsl_assert_data_4.fct = "main";
    __gen_e_acsl_assert_data_4.line = 19;
    __e_acsl_assert(__gen_e_acsl_initialized_2,& __gen_e_acsl_assert_data_4);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
  }
  /*@ assert \initialized(q); */ ;
  int a = 0;
  __e_acsl_store_block((void *)(& a),4UL);
  __e_acsl_full_init((void *)(& a));
  long c[2] = {(long)1, (long)1};
  __e_acsl_store_block((void *)(c),16UL);
  __e_acsl_full_init((void *)(& c));
  __e_acsl_full_init((void *)(& p));
  p = & a;
  __e_acsl_full_init((void *)(& q));
  q = & b;
  {
    int __gen_e_acsl_initialized_3;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_5 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_5,"&a",
                                 (void *)(& a));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_5,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& a),
                                                      sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,
                                 "\\initialized(&a)",0,
                                 __gen_e_acsl_initialized_3);
    __gen_e_acsl_assert_data_5.blocking = 1;
    __gen_e_acsl_assert_data_5.kind = "Assertion";
    __gen_e_acsl_assert_data_5.pred_txt = "\\initialized(&a)";
    __gen_e_acsl_assert_data_5.file = "initialized.c";
    __gen_e_acsl_assert_data_5.fct = "main";
    __gen_e_acsl_assert_data_5.line = 30;
    __e_acsl_assert(__gen_e_acsl_initialized_3,& __gen_e_acsl_assert_data_5);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_5);
  }
  /*@ assert \initialized(&a); */ ;
  {
    int __gen_e_acsl_initialized_4;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_6 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_6,"&b",
                                 (void *)(& b));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_6,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& b),
                                                      sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
                                 "\\initialized(&b)",0,
                                 __gen_e_acsl_initialized_4);
    __gen_e_acsl_assert_data_6.blocking = 1;
    __gen_e_acsl_assert_data_6.kind = "Assertion";
    __gen_e_acsl_assert_data_6.pred_txt = "!\\initialized(&b)";
    __gen_e_acsl_assert_data_6.file = "initialized.c";
    __gen_e_acsl_assert_data_6.fct = "main";
    __gen_e_acsl_assert_data_6.line = 31;
    __e_acsl_assert(! __gen_e_acsl_initialized_4,
                    & __gen_e_acsl_assert_data_6);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_6);
  }
  /*@ assert !\initialized(&b); */ ;
  {
    int __gen_e_acsl_initialized_5;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_7 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_7,"p",(void *)p);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_7,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)p,sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,
                                 "\\initialized(p)",0,
                                 __gen_e_acsl_initialized_5);
    __gen_e_acsl_assert_data_7.blocking = 1;
    __gen_e_acsl_assert_data_7.kind = "Assertion";
    __gen_e_acsl_assert_data_7.pred_txt = "\\initialized(p)";
    __gen_e_acsl_assert_data_7.file = "initialized.c";
    __gen_e_acsl_assert_data_7.fct = "main";
    __gen_e_acsl_assert_data_7.line = 32;
    __e_acsl_assert(__gen_e_acsl_initialized_5,& __gen_e_acsl_assert_data_7);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_7);
  }
  /*@ assert \initialized(p); */ ;
  {
    int __gen_e_acsl_initialized_6;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_8 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_8,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_8,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)q,sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,
                                 "\\initialized(q)",0,
                                 __gen_e_acsl_initialized_6);
    __gen_e_acsl_assert_data_8.blocking = 1;
    __gen_e_acsl_assert_data_8.kind = "Assertion";
    __gen_e_acsl_assert_data_8.pred_txt = "!\\initialized(q)";
    __gen_e_acsl_assert_data_8.file = "initialized.c";
    __gen_e_acsl_assert_data_8.fct = "main";
    __gen_e_acsl_assert_data_8.line = 33;
    __e_acsl_assert(! __gen_e_acsl_initialized_6,
                    & __gen_e_acsl_assert_data_8);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_8);
  }
  /*@ assert !\initialized(q); */ ;
  {
    int __gen_e_acsl_initialized_7;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_9 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_9,"&c",
                                 (void *)(& c));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_9,
                                   "sizeof(long [2])",0,sizeof(long [2]));
    __gen_e_acsl_initialized_7 = __e_acsl_initialized((void *)(& c),
                                                      sizeof(long [2]));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_9,
                                 "\\initialized(&c)",0,
                                 __gen_e_acsl_initialized_7);
    __gen_e_acsl_assert_data_9.blocking = 1;
    __gen_e_acsl_assert_data_9.kind = "Assertion";
    __gen_e_acsl_assert_data_9.pred_txt = "\\initialized(&c)";
    __gen_e_acsl_assert_data_9.file = "initialized.c";
    __gen_e_acsl_assert_data_9.fct = "main";
    __gen_e_acsl_assert_data_9.line = 34;
    __e_acsl_assert(__gen_e_acsl_initialized_7,& __gen_e_acsl_assert_data_9);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_9);
  }
  /*@ assert \initialized(&c); */ ;
  {
    int __gen_e_acsl_initialized_8;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_10 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_10,"&d",
                                 (void *)(& d));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_10,
                                   "sizeof(long [2])",0,sizeof(long [2]));
    __gen_e_acsl_initialized_8 = __e_acsl_initialized((void *)(& d),
                                                      sizeof(long [2]));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_10,
                                 "\\initialized(&d)",0,
                                 __gen_e_acsl_initialized_8);
    __gen_e_acsl_assert_data_10.blocking = 1;
    __gen_e_acsl_assert_data_10.kind = "Assertion";
    __gen_e_acsl_assert_data_10.pred_txt = "!\\initialized(&d)";
    __gen_e_acsl_assert_data_10.file = "initialized.c";
    __gen_e_acsl_assert_data_10.fct = "main";
    __gen_e_acsl_assert_data_10.line = 35;
    __e_acsl_assert(! __gen_e_acsl_initialized_8,
                    & __gen_e_acsl_assert_data_10);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_10);
  }
  /*@ assert !\initialized(&d); */ ;
  __e_acsl_full_init((void *)(& b));
  b = 0;
  {
    int __gen_e_acsl_initialized_9;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_11 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_11,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_11,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_9 = __e_acsl_initialized((void *)q,sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_11,
                                 "\\initialized(q)",0,
                                 __gen_e_acsl_initialized_9);
    __gen_e_acsl_assert_data_11.blocking = 1;
    __gen_e_acsl_assert_data_11.kind = "Assertion";
    __gen_e_acsl_assert_data_11.pred_txt = "\\initialized(q)";
    __gen_e_acsl_assert_data_11.file = "initialized.c";
    __gen_e_acsl_assert_data_11.fct = "main";
    __gen_e_acsl_assert_data_11.line = 39;
    __e_acsl_assert(__gen_e_acsl_initialized_9,& __gen_e_acsl_assert_data_11);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_11);
  }
  /*@ assert \initialized(q); */ ;
  {
    int __gen_e_acsl_initialized_10;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_12 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_12,"&b",
                                 (void *)(& b));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_12,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_10 = __e_acsl_initialized((void *)(& b),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_12,
                                 "\\initialized(&b)",0,
                                 __gen_e_acsl_initialized_10);
    __gen_e_acsl_assert_data_12.blocking = 1;
    __gen_e_acsl_assert_data_12.kind = "Assertion";
    __gen_e_acsl_assert_data_12.pred_txt = "\\initialized(&b)";
    __gen_e_acsl_assert_data_12.file = "initialized.c";
    __gen_e_acsl_assert_data_12.fct = "main";
    __gen_e_acsl_assert_data_12.line = 40;
    __e_acsl_assert(__gen_e_acsl_initialized_10,
                    & __gen_e_acsl_assert_data_12);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_12);
  }
  /*@ assert \initialized(&b); */ ;
  __e_acsl_full_init((void *)(& r));
  r = d;
  {
    int __gen_e_acsl_initialized_11;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_13 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_13,"(long *)d",
                                 (void *)(d));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_13,
                                   "sizeof(long)",0,sizeof(long));
    __gen_e_acsl_initialized_11 = __e_acsl_initialized((void *)(d),
                                                       sizeof(long));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_13,
                                 "\\initialized((long *)d)",0,
                                 __gen_e_acsl_initialized_11);
    __gen_e_acsl_assert_data_13.blocking = 1;
    __gen_e_acsl_assert_data_13.kind = "Assertion";
    __gen_e_acsl_assert_data_13.pred_txt = "!\\initialized((long *)d)";
    __gen_e_acsl_assert_data_13.file = "initialized.c";
    __gen_e_acsl_assert_data_13.fct = "main";
    __gen_e_acsl_assert_data_13.line = 43;
    __e_acsl_assert(! __gen_e_acsl_initialized_11,
                    & __gen_e_acsl_assert_data_13);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_13);
  }
  /*@ assert !\initialized((long *)d); */ ;
  {
    int __gen_e_acsl_initialized_12;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_14 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_14,"&d[1]",
                                 (void *)(& d[1]));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_14,
                                   "sizeof(long)",0,sizeof(long));
    __gen_e_acsl_initialized_12 = __e_acsl_initialized((void *)(& d[1]),
                                                       sizeof(long));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,
                                 "\\initialized(&d[1])",0,
                                 __gen_e_acsl_initialized_12);
    __gen_e_acsl_assert_data_14.blocking = 1;
    __gen_e_acsl_assert_data_14.kind = "Assertion";
    __gen_e_acsl_assert_data_14.pred_txt = "!\\initialized(&d[1])";
    __gen_e_acsl_assert_data_14.file = "initialized.c";
    __gen_e_acsl_assert_data_14.fct = "main";
    __gen_e_acsl_assert_data_14.line = 44;
    __e_acsl_assert(! __gen_e_acsl_initialized_12,
                    & __gen_e_acsl_assert_data_14);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_14);
  }
  /*@ assert !\initialized(&d[1]); */ ;
  {
    int __gen_e_acsl_initialized_13;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_15 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_15,"&d",
                                 (void *)(& d));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_15,
                                   "sizeof(long [2])",0,sizeof(long [2]));
    __gen_e_acsl_initialized_13 = __e_acsl_initialized((void *)(& d),
                                                       sizeof(long [2]));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_15,
                                 "\\initialized(&d)",0,
                                 __gen_e_acsl_initialized_13);
    __gen_e_acsl_assert_data_15.blocking = 1;
    __gen_e_acsl_assert_data_15.kind = "Assertion";
    __gen_e_acsl_assert_data_15.pred_txt = "!\\initialized(&d)";
    __gen_e_acsl_assert_data_15.file = "initialized.c";
    __gen_e_acsl_assert_data_15.fct = "main";
    __gen_e_acsl_assert_data_15.line = 45;
    __e_acsl_assert(! __gen_e_acsl_initialized_13,
                    & __gen_e_acsl_assert_data_15);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_15);
  }
  /*@ assert !\initialized(&d); */ ;
  {
    int __gen_e_acsl_initialized_14;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_16 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_16,"r",(void *)r);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_16,
                                   "sizeof(long)",0,sizeof(long));
    __gen_e_acsl_initialized_14 = __e_acsl_initialized((void *)r,
                                                       sizeof(long));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_16,
                                 "\\initialized(r)",0,
                                 __gen_e_acsl_initialized_14);
    __gen_e_acsl_assert_data_16.blocking = 1;
    __gen_e_acsl_assert_data_16.kind = "Assertion";
    __gen_e_acsl_assert_data_16.pred_txt = "!\\initialized(r)";
    __gen_e_acsl_assert_data_16.file = "initialized.c";
    __gen_e_acsl_assert_data_16.fct = "main";
    __gen_e_acsl_assert_data_16.line = 46;
    __e_acsl_assert(! __gen_e_acsl_initialized_14,
                    & __gen_e_acsl_assert_data_16);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_16);
  }
  /*@ assert !\initialized(r); */ ;
  {
    int __gen_e_acsl_initialized_15;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_17 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_17,"r",(void *)r);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_17,
                                   "sizeof(long)",0,sizeof(long));
    __gen_e_acsl_initialized_15 = __e_acsl_initialized((void *)(r + 1),
                                                       sizeof(long));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_17,
                                 "\\initialized(r + 1)",0,
                                 __gen_e_acsl_initialized_15);
    __gen_e_acsl_assert_data_17.blocking = 1;
    __gen_e_acsl_assert_data_17.kind = "Assertion";
    __gen_e_acsl_assert_data_17.pred_txt = "!\\initialized(r + 1)";
    __gen_e_acsl_assert_data_17.file = "initialized.c";
    __gen_e_acsl_assert_data_17.fct = "main";
    __gen_e_acsl_assert_data_17.line = 47;
    __e_acsl_assert(! __gen_e_acsl_initialized_15,
                    & __gen_e_acsl_assert_data_17);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_17);
  }
  /*@ assert !\initialized(r + 1); */ ;
  __e_acsl_initialize((void *)(d),sizeof(long));
  d[0] = (long)1;
  {
    int __gen_e_acsl_initialized_16;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_18 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_18,"(long *)d",
                                 (void *)(d));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_18,
                                   "sizeof(long)",0,sizeof(long));
    __gen_e_acsl_initialized_16 = __e_acsl_initialized((void *)(d),
                                                       sizeof(long));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_18,
                                 "\\initialized((long *)d)",0,
                                 __gen_e_acsl_initialized_16);
    __gen_e_acsl_assert_data_18.blocking = 1;
    __gen_e_acsl_assert_data_18.kind = "Assertion";
    __gen_e_acsl_assert_data_18.pred_txt = "\\initialized((long *)d)";
    __gen_e_acsl_assert_data_18.file = "initialized.c";
    __gen_e_acsl_assert_data_18.fct = "main";
    __gen_e_acsl_assert_data_18.line = 50;
    __e_acsl_assert(__gen_e_acsl_initialized_16,
                    & __gen_e_acsl_assert_data_18);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_18);
  }
  /*@ assert \initialized((long *)d); */ ;
  {
    int __gen_e_acsl_initialized_17;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_19 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_19,"&d[1]",
                                 (void *)(& d[1]));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_19,
                                   "sizeof(long)",0,sizeof(long));
    __gen_e_acsl_initialized_17 = __e_acsl_initialized((void *)(& d[1]),
                                                       sizeof(long));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_19,
                                 "\\initialized(&d[1])",0,
                                 __gen_e_acsl_initialized_17);
    __gen_e_acsl_assert_data_19.blocking = 1;
    __gen_e_acsl_assert_data_19.kind = "Assertion";
    __gen_e_acsl_assert_data_19.pred_txt = "!\\initialized(&d[1])";
    __gen_e_acsl_assert_data_19.file = "initialized.c";
    __gen_e_acsl_assert_data_19.fct = "main";
    __gen_e_acsl_assert_data_19.line = 51;
    __e_acsl_assert(! __gen_e_acsl_initialized_17,
                    & __gen_e_acsl_assert_data_19);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_19);
  }
  /*@ assert !\initialized(&d[1]); */ ;
  {
    int __gen_e_acsl_initialized_18;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_20 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_20,"&d",
                                 (void *)(& d));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_20,
                                   "sizeof(long [2])",0,sizeof(long [2]));
    __gen_e_acsl_initialized_18 = __e_acsl_initialized((void *)(& d),
                                                       sizeof(long [2]));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_20,
                                 "\\initialized(&d)",0,
                                 __gen_e_acsl_initialized_18);
    __gen_e_acsl_assert_data_20.blocking = 1;
    __gen_e_acsl_assert_data_20.kind = "Assertion";
    __gen_e_acsl_assert_data_20.pred_txt = "!\\initialized(&d)";
    __gen_e_acsl_assert_data_20.file = "initialized.c";
    __gen_e_acsl_assert_data_20.fct = "main";
    __gen_e_acsl_assert_data_20.line = 52;
    __e_acsl_assert(! __gen_e_acsl_initialized_18,
                    & __gen_e_acsl_assert_data_20);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_20);
  }
  /*@ assert !\initialized(&d); */ ;
  {
    int __gen_e_acsl_initialized_19;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_21 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_21,"r",(void *)r);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_21,
                                   "sizeof(long)",0,sizeof(long));
    __gen_e_acsl_initialized_19 = __e_acsl_initialized((void *)r,
                                                       sizeof(long));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_21,
                                 "\\initialized(r)",0,
                                 __gen_e_acsl_initialized_19);
    __gen_e_acsl_assert_data_21.blocking = 1;
    __gen_e_acsl_assert_data_21.kind = "Assertion";
    __gen_e_acsl_assert_data_21.pred_txt = "\\initialized(r)";
    __gen_e_acsl_assert_data_21.file = "initialized.c";
    __gen_e_acsl_assert_data_21.fct = "main";
    __gen_e_acsl_assert_data_21.line = 53;
    __e_acsl_assert(__gen_e_acsl_initialized_19,
                    & __gen_e_acsl_assert_data_21);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_21);
  }
  /*@ assert \initialized(r); */ ;
  {
    int __gen_e_acsl_initialized_20;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_22 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_22,"r",(void *)r);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_22,
                                   "sizeof(long)",0,sizeof(long));
    __gen_e_acsl_initialized_20 = __e_acsl_initialized((void *)(r + 1),
                                                       sizeof(long));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_22,
                                 "\\initialized(r + 1)",0,
                                 __gen_e_acsl_initialized_20);
    __gen_e_acsl_assert_data_22.blocking = 1;
    __gen_e_acsl_assert_data_22.kind = "Assertion";
    __gen_e_acsl_assert_data_22.pred_txt = "!\\initialized(r + 1)";
    __gen_e_acsl_assert_data_22.file = "initialized.c";
    __gen_e_acsl_assert_data_22.fct = "main";
    __gen_e_acsl_assert_data_22.line = 54;
    __e_acsl_assert(! __gen_e_acsl_initialized_20,
                    & __gen_e_acsl_assert_data_22);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_22);
  }
  /*@ assert !\initialized(r + 1); */ ;
  __e_acsl_initialize((void *)(& d[1]),sizeof(long));
  d[1] = (long)1;
  {
    int __gen_e_acsl_initialized_21;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_23 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_23,"(long *)d",
                                 (void *)(d));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_23,
                                   "sizeof(long)",0,sizeof(long));
    __gen_e_acsl_initialized_21 = __e_acsl_initialized((void *)(d),
                                                       sizeof(long));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_23,
                                 "\\initialized((long *)d)",0,
                                 __gen_e_acsl_initialized_21);
    __gen_e_acsl_assert_data_23.blocking = 1;
    __gen_e_acsl_assert_data_23.kind = "Assertion";
    __gen_e_acsl_assert_data_23.pred_txt = "\\initialized((long *)d)";
    __gen_e_acsl_assert_data_23.file = "initialized.c";
    __gen_e_acsl_assert_data_23.fct = "main";
    __gen_e_acsl_assert_data_23.line = 57;
    __e_acsl_assert(__gen_e_acsl_initialized_21,
                    & __gen_e_acsl_assert_data_23);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_23);
  }
  /*@ assert \initialized((long *)d); */ ;
  {
    int __gen_e_acsl_initialized_22;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_24 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_24,"&d[1]",
                                 (void *)(& d[1]));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_24,
                                   "sizeof(long)",0,sizeof(long));
    __gen_e_acsl_initialized_22 = __e_acsl_initialized((void *)(& d[1]),
                                                       sizeof(long));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_24,
                                 "\\initialized(&d[1])",0,
                                 __gen_e_acsl_initialized_22);
    __gen_e_acsl_assert_data_24.blocking = 1;
    __gen_e_acsl_assert_data_24.kind = "Assertion";
    __gen_e_acsl_assert_data_24.pred_txt = "\\initialized(&d[1])";
    __gen_e_acsl_assert_data_24.file = "initialized.c";
    __gen_e_acsl_assert_data_24.fct = "main";
    __gen_e_acsl_assert_data_24.line = 58;
    __e_acsl_assert(__gen_e_acsl_initialized_22,
                    & __gen_e_acsl_assert_data_24);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_24);
  }
  /*@ assert \initialized(&d[1]); */ ;
  {
    int __gen_e_acsl_initialized_23;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_25 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_25,"&d",
                                 (void *)(& d));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_25,
                                   "sizeof(long [2])",0,sizeof(long [2]));
    __gen_e_acsl_initialized_23 = __e_acsl_initialized((void *)(& d),
                                                       sizeof(long [2]));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_25,
                                 "\\initialized(&d)",0,
                                 __gen_e_acsl_initialized_23);
    __gen_e_acsl_assert_data_25.blocking = 1;
    __gen_e_acsl_assert_data_25.kind = "Assertion";
    __gen_e_acsl_assert_data_25.pred_txt = "\\initialized(&d)";
    __gen_e_acsl_assert_data_25.file = "initialized.c";
    __gen_e_acsl_assert_data_25.fct = "main";
    __gen_e_acsl_assert_data_25.line = 59;
    __e_acsl_assert(__gen_e_acsl_initialized_23,
                    & __gen_e_acsl_assert_data_25);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_25);
  }
  /*@ assert \initialized(&d); */ ;
  {
    int __gen_e_acsl_initialized_24;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_26 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_26,"r",(void *)r);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_26,
                                   "sizeof(long)",0,sizeof(long));
    __gen_e_acsl_initialized_24 = __e_acsl_initialized((void *)r,
                                                       sizeof(long));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_26,
                                 "\\initialized(r)",0,
                                 __gen_e_acsl_initialized_24);
    __gen_e_acsl_assert_data_26.blocking = 1;
    __gen_e_acsl_assert_data_26.kind = "Assertion";
    __gen_e_acsl_assert_data_26.pred_txt = "\\initialized(r)";
    __gen_e_acsl_assert_data_26.file = "initialized.c";
    __gen_e_acsl_assert_data_26.fct = "main";
    __gen_e_acsl_assert_data_26.line = 60;
    __e_acsl_assert(__gen_e_acsl_initialized_24,
                    & __gen_e_acsl_assert_data_26);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_26);
  }
  /*@ assert \initialized(r); */ ;
  {
    int __gen_e_acsl_initialized_25;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_27 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_27,"r",(void *)r);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_27,
                                   "sizeof(long)",0,sizeof(long));
    __gen_e_acsl_initialized_25 = __e_acsl_initialized((void *)(r + 1),
                                                       sizeof(long));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_27,
                                 "\\initialized(r + 1)",0,
                                 __gen_e_acsl_initialized_25);
    __gen_e_acsl_assert_data_27.blocking = 1;
    __gen_e_acsl_assert_data_27.kind = "Assertion";
    __gen_e_acsl_assert_data_27.pred_txt = "\\initialized(r + 1)";
    __gen_e_acsl_assert_data_27.file = "initialized.c";
    __gen_e_acsl_assert_data_27.fct = "main";
    __gen_e_acsl_assert_data_27.line = 61;
    __e_acsl_assert(__gen_e_acsl_initialized_25,
                    & __gen_e_acsl_assert_data_27);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_27);
  }
  /*@ assert \initialized(r + 1); */ ;
  __e_acsl_full_init((void *)(& p));
  p = (int *)malloc(sizeof(int *));
  {
    int __gen_e_acsl_initialized_26;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_28 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_28,"p",(void *)p);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_28,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_26 = __e_acsl_initialized((void *)p,sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_28,
                                 "\\initialized(p)",0,
                                 __gen_e_acsl_initialized_26);
    __gen_e_acsl_assert_data_28.blocking = 1;
    __gen_e_acsl_assert_data_28.kind = "Assertion";
    __gen_e_acsl_assert_data_28.pred_txt = "!\\initialized(p)";
    __gen_e_acsl_assert_data_28.file = "initialized.c";
    __gen_e_acsl_assert_data_28.fct = "main";
    __gen_e_acsl_assert_data_28.line = 65;
    __e_acsl_assert(! __gen_e_acsl_initialized_26,
                    & __gen_e_acsl_assert_data_28);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_28);
  }
  /*@ assert !\initialized(p); */ ;
  __e_acsl_full_init((void *)(& q));
  q = (int *)calloc((size_t)1,sizeof(int));
  {
    int __gen_e_acsl_initialized_27;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_29 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_29,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_29,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_27 = __e_acsl_initialized((void *)q,sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_29,
                                 "\\initialized(q)",0,
                                 __gen_e_acsl_initialized_27);
    __gen_e_acsl_assert_data_29.blocking = 1;
    __gen_e_acsl_assert_data_29.kind = "Assertion";
    __gen_e_acsl_assert_data_29.pred_txt = "\\initialized(q)";
    __gen_e_acsl_assert_data_29.file = "initialized.c";
    __gen_e_acsl_assert_data_29.fct = "main";
    __gen_e_acsl_assert_data_29.line = 69;
    __e_acsl_assert(__gen_e_acsl_initialized_27,
                    & __gen_e_acsl_assert_data_29);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_29);
  }
  /*@ assert \initialized(q); */ ;
  __e_acsl_full_init((void *)(& q));
  q = (int *)realloc((void *)q,(unsigned long)2 * sizeof(int));
  {
    int __gen_e_acsl_initialized_28;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_30 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_30,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_30,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_28 = __e_acsl_initialized((void *)q,sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_30,
                                 "\\initialized(q)",0,
                                 __gen_e_acsl_initialized_28);
    __gen_e_acsl_assert_data_30.blocking = 1;
    __gen_e_acsl_assert_data_30.kind = "Assertion";
    __gen_e_acsl_assert_data_30.pred_txt = "\\initialized(q)";
    __gen_e_acsl_assert_data_30.file = "initialized.c";
    __gen_e_acsl_assert_data_30.fct = "main";
    __gen_e_acsl_assert_data_30.line = 74;
    __e_acsl_assert(__gen_e_acsl_initialized_28,
                    & __gen_e_acsl_assert_data_30);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_30);
  }
  /*@ assert \initialized(q); */ ;
  __e_acsl_full_init((void *)(& q));
  q ++;
  {
    int __gen_e_acsl_initialized_29;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_31 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_31,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_31,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_29 = __e_acsl_initialized((void *)q,sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_31,
                                 "\\initialized(q)",0,
                                 __gen_e_acsl_initialized_29);
    __gen_e_acsl_assert_data_31.blocking = 1;
    __gen_e_acsl_assert_data_31.kind = "Assertion";
    __gen_e_acsl_assert_data_31.pred_txt = "!\\initialized(q)";
    __gen_e_acsl_assert_data_31.file = "initialized.c";
    __gen_e_acsl_assert_data_31.fct = "main";
    __gen_e_acsl_assert_data_31.line = 76;
    __e_acsl_assert(! __gen_e_acsl_initialized_29,
                    & __gen_e_acsl_assert_data_31);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_31);
  }
  /*@ assert !\initialized(q); */ ;
  __e_acsl_full_init((void *)(& q));
  q --;
  free((void *)p);
  free((void *)q);
  {
    int __gen_e_acsl_initialized_30;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_32 =
      {.values = (void *)0};
    /*@ assert Eva: dangling_pointer: !\dangling(&p); */
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_32,"p",(void *)p);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_32,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_30 = __e_acsl_initialized((void *)p,sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_32,
                                 "\\initialized(p)",0,
                                 __gen_e_acsl_initialized_30);
    __gen_e_acsl_assert_data_32.blocking = 1;
    __gen_e_acsl_assert_data_32.kind = "Assertion";
    __gen_e_acsl_assert_data_32.pred_txt = "!\\initialized(p)";
    __gen_e_acsl_assert_data_32.file = "initialized.c";
    __gen_e_acsl_assert_data_32.fct = "main";
    __gen_e_acsl_assert_data_32.line = 84;
    __e_acsl_assert(! __gen_e_acsl_initialized_30,
                    & __gen_e_acsl_assert_data_32);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_32);
  }
  /*@ assert !\initialized(p); */ ;
  {
    int __gen_e_acsl_initialized_31;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_33 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_33,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_33,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_31 = __e_acsl_initialized((void *)q,sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_33,
                                 "\\initialized(q)",0,
                                 __gen_e_acsl_initialized_31);
    __gen_e_acsl_assert_data_33.blocking = 1;
    __gen_e_acsl_assert_data_33.kind = "Assertion";
    __gen_e_acsl_assert_data_33.pred_txt = "!\\initialized(q)";
    __gen_e_acsl_assert_data_33.file = "initialized.c";
    __gen_e_acsl_assert_data_33.fct = "main";
    __gen_e_acsl_assert_data_33.line = 85;
    __e_acsl_assert(! __gen_e_acsl_initialized_31,
                    & __gen_e_acsl_assert_data_33);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_33);
  }
  /*@ assert !\initialized(q); */ ;
  __e_acsl_full_init((void *)(& q));
  q = (int *)calloc((size_t)3,sizeof(int));
  {
    int __gen_e_acsl_size;
    int __gen_e_acsl_if;
    int __gen_e_acsl_initialized_32;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_34 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_34,"q",(void *)q);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_34,"sizeof(int)",
                                 0,4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_34,"sizeof(int)",
                                 0,4);
    __gen_e_acsl_size = 4 * ((2 - 0) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_34,"size",0,
                                 __gen_e_acsl_size);
    if (__gen_e_acsl_size <= 0) __gen_e_acsl_if = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_34,"size",0,
                                   __gen_e_acsl_size);
      __gen_e_acsl_if = __gen_e_acsl_size;
    }
    __gen_e_acsl_initialized_32 = __e_acsl_initialized((void *)((char *)q + 
                                                                4 * 0),
                                                       (size_t)__gen_e_acsl_if);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_34,
                                 "\\initialized(q + (0 .. 2))",0,
                                 __gen_e_acsl_initialized_32);
    __gen_e_acsl_assert_data_34.blocking = 1;
    __gen_e_acsl_assert_data_34.kind = "Assertion";
    __gen_e_acsl_assert_data_34.pred_txt = "\\initialized(q + (0 .. 2))";
    __gen_e_acsl_assert_data_34.file = "initialized.c";
    __gen_e_acsl_assert_data_34.fct = "main";
    __gen_e_acsl_assert_data_34.line = 90;
    __e_acsl_assert(__gen_e_acsl_initialized_32,
                    & __gen_e_acsl_assert_data_34);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_34);
  }
  /*@ assert \initialized(q + (0 .. 2)); */ ;
  __e_acsl_full_init((void *)(& q));
  q = (int *)realloc((void *)q,(unsigned long)6 * sizeof(int));
  {
    int __gen_e_acsl_size_2;
    int __gen_e_acsl_if_2;
    int __gen_e_acsl_initialized_33;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_35 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_35,"q",(void *)q);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_35,"sizeof(int)",
                                 0,4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_35,"sizeof(int)",
                                 0,4);
    __gen_e_acsl_size_2 = 4 * ((2 - 0) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_35,"size",0,
                                 __gen_e_acsl_size_2);
    if (__gen_e_acsl_size_2 <= 0) __gen_e_acsl_if_2 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_35,"size",0,
                                   __gen_e_acsl_size_2);
      __gen_e_acsl_if_2 = __gen_e_acsl_size_2;
    }
    __gen_e_acsl_initialized_33 = __e_acsl_initialized((void *)((char *)q + 
                                                                4 * 0),
                                                       (size_t)__gen_e_acsl_if_2);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_35,
                                 "\\initialized(q + (0 .. 2))",0,
                                 __gen_e_acsl_initialized_33);
    __gen_e_acsl_assert_data_35.blocking = 1;
    __gen_e_acsl_assert_data_35.kind = "Assertion";
    __gen_e_acsl_assert_data_35.pred_txt = "\\initialized(q + (0 .. 2))";
    __gen_e_acsl_assert_data_35.file = "initialized.c";
    __gen_e_acsl_assert_data_35.fct = "main";
    __gen_e_acsl_assert_data_35.line = 92;
    __e_acsl_assert(__gen_e_acsl_initialized_33,
                    & __gen_e_acsl_assert_data_35);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_35);
  }
  /*@ assert \initialized(q + (0 .. 2)); */ ;
  {
    int __gen_e_acsl_initialized_34;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_36 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_36,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_36,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_34 = __e_acsl_initialized((void *)(q + 3),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_36,
                                 "\\initialized(q + 3)",0,
                                 __gen_e_acsl_initialized_34);
    __gen_e_acsl_assert_data_36.blocking = 1;
    __gen_e_acsl_assert_data_36.kind = "Assertion";
    __gen_e_acsl_assert_data_36.pred_txt = "!\\initialized(q + 3)";
    __gen_e_acsl_assert_data_36.file = "initialized.c";
    __gen_e_acsl_assert_data_36.fct = "main";
    __gen_e_acsl_assert_data_36.line = 93;
    __e_acsl_assert(! __gen_e_acsl_initialized_34,
                    & __gen_e_acsl_assert_data_36);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_36);
  }
  /*@ assert !\initialized(q + 3); */ ;
  {
    int __gen_e_acsl_initialized_35;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_37 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_37,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_37,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_35 = __e_acsl_initialized((void *)(q + 4),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_37,
                                 "\\initialized(q + 4)",0,
                                 __gen_e_acsl_initialized_35);
    __gen_e_acsl_assert_data_37.blocking = 1;
    __gen_e_acsl_assert_data_37.kind = "Assertion";
    __gen_e_acsl_assert_data_37.pred_txt = "!\\initialized(q + 4)";
    __gen_e_acsl_assert_data_37.file = "initialized.c";
    __gen_e_acsl_assert_data_37.fct = "main";
    __gen_e_acsl_assert_data_37.line = 94;
    __e_acsl_assert(! __gen_e_acsl_initialized_35,
                    & __gen_e_acsl_assert_data_37);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_37);
  }
  /*@ assert !\initialized(q + 4); */ ;
  {
    int __gen_e_acsl_initialized_36;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_38 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_38,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_38,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_36 = __e_acsl_initialized((void *)(q + 5),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_38,
                                 "\\initialized(q + 5)",0,
                                 __gen_e_acsl_initialized_36);
    __gen_e_acsl_assert_data_38.blocking = 1;
    __gen_e_acsl_assert_data_38.kind = "Assertion";
    __gen_e_acsl_assert_data_38.pred_txt = "!\\initialized(q + 5)";
    __gen_e_acsl_assert_data_38.file = "initialized.c";
    __gen_e_acsl_assert_data_38.fct = "main";
    __gen_e_acsl_assert_data_38.line = 95;
    __e_acsl_assert(! __gen_e_acsl_initialized_36,
                    & __gen_e_acsl_assert_data_38);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_38);
  }
  /*@ assert !\initialized(q + 5); */ ;
  free((void *)q);
  __e_acsl_full_init((void *)(& q));
  q = (int *)calloc((size_t)7,sizeof(int));
  {
    int __gen_e_acsl_size_3;
    int __gen_e_acsl_if_3;
    int __gen_e_acsl_initialized_37;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_39 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_39,"q",(void *)q);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_39,"sizeof(int)",
                                 0,4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_39,"sizeof(int)",
                                 0,4);
    __gen_e_acsl_size_3 = 4 * ((6 - 0) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_39,"size",0,
                                 __gen_e_acsl_size_3);
    if (__gen_e_acsl_size_3 <= 0) __gen_e_acsl_if_3 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_39,"size",0,
                                   __gen_e_acsl_size_3);
      __gen_e_acsl_if_3 = __gen_e_acsl_size_3;
    }
    __gen_e_acsl_initialized_37 = __e_acsl_initialized((void *)((char *)q + 
                                                                4 * 0),
                                                       (size_t)__gen_e_acsl_if_3);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_39,
                                 "\\initialized(q + (0 .. 6))",0,
                                 __gen_e_acsl_initialized_37);
    __gen_e_acsl_assert_data_39.blocking = 1;
    __gen_e_acsl_assert_data_39.kind = "Assertion";
    __gen_e_acsl_assert_data_39.pred_txt = "\\initialized(q + (0 .. 6))";
    __gen_e_acsl_assert_data_39.file = "initialized.c";
    __gen_e_acsl_assert_data_39.fct = "main";
    __gen_e_acsl_assert_data_39.line = 98;
    __e_acsl_assert(__gen_e_acsl_initialized_37,
                    & __gen_e_acsl_assert_data_39);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_39);
  }
  /*@ assert \initialized(q + (0 .. 6)); */ ;
  __e_acsl_full_init((void *)(& q));
  q = (int *)realloc((void *)q,(unsigned long)8 * sizeof(int));
  {
    int __gen_e_acsl_size_4;
    int __gen_e_acsl_if_4;
    int __gen_e_acsl_initialized_38;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_40 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_40,"q",(void *)q);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_40,"sizeof(int)",
                                 0,4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_40,"sizeof(int)",
                                 0,4);
    __gen_e_acsl_size_4 = 4 * ((6 - 0) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_40,"size",0,
                                 __gen_e_acsl_size_4);
    if (__gen_e_acsl_size_4 <= 0) __gen_e_acsl_if_4 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_40,"size",0,
                                   __gen_e_acsl_size_4);
      __gen_e_acsl_if_4 = __gen_e_acsl_size_4;
    }
    __gen_e_acsl_initialized_38 = __e_acsl_initialized((void *)((char *)q + 
                                                                4 * 0),
                                                       (size_t)__gen_e_acsl_if_4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_40,
                                 "\\initialized(q + (0 .. 6))",0,
                                 __gen_e_acsl_initialized_38);
    __gen_e_acsl_assert_data_40.blocking = 1;
    __gen_e_acsl_assert_data_40.kind = "Assertion";
    __gen_e_acsl_assert_data_40.pred_txt = "\\initialized(q + (0 .. 6))";
    __gen_e_acsl_assert_data_40.file = "initialized.c";
    __gen_e_acsl_assert_data_40.fct = "main";
    __gen_e_acsl_assert_data_40.line = 100;
    __e_acsl_assert(__gen_e_acsl_initialized_38,
                    & __gen_e_acsl_assert_data_40);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_40);
  }
  /*@ assert \initialized(q + (0 .. 6)); */ ;
  {
    int __gen_e_acsl_initialized_39;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_41 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_41,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_41,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_39 = __e_acsl_initialized((void *)(q + 7),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_41,
                                 "\\initialized(q + 7)",0,
                                 __gen_e_acsl_initialized_39);
    __gen_e_acsl_assert_data_41.blocking = 1;
    __gen_e_acsl_assert_data_41.kind = "Assertion";
    __gen_e_acsl_assert_data_41.pred_txt = "!\\initialized(q + 7)";
    __gen_e_acsl_assert_data_41.file = "initialized.c";
    __gen_e_acsl_assert_data_41.fct = "main";
    __gen_e_acsl_assert_data_41.line = 101;
    __e_acsl_assert(! __gen_e_acsl_initialized_39,
                    & __gen_e_acsl_assert_data_41);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_41);
  }
  /*@ assert !\initialized(q + 7); */ ;
  __e_acsl_full_init((void *)(& q));
  q = (int *)realloc((void *)q,(unsigned long)10 * sizeof(int));
  {
    int __gen_e_acsl_size_5;
    int __gen_e_acsl_if_5;
    int __gen_e_acsl_initialized_40;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_42 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_42,"q",(void *)q);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_42,"sizeof(int)",
                                 0,4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_42,"sizeof(int)",
                                 0,4);
    __gen_e_acsl_size_5 = 4 * ((6 - 0) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_42,"size",0,
                                 __gen_e_acsl_size_5);
    if (__gen_e_acsl_size_5 <= 0) __gen_e_acsl_if_5 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_42,"size",0,
                                   __gen_e_acsl_size_5);
      __gen_e_acsl_if_5 = __gen_e_acsl_size_5;
    }
    __gen_e_acsl_initialized_40 = __e_acsl_initialized((void *)((char *)q + 
                                                                4 * 0),
                                                       (size_t)__gen_e_acsl_if_5);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_42,
                                 "\\initialized(q + (0 .. 6))",0,
                                 __gen_e_acsl_initialized_40);
    __gen_e_acsl_assert_data_42.blocking = 1;
    __gen_e_acsl_assert_data_42.kind = "Assertion";
    __gen_e_acsl_assert_data_42.pred_txt = "\\initialized(q + (0 .. 6))";
    __gen_e_acsl_assert_data_42.file = "initialized.c";
    __gen_e_acsl_assert_data_42.fct = "main";
    __gen_e_acsl_assert_data_42.line = 103;
    __e_acsl_assert(__gen_e_acsl_initialized_40,
                    & __gen_e_acsl_assert_data_42);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_42);
  }
  /*@ assert \initialized(q + (0 .. 6)); */ ;
  {
    int __gen_e_acsl_initialized_41;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_43 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_43,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_43,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_41 = __e_acsl_initialized((void *)(q + 7),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_43,
                                 "\\initialized(q + 7)",0,
                                 __gen_e_acsl_initialized_41);
    __gen_e_acsl_assert_data_43.blocking = 1;
    __gen_e_acsl_assert_data_43.kind = "Assertion";
    __gen_e_acsl_assert_data_43.pred_txt = "!\\initialized(q + 7)";
    __gen_e_acsl_assert_data_43.file = "initialized.c";
    __gen_e_acsl_assert_data_43.fct = "main";
    __gen_e_acsl_assert_data_43.line = 104;
    __e_acsl_assert(! __gen_e_acsl_initialized_41,
                    & __gen_e_acsl_assert_data_43);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_43);
  }
  /*@ assert !\initialized(q + 7); */ ;
  {
    int __gen_e_acsl_initialized_42;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_44 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_44,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_44,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_42 = __e_acsl_initialized((void *)(q + 8),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_44,
                                 "\\initialized(q + 8)",0,
                                 __gen_e_acsl_initialized_42);
    __gen_e_acsl_assert_data_44.blocking = 1;
    __gen_e_acsl_assert_data_44.kind = "Assertion";
    __gen_e_acsl_assert_data_44.pred_txt = "!\\initialized(q + 8)";
    __gen_e_acsl_assert_data_44.file = "initialized.c";
    __gen_e_acsl_assert_data_44.fct = "main";
    __gen_e_acsl_assert_data_44.line = 105;
    __e_acsl_assert(! __gen_e_acsl_initialized_42,
                    & __gen_e_acsl_assert_data_44);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_44);
  }
  /*@ assert !\initialized(q + 8); */ ;
  {
    int __gen_e_acsl_initialized_43;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_45 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_45,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_45,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_43 = __e_acsl_initialized((void *)(q + 9),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_45,
                                 "\\initialized(q + 9)",0,
                                 __gen_e_acsl_initialized_43);
    __gen_e_acsl_assert_data_45.blocking = 1;
    __gen_e_acsl_assert_data_45.kind = "Assertion";
    __gen_e_acsl_assert_data_45.pred_txt = "!\\initialized(q + 9)";
    __gen_e_acsl_assert_data_45.file = "initialized.c";
    __gen_e_acsl_assert_data_45.fct = "main";
    __gen_e_acsl_assert_data_45.line = 106;
    __e_acsl_assert(! __gen_e_acsl_initialized_43,
                    & __gen_e_acsl_assert_data_45);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_45);
  }
  /*@ assert !\initialized(q + 9); */ ;
  free((void *)q);
  __e_acsl_full_init((void *)(& q));
  q = (int *)calloc((size_t)2,sizeof(int));
  {
    int __gen_e_acsl_size_6;
    int __gen_e_acsl_if_6;
    int __gen_e_acsl_initialized_44;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_46 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_46,"q",(void *)q);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_46,"sizeof(int)",
                                 0,4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_46,"sizeof(int)",
                                 0,4);
    __gen_e_acsl_size_6 = 4 * ((1 - 0) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_46,"size",0,
                                 __gen_e_acsl_size_6);
    if (__gen_e_acsl_size_6 <= 0) __gen_e_acsl_if_6 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_46,"size",0,
                                   __gen_e_acsl_size_6);
      __gen_e_acsl_if_6 = __gen_e_acsl_size_6;
    }
    __gen_e_acsl_initialized_44 = __e_acsl_initialized((void *)((char *)q + 
                                                                4 * 0),
                                                       (size_t)__gen_e_acsl_if_6);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_46,
                                 "\\initialized(q + (0 .. 1))",0,
                                 __gen_e_acsl_initialized_44);
    __gen_e_acsl_assert_data_46.blocking = 1;
    __gen_e_acsl_assert_data_46.kind = "Assertion";
    __gen_e_acsl_assert_data_46.pred_txt = "\\initialized(q + (0 .. 1))";
    __gen_e_acsl_assert_data_46.file = "initialized.c";
    __gen_e_acsl_assert_data_46.fct = "main";
    __gen_e_acsl_assert_data_46.line = 109;
    __e_acsl_assert(__gen_e_acsl_initialized_44,
                    & __gen_e_acsl_assert_data_46);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_46);
  }
  /*@ assert \initialized(q + (0 .. 1)); */ ;
  __e_acsl_full_init((void *)(& q));
  q = (int *)realloc((void *)q,(unsigned long)4 * sizeof(int));
  {
    int __gen_e_acsl_size_7;
    int __gen_e_acsl_if_7;
    int __gen_e_acsl_initialized_45;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_47 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_47,"q",(void *)q);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_47,"sizeof(int)",
                                 0,4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_47,"sizeof(int)",
                                 0,4);
    __gen_e_acsl_size_7 = 4 * ((1 - 0) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_47,"size",0,
                                 __gen_e_acsl_size_7);
    if (__gen_e_acsl_size_7 <= 0) __gen_e_acsl_if_7 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_47,"size",0,
                                   __gen_e_acsl_size_7);
      __gen_e_acsl_if_7 = __gen_e_acsl_size_7;
    }
    __gen_e_acsl_initialized_45 = __e_acsl_initialized((void *)((char *)q + 
                                                                4 * 0),
                                                       (size_t)__gen_e_acsl_if_7);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_47,
                                 "\\initialized(q + (0 .. 1))",0,
                                 __gen_e_acsl_initialized_45);
    __gen_e_acsl_assert_data_47.blocking = 1;
    __gen_e_acsl_assert_data_47.kind = "Assertion";
    __gen_e_acsl_assert_data_47.pred_txt = "\\initialized(q + (0 .. 1))";
    __gen_e_acsl_assert_data_47.file = "initialized.c";
    __gen_e_acsl_assert_data_47.fct = "main";
    __gen_e_acsl_assert_data_47.line = 111;
    __e_acsl_assert(__gen_e_acsl_initialized_45,
                    & __gen_e_acsl_assert_data_47);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_47);
  }
  /*@ assert \initialized(q + (0 .. 1)); */ ;
  {
    int __gen_e_acsl_initialized_46;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_48 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_48,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_48,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_46 = __e_acsl_initialized((void *)(q + 2),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_48,
                                 "\\initialized(q + 2)",0,
                                 __gen_e_acsl_initialized_46);
    __gen_e_acsl_assert_data_48.blocking = 1;
    __gen_e_acsl_assert_data_48.kind = "Assertion";
    __gen_e_acsl_assert_data_48.pred_txt = "!\\initialized(q + 2)";
    __gen_e_acsl_assert_data_48.file = "initialized.c";
    __gen_e_acsl_assert_data_48.fct = "main";
    __gen_e_acsl_assert_data_48.line = 112;
    __e_acsl_assert(! __gen_e_acsl_initialized_46,
                    & __gen_e_acsl_assert_data_48);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_48);
  }
  /*@ assert !\initialized(q + 2); */ ;
  {
    int __gen_e_acsl_initialized_47;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_49 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_49,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_49,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_47 = __e_acsl_initialized((void *)(q + 3),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_49,
                                 "\\initialized(q + 3)",0,
                                 __gen_e_acsl_initialized_47);
    __gen_e_acsl_assert_data_49.blocking = 1;
    __gen_e_acsl_assert_data_49.kind = "Assertion";
    __gen_e_acsl_assert_data_49.pred_txt = "!\\initialized(q + 3)";
    __gen_e_acsl_assert_data_49.file = "initialized.c";
    __gen_e_acsl_assert_data_49.fct = "main";
    __gen_e_acsl_assert_data_49.line = 113;
    __e_acsl_assert(! __gen_e_acsl_initialized_47,
                    & __gen_e_acsl_assert_data_49);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_49);
  }
  /*@ assert !\initialized(q + 3); */ ;
  free((void *)q);
  __e_acsl_full_init((void *)(& q));
  q = (int *)calloc((size_t)6,sizeof(int));
  {
    int __gen_e_acsl_size_8;
    int __gen_e_acsl_if_8;
    int __gen_e_acsl_initialized_48;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_50 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_50,"q",(void *)q);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_50,"sizeof(int)",
                                 0,4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_50,"sizeof(int)",
                                 0,4);
    __gen_e_acsl_size_8 = 4 * ((5 - 0) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_50,"size",0,
                                 __gen_e_acsl_size_8);
    if (__gen_e_acsl_size_8 <= 0) __gen_e_acsl_if_8 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_50,"size",0,
                                   __gen_e_acsl_size_8);
      __gen_e_acsl_if_8 = __gen_e_acsl_size_8;
    }
    __gen_e_acsl_initialized_48 = __e_acsl_initialized((void *)((char *)q + 
                                                                4 * 0),
                                                       (size_t)__gen_e_acsl_if_8);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_50,
                                 "\\initialized(q + (0 .. 5))",0,
                                 __gen_e_acsl_initialized_48);
    __gen_e_acsl_assert_data_50.blocking = 1;
    __gen_e_acsl_assert_data_50.kind = "Assertion";
    __gen_e_acsl_assert_data_50.pred_txt = "\\initialized(q + (0 .. 5))";
    __gen_e_acsl_assert_data_50.file = "initialized.c";
    __gen_e_acsl_assert_data_50.fct = "main";
    __gen_e_acsl_assert_data_50.line = 116;
    __e_acsl_assert(__gen_e_acsl_initialized_48,
                    & __gen_e_acsl_assert_data_50);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_50);
  }
  /*@ assert \initialized(q + (0 .. 5)); */ ;
  __e_acsl_full_init((void *)(& q));
  q = (int *)realloc((void *)q,(unsigned long)3 * sizeof(int));
  {
    int __gen_e_acsl_size_9;
    int __gen_e_acsl_if_9;
    int __gen_e_acsl_initialized_49;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_51 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_51,"q",(void *)q);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_51,"sizeof(int)",
                                 0,4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_51,"sizeof(int)",
                                 0,4);
    __gen_e_acsl_size_9 = 4 * ((2 - 0) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_51,"size",0,
                                 __gen_e_acsl_size_9);
    if (__gen_e_acsl_size_9 <= 0) __gen_e_acsl_if_9 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_51,"size",0,
                                   __gen_e_acsl_size_9);
      __gen_e_acsl_if_9 = __gen_e_acsl_size_9;
    }
    __gen_e_acsl_initialized_49 = __e_acsl_initialized((void *)((char *)q + 
                                                                4 * 0),
                                                       (size_t)__gen_e_acsl_if_9);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_51,
                                 "\\initialized(q + (0 .. 2))",0,
                                 __gen_e_acsl_initialized_49);
    __gen_e_acsl_assert_data_51.blocking = 1;
    __gen_e_acsl_assert_data_51.kind = "Assertion";
    __gen_e_acsl_assert_data_51.pred_txt = "\\initialized(q + (0 .. 2))";
    __gen_e_acsl_assert_data_51.file = "initialized.c";
    __gen_e_acsl_assert_data_51.fct = "main";
    __gen_e_acsl_assert_data_51.line = 118;
    __e_acsl_assert(__gen_e_acsl_initialized_49,
                    & __gen_e_acsl_assert_data_51);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_51);
  }
  /*@ assert \initialized(q + (0 .. 2)); */ ;
  free((void *)q);
  __e_acsl_full_init((void *)(& q));
  q = (int *)malloc((unsigned long)6 * sizeof(int));
  {
    int __gen_e_acsl_initialized_50;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_52 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_52,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_52,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_50 = __e_acsl_initialized((void *)(q + 0),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_52,
                                 "\\initialized(q + 0)",0,
                                 __gen_e_acsl_initialized_50);
    __gen_e_acsl_assert_data_52.blocking = 1;
    __gen_e_acsl_assert_data_52.kind = "Assertion";
    __gen_e_acsl_assert_data_52.pred_txt = "!\\initialized(q + 0)";
    __gen_e_acsl_assert_data_52.file = "initialized.c";
    __gen_e_acsl_assert_data_52.fct = "main";
    __gen_e_acsl_assert_data_52.line = 121;
    __e_acsl_assert(! __gen_e_acsl_initialized_50,
                    & __gen_e_acsl_assert_data_52);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_52);
  }
  /*@ assert !\initialized(q + 0); */ ;
  {
    int __gen_e_acsl_initialized_51;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_53 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_53,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_53,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_51 = __e_acsl_initialized((void *)(q + 1),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_53,
                                 "\\initialized(q + 1)",0,
                                 __gen_e_acsl_initialized_51);
    __gen_e_acsl_assert_data_53.blocking = 1;
    __gen_e_acsl_assert_data_53.kind = "Assertion";
    __gen_e_acsl_assert_data_53.pred_txt = "!\\initialized(q + 1)";
    __gen_e_acsl_assert_data_53.file = "initialized.c";
    __gen_e_acsl_assert_data_53.fct = "main";
    __gen_e_acsl_assert_data_53.line = 122;
    __e_acsl_assert(! __gen_e_acsl_initialized_51,
                    & __gen_e_acsl_assert_data_53);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_53);
  }
  /*@ assert !\initialized(q + 1); */ ;
  {
    int __gen_e_acsl_initialized_52;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_54 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_54,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_54,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_52 = __e_acsl_initialized((void *)(q + 2),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_54,
                                 "\\initialized(q + 2)",0,
                                 __gen_e_acsl_initialized_52);
    __gen_e_acsl_assert_data_54.blocking = 1;
    __gen_e_acsl_assert_data_54.kind = "Assertion";
    __gen_e_acsl_assert_data_54.pred_txt = "!\\initialized(q + 2)";
    __gen_e_acsl_assert_data_54.file = "initialized.c";
    __gen_e_acsl_assert_data_54.fct = "main";
    __gen_e_acsl_assert_data_54.line = 123;
    __e_acsl_assert(! __gen_e_acsl_initialized_52,
                    & __gen_e_acsl_assert_data_54);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_54);
  }
  /*@ assert !\initialized(q + 2); */ ;
  {
    int __gen_e_acsl_initialized_53;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_55 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_55,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_55,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_53 = __e_acsl_initialized((void *)(q + 3),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_55,
                                 "\\initialized(q + 3)",0,
                                 __gen_e_acsl_initialized_53);
    __gen_e_acsl_assert_data_55.blocking = 1;
    __gen_e_acsl_assert_data_55.kind = "Assertion";
    __gen_e_acsl_assert_data_55.pred_txt = "!\\initialized(q + 3)";
    __gen_e_acsl_assert_data_55.file = "initialized.c";
    __gen_e_acsl_assert_data_55.fct = "main";
    __gen_e_acsl_assert_data_55.line = 124;
    __e_acsl_assert(! __gen_e_acsl_initialized_53,
                    & __gen_e_acsl_assert_data_55);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_55);
  }
  /*@ assert !\initialized(q + 3); */ ;
  {
    int __gen_e_acsl_initialized_54;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_56 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_56,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_56,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_54 = __e_acsl_initialized((void *)(q + 4),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_56,
                                 "\\initialized(q + 4)",0,
                                 __gen_e_acsl_initialized_54);
    __gen_e_acsl_assert_data_56.blocking = 1;
    __gen_e_acsl_assert_data_56.kind = "Assertion";
    __gen_e_acsl_assert_data_56.pred_txt = "!\\initialized(q + 4)";
    __gen_e_acsl_assert_data_56.file = "initialized.c";
    __gen_e_acsl_assert_data_56.fct = "main";
    __gen_e_acsl_assert_data_56.line = 125;
    __e_acsl_assert(! __gen_e_acsl_initialized_54,
                    & __gen_e_acsl_assert_data_56);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_56);
  }
  /*@ assert !\initialized(q + 4); */ ;
  {
    int __gen_e_acsl_initialized_55;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_57 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_57,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_57,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_55 = __e_acsl_initialized((void *)(q + 5),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_57,
                                 "\\initialized(q + 5)",0,
                                 __gen_e_acsl_initialized_55);
    __gen_e_acsl_assert_data_57.blocking = 1;
    __gen_e_acsl_assert_data_57.kind = "Assertion";
    __gen_e_acsl_assert_data_57.pred_txt = "!\\initialized(q + 5)";
    __gen_e_acsl_assert_data_57.file = "initialized.c";
    __gen_e_acsl_assert_data_57.fct = "main";
    __gen_e_acsl_assert_data_57.line = 126;
    __e_acsl_assert(! __gen_e_acsl_initialized_55,
                    & __gen_e_acsl_assert_data_57);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_57);
  }
  /*@ assert !\initialized(q + 5); */ ;
  __e_acsl_full_init((void *)(& q));
  q = (int *)realloc((void *)q,(unsigned long)3 * sizeof(int));
  {
    int __gen_e_acsl_initialized_56;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_58 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_58,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_58,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_56 = __e_acsl_initialized((void *)(q + 0),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_58,
                                 "\\initialized(q + 0)",0,
                                 __gen_e_acsl_initialized_56);
    __gen_e_acsl_assert_data_58.blocking = 1;
    __gen_e_acsl_assert_data_58.kind = "Assertion";
    __gen_e_acsl_assert_data_58.pred_txt = "!\\initialized(q + 0)";
    __gen_e_acsl_assert_data_58.file = "initialized.c";
    __gen_e_acsl_assert_data_58.fct = "main";
    __gen_e_acsl_assert_data_58.line = 128;
    __e_acsl_assert(! __gen_e_acsl_initialized_56,
                    & __gen_e_acsl_assert_data_58);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_58);
  }
  /*@ assert !\initialized(q + 0); */ ;
  {
    int __gen_e_acsl_initialized_57;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_59 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_59,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_59,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_57 = __e_acsl_initialized((void *)(q + 1),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_59,
                                 "\\initialized(q + 1)",0,
                                 __gen_e_acsl_initialized_57);
    __gen_e_acsl_assert_data_59.blocking = 1;
    __gen_e_acsl_assert_data_59.kind = "Assertion";
    __gen_e_acsl_assert_data_59.pred_txt = "!\\initialized(q + 1)";
    __gen_e_acsl_assert_data_59.file = "initialized.c";
    __gen_e_acsl_assert_data_59.fct = "main";
    __gen_e_acsl_assert_data_59.line = 129;
    __e_acsl_assert(! __gen_e_acsl_initialized_57,
                    & __gen_e_acsl_assert_data_59);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_59);
  }
  /*@ assert !\initialized(q + 1); */ ;
  {
    int __gen_e_acsl_initialized_58;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_60 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_60,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_60,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_58 = __e_acsl_initialized((void *)(q + 2),
                                                       sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_60,
                                 "\\initialized(q + 2)",0,
                                 __gen_e_acsl_initialized_58);
    __gen_e_acsl_assert_data_60.blocking = 1;
    __gen_e_acsl_assert_data_60.kind = "Assertion";
    __gen_e_acsl_assert_data_60.pred_txt = "!\\initialized(q + 2)";
    __gen_e_acsl_assert_data_60.file = "initialized.c";
    __gen_e_acsl_assert_data_60.fct = "main";
    __gen_e_acsl_assert_data_60.line = 130;
    __e_acsl_assert(! __gen_e_acsl_initialized_58,
                    & __gen_e_acsl_assert_data_60);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_60);
  }
  /*@ assert !\initialized(q + 2); */ ;
  free((void *)q);
  __e_acsl_full_init((void *)(& q));
  q = (int *)(& q - 1024 * 5);
  __e_acsl_full_init((void *)(& q));
  q = (int *)128;
  {
    int __gen_e_acsl_initialized_59;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_61 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_61,"q",(void *)q);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_61,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_59 = __e_acsl_initialized((void *)q,sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_61,
                                 "\\initialized(q)",0,
                                 __gen_e_acsl_initialized_59);
    __gen_e_acsl_assert_data_61.blocking = 1;
    __gen_e_acsl_assert_data_61.kind = "Assertion";
    __gen_e_acsl_assert_data_61.pred_txt = "!\\initialized(q)";
    __gen_e_acsl_assert_data_61.file = "initialized.c";
    __gen_e_acsl_assert_data_61.fct = "main";
    __gen_e_acsl_assert_data_61.line = 139;
    __e_acsl_assert(! __gen_e_acsl_initialized_59,
                    & __gen_e_acsl_assert_data_61);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_61);
  }
  /*@ assert !\initialized(q); */ ;
  __e_acsl_full_init((void *)(& p));
  p = (int *)0;
  {
    int __gen_e_acsl_initialized_60;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_62 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_62,"p",(void *)p);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_62,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_initialized_60 = __e_acsl_initialized((void *)p,sizeof(int));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_62,
                                 "\\initialized(p)",0,
                                 __gen_e_acsl_initialized_60);
    __gen_e_acsl_assert_data_62.blocking = 1;
    __gen_e_acsl_assert_data_62.kind = "Assertion";
    __gen_e_acsl_assert_data_62.pred_txt = "!\\initialized(p)";
    __gen_e_acsl_assert_data_62.file = "initialized.c";
    __gen_e_acsl_assert_data_62.fct = "main";
    __gen_e_acsl_assert_data_62.line = 142;
    __e_acsl_assert(! __gen_e_acsl_initialized_60,
                    & __gen_e_acsl_assert_data_62);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_62);
  }
  /*@ assert !\initialized(p); */ ;
  int size = 100;
  char *partsc = malloc((unsigned long)size * sizeof(char));
  char *partsi = malloc((unsigned long)size * sizeof(int));
  {
    int i = 0;
    while (i < size) {
      if (i % 2 != 0) *(partsc + i) = (char)'0';
      else *(partsi + i) = (char)0;
      i ++;
    }
  }
  {
    int i_0 = 0;
    while (i_0 < size) {
      if (i_0 % 2 != 0) ;
      i_0 ++;
    }
  }
  dup[0] = 1;
  dup[0] = 1;
  __retres = 0;
  __e_acsl_delete_block((void *)(d));
  __e_acsl_delete_block((void *)(c));
  __e_acsl_delete_block((void *)(& r));
  __e_acsl_delete_block((void *)(& b));
  __e_acsl_delete_block((void *)(& a));
  __e_acsl_delete_block((void *)(& q));
  __e_acsl_delete_block((void *)(& p));
  __e_acsl_globals_clean();
  __e_acsl_memory_clean();
  return __retres;
}


