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

int T1[3];
int T2[4];
void arrays(void)
{
  int a[3] = {1, 2, 3};
  int b[3] = {4, 5, 6};
  __e_acsl_store_block((void *)(b),12UL);
  __e_acsl_full_init((void *)(& b));
  int c[3] = {1, 2, 3};
  __e_acsl_store_block((void *)(c),12UL);
  __e_acsl_full_init((void *)(& c));
  int d[6] = {1, 2, 3, 4, 5, 6};
  {
    int __gen_e_acsl_ne;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data,"a",
                                   (void *)(a));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data,"b",
                                   (void *)(b));
    __gen_e_acsl_ne = 0;
    if (1) {
      unsigned long __gen_e_acsl_iter;
      __gen_e_acsl_iter = 0;
      while (__gen_e_acsl_iter < 3) {
        if (a[__gen_e_acsl_iter] != b[__gen_e_acsl_iter]) {
          __gen_e_acsl_ne = 1;
          break;
        }
        __gen_e_acsl_iter ++;
      }
    }
    else __gen_e_acsl_ne = 1;
    __gen_e_acsl_assert_data.blocking = 1;
    __gen_e_acsl_assert_data.kind = "Assertion";
    __gen_e_acsl_assert_data.pred_txt = "a != b";
    __gen_e_acsl_assert_data.file = "array.i";
    __gen_e_acsl_assert_data.fct = "arrays";
    __gen_e_acsl_assert_data.line = 21;
    __e_acsl_assert(__gen_e_acsl_ne,& __gen_e_acsl_assert_data);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
  }
  /*@ assert a != b; */ ;
  {
    int __gen_e_acsl_eq;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
      {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_2,"a",
                                   (void *)(a));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_2,"c",
                                   (void *)(c));
    __gen_e_acsl_eq = 1;
    if (1) {
      unsigned long __gen_e_acsl_iter_2;
      __gen_e_acsl_iter_2 = 0;
      while (__gen_e_acsl_iter_2 < 3) {
        if (a[__gen_e_acsl_iter_2] != c[__gen_e_acsl_iter_2]) {
          __gen_e_acsl_eq = 0;
          break;
        }
        __gen_e_acsl_iter_2 ++;
      }
    }
    else __gen_e_acsl_eq = 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 = "a == c";
    __gen_e_acsl_assert_data_2.file = "array.i";
    __gen_e_acsl_assert_data_2.fct = "arrays";
    __gen_e_acsl_assert_data_2.line = 22;
    __e_acsl_assert(__gen_e_acsl_eq,& __gen_e_acsl_assert_data_2);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
  }
  /*@ assert a == c; */ ;
  {
    int __gen_e_acsl_ne_2;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
      {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_3,"a",
                                   (void *)(a));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_3,"d",
                                   (void *)(d));
    __gen_e_acsl_ne_2 = 0;
    if (0) {
      unsigned long __gen_e_acsl_iter_3;
      __gen_e_acsl_iter_3 = 0;
      while (__gen_e_acsl_iter_3 < 3) {
        if (a[__gen_e_acsl_iter_3] != d[__gen_e_acsl_iter_3]) {
          __gen_e_acsl_ne_2 = 1;
          break;
        }
        __gen_e_acsl_iter_3 ++;
      }
    }
    else __gen_e_acsl_ne_2 = 1;
    __gen_e_acsl_assert_data_3.blocking = 1;
    __gen_e_acsl_assert_data_3.kind = "Assertion";
    __gen_e_acsl_assert_data_3.pred_txt = "a != d";
    __gen_e_acsl_assert_data_3.file = "array.i";
    __gen_e_acsl_assert_data_3.fct = "arrays";
    __gen_e_acsl_assert_data_3.line = 23;
    __e_acsl_assert(__gen_e_acsl_ne_2,& __gen_e_acsl_assert_data_3);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
  }
  /*@ assert a != d; */ ;
  int *e = a;
  int *f = b;
  __e_acsl_store_block((void *)(& f),8UL);
  __e_acsl_full_init((void *)(& f));
  int *g = c;
  __e_acsl_store_block((void *)(& g),8UL);
  __e_acsl_full_init((void *)(& g));
  int *h = a;
  {
    __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,"e",(void *)e);
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_4,"f",(void *)f);
    __gen_e_acsl_assert_data_4.blocking = 1;
    __gen_e_acsl_assert_data_4.kind = "Assertion";
    __gen_e_acsl_assert_data_4.pred_txt = "e != f";
    __gen_e_acsl_assert_data_4.file = "array.i";
    __gen_e_acsl_assert_data_4.fct = "arrays";
    __gen_e_acsl_assert_data_4.line = 30;
    __e_acsl_assert(e != f,& __gen_e_acsl_assert_data_4);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
  }
  /*@ assert e != f; */ ;
  {
    __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,"e",(void *)e);
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_5,"g",(void *)g);
    __gen_e_acsl_assert_data_5.blocking = 1;
    __gen_e_acsl_assert_data_5.kind = "Assertion";
    __gen_e_acsl_assert_data_5.pred_txt = "e != g";
    __gen_e_acsl_assert_data_5.file = "array.i";
    __gen_e_acsl_assert_data_5.fct = "arrays";
    __gen_e_acsl_assert_data_5.line = 31;
    __e_acsl_assert(e != g,& __gen_e_acsl_assert_data_5);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_5);
  }
  /*@ assert e != g; */ ;
  {
    __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,"e",(void *)e);
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_6,"h",(void *)h);
    __gen_e_acsl_assert_data_6.blocking = 1;
    __gen_e_acsl_assert_data_6.kind = "Assertion";
    __gen_e_acsl_assert_data_6.pred_txt = "e == h";
    __gen_e_acsl_assert_data_6.file = "array.i";
    __gen_e_acsl_assert_data_6.fct = "arrays";
    __gen_e_acsl_assert_data_6.line = 32;
    __e_acsl_assert(e == h,& __gen_e_acsl_assert_data_6);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_6);
  }
  /*@ assert e == h; */ ;
  {
    __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,"e",(void *)e);
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_7,"(int *)a",
                                 (void *)(a));
    __gen_e_acsl_assert_data_7.blocking = 1;
    __gen_e_acsl_assert_data_7.kind = "Assertion";
    __gen_e_acsl_assert_data_7.pred_txt = "e == (int *)a";
    __gen_e_acsl_assert_data_7.file = "array.i";
    __gen_e_acsl_assert_data_7.fct = "arrays";
    __gen_e_acsl_assert_data_7.line = 36;
    __e_acsl_assert(e == a,& __gen_e_acsl_assert_data_7);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_7);
  }
  /*@ assert e == (int *)a; */ ;
  {
    __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,"e",(void *)e);
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_8,"(int *)c",
                                 (void *)(c));
    __gen_e_acsl_assert_data_8.blocking = 1;
    __gen_e_acsl_assert_data_8.kind = "Assertion";
    __gen_e_acsl_assert_data_8.pred_txt = "e != (int *)c";
    __gen_e_acsl_assert_data_8.file = "array.i";
    __gen_e_acsl_assert_data_8.fct = "arrays";
    __gen_e_acsl_assert_data_8.line = 37;
    __e_acsl_assert(e != c,& __gen_e_acsl_assert_data_8);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_8);
  }
  /*@ assert e != (int *)c; */ ;
  {
    int __gen_e_acsl_eq_2;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_9 =
      {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_9,"a",
                                   (void *)(a));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_9,
                                   "*((int (*)[3])g)",
                                   (void *)(*((int (*)[3])g)));
    __gen_e_acsl_eq_2 = 1;
    if (1) {
      unsigned long __gen_e_acsl_iter_4;
      __gen_e_acsl_iter_4 = 0;
      while (__gen_e_acsl_iter_4 < 3) {
        {
          int __gen_e_acsl_valid_read;
          __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,
                                       "&(*((int (*)[3])g))[__gen_e_acsl_iter_4]",
                                       (void *)(& (*((int (*)[3])g))[__gen_e_acsl_iter_4]));
          __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_10,
                                         "sizeof(int)",0,sizeof(int));
          __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(& (*((int (*)[3])g))[__gen_e_acsl_iter_4]),
                                                        sizeof(int),
                                                        (void *)(*((int (*)[3])g)),
                                                        (void *)0);
          __gen_e_acsl_assert_data_10.blocking = 1;
          __gen_e_acsl_assert_data_10.kind = "RTE";
          __gen_e_acsl_assert_data_10.pred_txt = "\\valid_read(&(*((int (*)[3])g))[__gen_e_acsl_iter_4])";
          __gen_e_acsl_assert_data_10.file = "array.i";
          __gen_e_acsl_assert_data_10.fct = "arrays";
          __gen_e_acsl_assert_data_10.line = 40;
          __gen_e_acsl_assert_data_10.name = "mem_access";
          __e_acsl_assert(__gen_e_acsl_valid_read,
                          & __gen_e_acsl_assert_data_10);
          __e_acsl_assert_clean(& __gen_e_acsl_assert_data_10);
          if (a[__gen_e_acsl_iter_4] != (*((int (*)[3])g))[__gen_e_acsl_iter_4]) {
            __gen_e_acsl_eq_2 = 0;
            break;
          }
        }
        __gen_e_acsl_iter_4 ++;
      }
    }
    else __gen_e_acsl_eq_2 = 0;
    __gen_e_acsl_assert_data_9.blocking = 1;
    __gen_e_acsl_assert_data_9.kind = "Assertion";
    __gen_e_acsl_assert_data_9.pred_txt = "a == *((int (*)[3])g)";
    __gen_e_acsl_assert_data_9.file = "array.i";
    __gen_e_acsl_assert_data_9.fct = "arrays";
    __gen_e_acsl_assert_data_9.line = 40;
    __e_acsl_assert(__gen_e_acsl_eq_2,& __gen_e_acsl_assert_data_9);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_9);
  }
  /*@ assert a == *((int (*)[3])g); */ ;
  {
    int __gen_e_acsl_eq_3;
    int __gen_e_acsl_valid_read_2;
    unsigned long __gen_e_acsl_;
    unsigned long __gen_e_acsl__2;
    unsigned long __gen_e_acsl_length2;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_11 =
      {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_11,"a",
                                   (void *)(a));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_11,
                                   "*((int (*)[])g)",
                                   (void *)(*((int (*)[])g)));
    __gen_e_acsl_eq_3 = 1;
    __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,
                                 "(int *)*((int (*)[])g)",
                                 (void *)(*((int (*)[])g)));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_12,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(*((int (*)[])g)),
                                                    sizeof(int),
                                                    (void *)(*((int (*)[])g)),
                                                    (void *)0);
    __gen_e_acsl_assert_data_12.blocking = 1;
    __gen_e_acsl_assert_data_12.kind = "RTE";
    __gen_e_acsl_assert_data_12.pred_txt = "\\valid_read((int *)*((int (*)[])g))";
    __gen_e_acsl_assert_data_12.file = "array.i";
    __gen_e_acsl_assert_data_12.fct = "arrays";
    __gen_e_acsl_assert_data_12.line = 41;
    __gen_e_acsl_assert_data_12.name = "mem_access";
    __e_acsl_assert(__gen_e_acsl_valid_read_2,& __gen_e_acsl_assert_data_12);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_12);
    __gen_e_acsl_ = __e_acsl_block_length((void *)(*((int (*)[])g)));
    __gen_e_acsl__2 = __e_acsl_offset((void *)(*((int (*)[])g)));
    __gen_e_acsl_length2 = (__gen_e_acsl_ - __gen_e_acsl__2) / sizeof(int);
    if (3UL == __gen_e_acsl_length2) {
      unsigned long __gen_e_acsl_iter_5;
      __gen_e_acsl_iter_5 = 0;
      while (__gen_e_acsl_iter_5 < 3) {
        {
          int __gen_e_acsl_valid_read_3;
          __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,
                                       "&(*((int (*)[])g))[__gen_e_acsl_iter_5]",
                                       (void *)(& (*((int (*)[])g))[__gen_e_acsl_iter_5]));
          __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_13,
                                         "sizeof(int)",0,sizeof(int));
          __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(& (*((int (*)[])g))[__gen_e_acsl_iter_5]),
                                                          sizeof(int),
                                                          (void *)(*((int (*)[])g)),
                                                          (void *)0);
          __gen_e_acsl_assert_data_13.blocking = 1;
          __gen_e_acsl_assert_data_13.kind = "RTE";
          __gen_e_acsl_assert_data_13.pred_txt = "\\valid_read(&(*((int (*)[])g))[__gen_e_acsl_iter_5])";
          __gen_e_acsl_assert_data_13.file = "array.i";
          __gen_e_acsl_assert_data_13.fct = "arrays";
          __gen_e_acsl_assert_data_13.line = 41;
          __gen_e_acsl_assert_data_13.name = "mem_access";
          __e_acsl_assert(__gen_e_acsl_valid_read_3,
                          & __gen_e_acsl_assert_data_13);
          __e_acsl_assert_clean(& __gen_e_acsl_assert_data_13);
          if (a[__gen_e_acsl_iter_5] != (*((int (*)[])g))[__gen_e_acsl_iter_5]) {
            __gen_e_acsl_eq_3 = 0;
            break;
          }
        }
        __gen_e_acsl_iter_5 ++;
      }
    }
    else __gen_e_acsl_eq_3 = 0;
    __gen_e_acsl_assert_data_11.blocking = 1;
    __gen_e_acsl_assert_data_11.kind = "Assertion";
    __gen_e_acsl_assert_data_11.pred_txt = "a == *((int (*)[])g)";
    __gen_e_acsl_assert_data_11.file = "array.i";
    __gen_e_acsl_assert_data_11.fct = "arrays";
    __gen_e_acsl_assert_data_11.line = 41;
    __e_acsl_assert(__gen_e_acsl_eq_3,& __gen_e_acsl_assert_data_11);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_11);
  }
  /*@ assert a == *((int (*)[])g); */ ;
  {
    int __gen_e_acsl_ne_3;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_14 =
      {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_14,"a",
                                   (void *)(a));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_14,
                                   "*((int (*)[3])f)",
                                   (void *)(*((int (*)[3])f)));
    __gen_e_acsl_ne_3 = 0;
    if (1) {
      unsigned long __gen_e_acsl_iter_6;
      __gen_e_acsl_iter_6 = 0;
      while (__gen_e_acsl_iter_6 < 3) {
        {
          int __gen_e_acsl_valid_read_4;
          __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,
                                       "&(*((int (*)[3])f))[__gen_e_acsl_iter_6]",
                                       (void *)(& (*((int (*)[3])f))[__gen_e_acsl_iter_6]));
          __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_15,
                                         "sizeof(int)",0,sizeof(int));
          __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(& (*((int (*)[3])f))[__gen_e_acsl_iter_6]),
                                                          sizeof(int),
                                                          (void *)(*((int (*)[3])f)),
                                                          (void *)0);
          __gen_e_acsl_assert_data_15.blocking = 1;
          __gen_e_acsl_assert_data_15.kind = "RTE";
          __gen_e_acsl_assert_data_15.pred_txt = "\\valid_read(&(*((int (*)[3])f))[__gen_e_acsl_iter_6])";
          __gen_e_acsl_assert_data_15.file = "array.i";
          __gen_e_acsl_assert_data_15.fct = "arrays";
          __gen_e_acsl_assert_data_15.line = 42;
          __gen_e_acsl_assert_data_15.name = "mem_access";
          __e_acsl_assert(__gen_e_acsl_valid_read_4,
                          & __gen_e_acsl_assert_data_15);
          __e_acsl_assert_clean(& __gen_e_acsl_assert_data_15);
          if (a[__gen_e_acsl_iter_6] != (*((int (*)[3])f))[__gen_e_acsl_iter_6]) {
            __gen_e_acsl_ne_3 = 1;
            break;
          }
        }
        __gen_e_acsl_iter_6 ++;
      }
    }
    else __gen_e_acsl_ne_3 = 1;
    __gen_e_acsl_assert_data_14.blocking = 1;
    __gen_e_acsl_assert_data_14.kind = "Assertion";
    __gen_e_acsl_assert_data_14.pred_txt = "a != *((int (*)[3])f)";
    __gen_e_acsl_assert_data_14.file = "array.i";
    __gen_e_acsl_assert_data_14.fct = "arrays";
    __gen_e_acsl_assert_data_14.line = 42;
    __e_acsl_assert(__gen_e_acsl_ne_3,& __gen_e_acsl_assert_data_14);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_14);
  }
  /*@ assert a != *((int (*)[3])f); */ ;
  {
    int __gen_e_acsl_ne_4;
    int __gen_e_acsl_valid_read_5;
    unsigned long __gen_e_acsl__3;
    unsigned long __gen_e_acsl__4;
    unsigned long __gen_e_acsl_length2_2;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_16 =
      {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_16,"a",
                                   (void *)(a));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_16,
                                   "*((int (*)[])f)",
                                   (void *)(*((int (*)[])f)));
    __gen_e_acsl_ne_4 = 0;
    __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,
                                 "(int *)*((int (*)[])f)",
                                 (void *)(*((int (*)[])f)));
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_17,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)(*((int (*)[])f)),
                                                    sizeof(int),
                                                    (void *)(*((int (*)[])f)),
                                                    (void *)0);
    __gen_e_acsl_assert_data_17.blocking = 1;
    __gen_e_acsl_assert_data_17.kind = "RTE";
    __gen_e_acsl_assert_data_17.pred_txt = "\\valid_read((int *)*((int (*)[])f))";
    __gen_e_acsl_assert_data_17.file = "array.i";
    __gen_e_acsl_assert_data_17.fct = "arrays";
    __gen_e_acsl_assert_data_17.line = 43;
    __gen_e_acsl_assert_data_17.name = "mem_access";
    __e_acsl_assert(__gen_e_acsl_valid_read_5,& __gen_e_acsl_assert_data_17);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_17);
    __gen_e_acsl__3 = __e_acsl_block_length((void *)(*((int (*)[])f)));
    __gen_e_acsl__4 = __e_acsl_offset((void *)(*((int (*)[])f)));
    __gen_e_acsl_length2_2 = (__gen_e_acsl__3 - __gen_e_acsl__4) / sizeof(int);
    if (3UL == __gen_e_acsl_length2_2) {
      unsigned long __gen_e_acsl_iter_7;
      __gen_e_acsl_iter_7 = 0;
      while (__gen_e_acsl_iter_7 < 3) {
        {
          int __gen_e_acsl_valid_read_6;
          __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,
                                       "&(*((int (*)[])f))[__gen_e_acsl_iter_7]",
                                       (void *)(& (*((int (*)[])f))[__gen_e_acsl_iter_7]));
          __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_18,
                                         "sizeof(int)",0,sizeof(int));
          __gen_e_acsl_valid_read_6 = __e_acsl_valid_read((void *)(& (*((int (*)[])f))[__gen_e_acsl_iter_7]),
                                                          sizeof(int),
                                                          (void *)(*((int (*)[])f)),
                                                          (void *)0);
          __gen_e_acsl_assert_data_18.blocking = 1;
          __gen_e_acsl_assert_data_18.kind = "RTE";
          __gen_e_acsl_assert_data_18.pred_txt = "\\valid_read(&(*((int (*)[])f))[__gen_e_acsl_iter_7])";
          __gen_e_acsl_assert_data_18.file = "array.i";
          __gen_e_acsl_assert_data_18.fct = "arrays";
          __gen_e_acsl_assert_data_18.line = 43;
          __gen_e_acsl_assert_data_18.name = "mem_access";
          __e_acsl_assert(__gen_e_acsl_valid_read_6,
                          & __gen_e_acsl_assert_data_18);
          __e_acsl_assert_clean(& __gen_e_acsl_assert_data_18);
          if (a[__gen_e_acsl_iter_7] != (*((int (*)[])f))[__gen_e_acsl_iter_7]) {
            __gen_e_acsl_ne_4 = 1;
            break;
          }
        }
        __gen_e_acsl_iter_7 ++;
      }
    }
    else __gen_e_acsl_ne_4 = 1;
    __gen_e_acsl_assert_data_16.blocking = 1;
    __gen_e_acsl_assert_data_16.kind = "Assertion";
    __gen_e_acsl_assert_data_16.pred_txt = "a != *((int (*)[])f)";
    __gen_e_acsl_assert_data_16.file = "array.i";
    __gen_e_acsl_assert_data_16.fct = "arrays";
    __gen_e_acsl_assert_data_16.line = 43;
    __e_acsl_assert(__gen_e_acsl_ne_4,& __gen_e_acsl_assert_data_16);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_16);
  }
  /*@ assert a != *((int (*)[])f); */ ;
  int i[6] = {1, 2, 3, 4, 5, 6};
  __e_acsl_store_block((void *)(i),24UL);
  __e_acsl_full_init((void *)(& i));
  int j[6] = {4, 5, 6, 1, 2, 3};
  __e_acsl_store_block((void *)(j),24UL);
  __e_acsl_full_init((void *)(& j));
  int k[6] = {4, 5, 6, 4, 5, 6};
  __e_acsl_store_block((void *)(k),24UL);
  __e_acsl_full_init((void *)(& k));
  {
    int __gen_e_acsl_ne_5;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_19 =
      {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_19,"i",
                                   (void *)(i));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_19,"j",
                                   (void *)(j));
    __gen_e_acsl_ne_5 = 0;
    if (1) {
      unsigned long __gen_e_acsl_iter_8;
      __gen_e_acsl_iter_8 = 0;
      while (__gen_e_acsl_iter_8 < 6) {
        if (i[__gen_e_acsl_iter_8] != j[__gen_e_acsl_iter_8]) {
          __gen_e_acsl_ne_5 = 1;
          break;
        }
        __gen_e_acsl_iter_8 ++;
      }
    }
    else __gen_e_acsl_ne_5 = 1;
    __gen_e_acsl_assert_data_19.blocking = 1;
    __gen_e_acsl_assert_data_19.kind = "Assertion";
    __gen_e_acsl_assert_data_19.pred_txt = "i != j";
    __gen_e_acsl_assert_data_19.file = "array.i";
    __gen_e_acsl_assert_data_19.fct = "arrays";
    __gen_e_acsl_assert_data_19.line = 49;
    __e_acsl_assert(__gen_e_acsl_ne_5,& __gen_e_acsl_assert_data_19);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_19);
  }
  /*@ assert i != j; */ ;
  {
    int __gen_e_acsl_ne_6;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_20 =
      {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_20,"i",
                                   (void *)(i));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_20,"k",
                                   (void *)(k));
    __gen_e_acsl_ne_6 = 0;
    if (1) {
      unsigned long __gen_e_acsl_iter_9;
      __gen_e_acsl_iter_9 = 0;
      while (__gen_e_acsl_iter_9 < 6) {
        if (i[__gen_e_acsl_iter_9] != k[__gen_e_acsl_iter_9]) {
          __gen_e_acsl_ne_6 = 1;
          break;
        }
        __gen_e_acsl_iter_9 ++;
      }
    }
    else __gen_e_acsl_ne_6 = 1;
    __gen_e_acsl_assert_data_20.blocking = 1;
    __gen_e_acsl_assert_data_20.kind = "Assertion";
    __gen_e_acsl_assert_data_20.pred_txt = "i != k";
    __gen_e_acsl_assert_data_20.file = "array.i";
    __gen_e_acsl_assert_data_20.fct = "arrays";
    __gen_e_acsl_assert_data_20.line = 50;
    __e_acsl_assert(__gen_e_acsl_ne_6,& __gen_e_acsl_assert_data_20);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_20);
  }
  /*@ assert i != k; */ ;
  {
    int __gen_e_acsl_ne_7;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_21 =
      {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_21,"j",
                                   (void *)(j));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_21,"k",
                                   (void *)(k));
    __gen_e_acsl_ne_7 = 0;
    if (1) {
      unsigned long __gen_e_acsl_iter_10;
      __gen_e_acsl_iter_10 = 0;
      while (__gen_e_acsl_iter_10 < 6) {
        if (j[__gen_e_acsl_iter_10] != k[__gen_e_acsl_iter_10]) {
          __gen_e_acsl_ne_7 = 1;
          break;
        }
        __gen_e_acsl_iter_10 ++;
      }
    }
    else __gen_e_acsl_ne_7 = 1;
    __gen_e_acsl_assert_data_21.blocking = 1;
    __gen_e_acsl_assert_data_21.kind = "Assertion";
    __gen_e_acsl_assert_data_21.pred_txt = "j != k";
    __gen_e_acsl_assert_data_21.file = "array.i";
    __gen_e_acsl_assert_data_21.fct = "arrays";
    __gen_e_acsl_assert_data_21.line = 51;
    __e_acsl_assert(__gen_e_acsl_ne_7,& __gen_e_acsl_assert_data_21);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_21);
  }
  /*@ assert j != k; */ ;
  int *l = & i[3];
  __e_acsl_store_block((void *)(& l),8UL);
  __e_acsl_full_init((void *)(& l));
  int *m = & j[3];
  __e_acsl_store_block((void *)(& m),8UL);
  __e_acsl_full_init((void *)(& m));
  int *n = & k[3];
  __e_acsl_store_block((void *)(& n),8UL);
  __e_acsl_full_init((void *)(& n));
  {
    int __gen_e_acsl_ne_8;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_22 =
      {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_22,
                                   "*((int (*)[3])l)",
                                   (void *)(*((int (*)[3])l)));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_22,
                                   "*((int (*)[3])m)",
                                   (void *)(*((int (*)[3])m)));
    __gen_e_acsl_ne_8 = 0;
    if (1) {
      unsigned long __gen_e_acsl_iter_11;
      __gen_e_acsl_iter_11 = 0;
      while (__gen_e_acsl_iter_11 < 3) {
        {
          int __gen_e_acsl_valid_read_7;
          int __gen_e_acsl_valid_read_8;
          __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,
                                       "&(*((int (*)[3])l))[__gen_e_acsl_iter_11]",
                                       (void *)(& (*((int (*)[3])l))[__gen_e_acsl_iter_11]));
          __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_23,
                                         "sizeof(int)",0,sizeof(int));
          __gen_e_acsl_valid_read_7 = __e_acsl_valid_read((void *)(& (*((int (*)[3])l))[__gen_e_acsl_iter_11]),
                                                          sizeof(int),
                                                          (void *)(*((int (*)[3])l)),
                                                          (void *)0);
          __gen_e_acsl_assert_data_23.blocking = 1;
          __gen_e_acsl_assert_data_23.kind = "RTE";
          __gen_e_acsl_assert_data_23.pred_txt = "\\valid_read(&(*((int (*)[3])l))[__gen_e_acsl_iter_11])";
          __gen_e_acsl_assert_data_23.file = "array.i";
          __gen_e_acsl_assert_data_23.fct = "arrays";
          __gen_e_acsl_assert_data_23.line = 55;
          __gen_e_acsl_assert_data_23.name = "mem_access";
          __e_acsl_assert(__gen_e_acsl_valid_read_7,
                          & __gen_e_acsl_assert_data_23);
          __e_acsl_assert_clean(& __gen_e_acsl_assert_data_23);
          __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,
                                       "&(*((int (*)[3])m))[__gen_e_acsl_iter_11]",
                                       (void *)(& (*((int (*)[3])m))[__gen_e_acsl_iter_11]));
          __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_24,
                                         "sizeof(int)",0,sizeof(int));
          __gen_e_acsl_valid_read_8 = __e_acsl_valid_read((void *)(& (*((int (*)[3])m))[__gen_e_acsl_iter_11]),
                                                          sizeof(int),
                                                          (void *)(*((int (*)[3])m)),
                                                          (void *)0);
          __gen_e_acsl_assert_data_24.blocking = 1;
          __gen_e_acsl_assert_data_24.kind = "RTE";
          __gen_e_acsl_assert_data_24.pred_txt = "\\valid_read(&(*((int (*)[3])m))[__gen_e_acsl_iter_11])";
          __gen_e_acsl_assert_data_24.file = "array.i";
          __gen_e_acsl_assert_data_24.fct = "arrays";
          __gen_e_acsl_assert_data_24.line = 55;
          __gen_e_acsl_assert_data_24.name = "mem_access";
          __e_acsl_assert(__gen_e_acsl_valid_read_8,
                          & __gen_e_acsl_assert_data_24);
          __e_acsl_assert_clean(& __gen_e_acsl_assert_data_24);
          if ((*((int (*)[3])l))[__gen_e_acsl_iter_11] != (*((int (*)[3])m))[__gen_e_acsl_iter_11]) {
            __gen_e_acsl_ne_8 = 1;
            break;
          }
        }
        __gen_e_acsl_iter_11 ++;
      }
    }
    else __gen_e_acsl_ne_8 = 1;
    __gen_e_acsl_assert_data_22.blocking = 1;
    __gen_e_acsl_assert_data_22.kind = "Assertion";
    __gen_e_acsl_assert_data_22.pred_txt = "*((int (*)[3])l) != *((int (*)[3])m)";
    __gen_e_acsl_assert_data_22.file = "array.i";
    __gen_e_acsl_assert_data_22.fct = "arrays";
    __gen_e_acsl_assert_data_22.line = 55;
    __e_acsl_assert(__gen_e_acsl_ne_8,& __gen_e_acsl_assert_data_22);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_22);
  }
  /*@ assert *((int (*)[3])l) != *((int (*)[3])m); */ ;
  {
    int __gen_e_acsl_eq_4;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_25 =
      {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_25,
                                   "*((int (*)[3])l)",
                                   (void *)(*((int (*)[3])l)));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_25,
                                   "*((int (*)[3])n)",
                                   (void *)(*((int (*)[3])n)));
    __gen_e_acsl_eq_4 = 1;
    if (1) {
      unsigned long __gen_e_acsl_iter_12;
      __gen_e_acsl_iter_12 = 0;
      while (__gen_e_acsl_iter_12 < 3) {
        {
          int __gen_e_acsl_valid_read_9;
          int __gen_e_acsl_valid_read_10;
          __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,
                                       "&(*((int (*)[3])l))[__gen_e_acsl_iter_12]",
                                       (void *)(& (*((int (*)[3])l))[__gen_e_acsl_iter_12]));
          __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_26,
                                         "sizeof(int)",0,sizeof(int));
          __gen_e_acsl_valid_read_9 = __e_acsl_valid_read((void *)(& (*((int (*)[3])l))[__gen_e_acsl_iter_12]),
                                                          sizeof(int),
                                                          (void *)(*((int (*)[3])l)),
                                                          (void *)0);
          __gen_e_acsl_assert_data_26.blocking = 1;
          __gen_e_acsl_assert_data_26.kind = "RTE";
          __gen_e_acsl_assert_data_26.pred_txt = "\\valid_read(&(*((int (*)[3])l))[__gen_e_acsl_iter_12])";
          __gen_e_acsl_assert_data_26.file = "array.i";
          __gen_e_acsl_assert_data_26.fct = "arrays";
          __gen_e_acsl_assert_data_26.line = 56;
          __gen_e_acsl_assert_data_26.name = "mem_access";
          __e_acsl_assert(__gen_e_acsl_valid_read_9,
                          & __gen_e_acsl_assert_data_26);
          __e_acsl_assert_clean(& __gen_e_acsl_assert_data_26);
          __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,
                                       "&(*((int (*)[3])n))[__gen_e_acsl_iter_12]",
                                       (void *)(& (*((int (*)[3])n))[__gen_e_acsl_iter_12]));
          __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_27,
                                         "sizeof(int)",0,sizeof(int));
          __gen_e_acsl_valid_read_10 = __e_acsl_valid_read((void *)(& (*((int (*)[3])n))[__gen_e_acsl_iter_12]),
                                                           sizeof(int),
                                                           (void *)(*((int (*)[3])n)),
                                                           (void *)0);
          __gen_e_acsl_assert_data_27.blocking = 1;
          __gen_e_acsl_assert_data_27.kind = "RTE";
          __gen_e_acsl_assert_data_27.pred_txt = "\\valid_read(&(*((int (*)[3])n))[__gen_e_acsl_iter_12])";
          __gen_e_acsl_assert_data_27.file = "array.i";
          __gen_e_acsl_assert_data_27.fct = "arrays";
          __gen_e_acsl_assert_data_27.line = 56;
          __gen_e_acsl_assert_data_27.name = "mem_access";
          __e_acsl_assert(__gen_e_acsl_valid_read_10,
                          & __gen_e_acsl_assert_data_27);
          __e_acsl_assert_clean(& __gen_e_acsl_assert_data_27);
          if ((*((int (*)[3])l))[__gen_e_acsl_iter_12] != (*((int (*)[3])n))[__gen_e_acsl_iter_12]) {
            __gen_e_acsl_eq_4 = 0;
            break;
          }
        }
        __gen_e_acsl_iter_12 ++;
      }
    }
    else __gen_e_acsl_eq_4 = 0;
    __gen_e_acsl_assert_data_25.blocking = 1;
    __gen_e_acsl_assert_data_25.kind = "Assertion";
    __gen_e_acsl_assert_data_25.pred_txt = "*((int (*)[3])l) == *((int (*)[3])n)";
    __gen_e_acsl_assert_data_25.file = "array.i";
    __gen_e_acsl_assert_data_25.fct = "arrays";
    __gen_e_acsl_assert_data_25.line = 56;
    __e_acsl_assert(__gen_e_acsl_eq_4,& __gen_e_acsl_assert_data_25);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_25);
  }
  /*@ assert *((int (*)[3])l) == *((int (*)[3])n); */ ;
  {
    int __gen_e_acsl_ne_9;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_28 =
      {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_28,"i",
                                   (void *)(i));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_28,"k",
                                   (void *)(k));
    __gen_e_acsl_ne_9 = 0;
    if (1) {
      unsigned long __gen_e_acsl_iter_13;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_29 =
        {.values = (void *)0};
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_30 =
        {.values = (void *)0};
      __gen_e_acsl_assert_data_30.blocking = 1;
      __gen_e_acsl_assert_data_30.kind = "RTE";
      __gen_e_acsl_assert_data_30.pred_txt = "(int)3 <= (int)6";
      __gen_e_acsl_assert_data_30.file = "array.i";
      __gen_e_acsl_assert_data_30.fct = "arrays";
      __gen_e_acsl_assert_data_30.line = 59;
      __gen_e_acsl_assert_data_30.name = "array_coercion";
      __e_acsl_assert(1,& __gen_e_acsl_assert_data_30);
      __gen_e_acsl_assert_data_29.blocking = 1;
      __gen_e_acsl_assert_data_29.kind = "RTE";
      __gen_e_acsl_assert_data_29.pred_txt = "(int)3 <= (int)6";
      __gen_e_acsl_assert_data_29.file = "array.i";
      __gen_e_acsl_assert_data_29.fct = "arrays";
      __gen_e_acsl_assert_data_29.line = 59;
      __gen_e_acsl_assert_data_29.name = "array_coercion";
      __e_acsl_assert(1,& __gen_e_acsl_assert_data_29);
      __gen_e_acsl_iter_13 = 0;
      while (__gen_e_acsl_iter_13 < 3) {
        if (i[__gen_e_acsl_iter_13] != k[__gen_e_acsl_iter_13]) {
          __gen_e_acsl_ne_9 = 1;
          break;
        }
        __gen_e_acsl_iter_13 ++;
      }
    }
    else __gen_e_acsl_ne_9 = 1;
    __gen_e_acsl_assert_data_28.blocking = 1;
    __gen_e_acsl_assert_data_28.kind = "Assertion";
    __gen_e_acsl_assert_data_28.pred_txt = "(int [3])i != (int [3])k";
    __gen_e_acsl_assert_data_28.file = "array.i";
    __gen_e_acsl_assert_data_28.fct = "arrays";
    __gen_e_acsl_assert_data_28.line = 59;
    __e_acsl_assert(__gen_e_acsl_ne_9,& __gen_e_acsl_assert_data_28);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_28);
  }
  /*@ assert (int [3])i != (int [3])k; */ ;
  {
    int __gen_e_acsl_eq_5;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_31 =
      {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_31,"j",
                                   (void *)(j));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_31,"k",
                                   (void *)(k));
    __gen_e_acsl_eq_5 = 1;
    if (1) {
      unsigned long __gen_e_acsl_iter_14;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_32 =
        {.values = (void *)0};
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_33 =
        {.values = (void *)0};
      __gen_e_acsl_assert_data_33.blocking = 1;
      __gen_e_acsl_assert_data_33.kind = "RTE";
      __gen_e_acsl_assert_data_33.pred_txt = "(int)3 <= (int)6";
      __gen_e_acsl_assert_data_33.file = "array.i";
      __gen_e_acsl_assert_data_33.fct = "arrays";
      __gen_e_acsl_assert_data_33.line = 60;
      __gen_e_acsl_assert_data_33.name = "array_coercion";
      __e_acsl_assert(1,& __gen_e_acsl_assert_data_33);
      __gen_e_acsl_assert_data_32.blocking = 1;
      __gen_e_acsl_assert_data_32.kind = "RTE";
      __gen_e_acsl_assert_data_32.pred_txt = "(int)3 <= (int)6";
      __gen_e_acsl_assert_data_32.file = "array.i";
      __gen_e_acsl_assert_data_32.fct = "arrays";
      __gen_e_acsl_assert_data_32.line = 60;
      __gen_e_acsl_assert_data_32.name = "array_coercion";
      __e_acsl_assert(1,& __gen_e_acsl_assert_data_32);
      __gen_e_acsl_iter_14 = 0;
      while (__gen_e_acsl_iter_14 < 3) {
        if (j[__gen_e_acsl_iter_14] != k[__gen_e_acsl_iter_14]) {
          __gen_e_acsl_eq_5 = 0;
          break;
        }
        __gen_e_acsl_iter_14 ++;
      }
    }
    else __gen_e_acsl_eq_5 = 0;
    __gen_e_acsl_assert_data_31.blocking = 1;
    __gen_e_acsl_assert_data_31.kind = "Assertion";
    __gen_e_acsl_assert_data_31.pred_txt = "(int [3])j == (int [3])k";
    __gen_e_acsl_assert_data_31.file = "array.i";
    __gen_e_acsl_assert_data_31.fct = "arrays";
    __gen_e_acsl_assert_data_31.line = 60;
    __e_acsl_assert(__gen_e_acsl_eq_5,& __gen_e_acsl_assert_data_31);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_31);
  }
  /*@ assert (int [3])j == (int [3])k; */ ;
  {
    int __gen_e_acsl_ne_10;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_34 =
      {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_34,
                                   "*((int (*)[2])l)",
                                   (void *)(*((int (*)[2])l)));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_34,
                                   "*((int (*)[2])m)",
                                   (void *)(*((int (*)[2])m)));
    __gen_e_acsl_ne_10 = 0;
    if (1) {
      unsigned long __gen_e_acsl_iter_15;
      __gen_e_acsl_iter_15 = 0;
      while (__gen_e_acsl_iter_15 < 2) {
        {
          int __gen_e_acsl_valid_read_11;
          int __gen_e_acsl_valid_read_12;
          __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,
                                       "&(*((int (*)[2])l))[__gen_e_acsl_iter_15]",
                                       (void *)(& (*((int (*)[2])l))[__gen_e_acsl_iter_15]));
          __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_35,
                                         "sizeof(int)",0,sizeof(int));
          __gen_e_acsl_valid_read_11 = __e_acsl_valid_read((void *)(& (*((int (*)[2])l))[__gen_e_acsl_iter_15]),
                                                           sizeof(int),
                                                           (void *)(*((int (*)[2])l)),
                                                           (void *)0);
          __gen_e_acsl_assert_data_35.blocking = 1;
          __gen_e_acsl_assert_data_35.kind = "RTE";
          __gen_e_acsl_assert_data_35.pred_txt = "\\valid_read(&(*((int (*)[2])l))[__gen_e_acsl_iter_15])";
          __gen_e_acsl_assert_data_35.file = "array.i";
          __gen_e_acsl_assert_data_35.fct = "arrays";
          __gen_e_acsl_assert_data_35.line = 61;
          __gen_e_acsl_assert_data_35.name = "mem_access";
          __e_acsl_assert(__gen_e_acsl_valid_read_11,
                          & __gen_e_acsl_assert_data_35);
          __e_acsl_assert_clean(& __gen_e_acsl_assert_data_35);
          __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,
                                       "&(*((int (*)[2])m))[__gen_e_acsl_iter_15]",
                                       (void *)(& (*((int (*)[2])m))[__gen_e_acsl_iter_15]));
          __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_36,
                                         "sizeof(int)",0,sizeof(int));
          __gen_e_acsl_valid_read_12 = __e_acsl_valid_read((void *)(& (*((int (*)[2])m))[__gen_e_acsl_iter_15]),
                                                           sizeof(int),
                                                           (void *)(*((int (*)[2])m)),
                                                           (void *)0);
          __gen_e_acsl_assert_data_36.blocking = 1;
          __gen_e_acsl_assert_data_36.kind = "RTE";
          __gen_e_acsl_assert_data_36.pred_txt = "\\valid_read(&(*((int (*)[2])m))[__gen_e_acsl_iter_15])";
          __gen_e_acsl_assert_data_36.file = "array.i";
          __gen_e_acsl_assert_data_36.fct = "arrays";
          __gen_e_acsl_assert_data_36.line = 61;
          __gen_e_acsl_assert_data_36.name = "mem_access";
          __e_acsl_assert(__gen_e_acsl_valid_read_12,
                          & __gen_e_acsl_assert_data_36);
          __e_acsl_assert_clean(& __gen_e_acsl_assert_data_36);
          if ((*((int (*)[2])l))[__gen_e_acsl_iter_15] != (*((int (*)[2])m))[__gen_e_acsl_iter_15]) {
            __gen_e_acsl_ne_10 = 1;
            break;
          }
        }
        __gen_e_acsl_iter_15 ++;
      }
    }
    else __gen_e_acsl_ne_10 = 1;
    __gen_e_acsl_assert_data_34.blocking = 1;
    __gen_e_acsl_assert_data_34.kind = "Assertion";
    __gen_e_acsl_assert_data_34.pred_txt = "*((int (*)[2])l) != *((int (*)[2])m)";
    __gen_e_acsl_assert_data_34.file = "array.i";
    __gen_e_acsl_assert_data_34.fct = "arrays";
    __gen_e_acsl_assert_data_34.line = 61;
    __e_acsl_assert(__gen_e_acsl_ne_10,& __gen_e_acsl_assert_data_34);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_34);
  }
  /*@ assert *((int (*)[2])l) != *((int (*)[2])m); */ ;
  {
    int __gen_e_acsl_eq_6;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_37 =
      {.values = (void *)0};
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_37,
                                   "*((int (*)[2])l)",
                                   (void *)(*((int (*)[2])l)));
    __e_acsl_assert_register_array(& __gen_e_acsl_assert_data_37,
                                   "*((int (*)[2])n)",
                                   (void *)(*((int (*)[2])n)));
    __gen_e_acsl_eq_6 = 1;
    if (1) {
      unsigned long __gen_e_acsl_iter_16;
      __gen_e_acsl_iter_16 = 0;
      while (__gen_e_acsl_iter_16 < 2) {
        {
          int __gen_e_acsl_valid_read_13;
          int __gen_e_acsl_valid_read_14;
          __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,
                                       "&(*((int (*)[2])l))[__gen_e_acsl_iter_16]",
                                       (void *)(& (*((int (*)[2])l))[__gen_e_acsl_iter_16]));
          __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_38,
                                         "sizeof(int)",0,sizeof(int));
          __gen_e_acsl_valid_read_13 = __e_acsl_valid_read((void *)(& (*((int (*)[2])l))[__gen_e_acsl_iter_16]),
                                                           sizeof(int),
                                                           (void *)(*((int (*)[2])l)),
                                                           (void *)0);
          __gen_e_acsl_assert_data_38.blocking = 1;
          __gen_e_acsl_assert_data_38.kind = "RTE";
          __gen_e_acsl_assert_data_38.pred_txt = "\\valid_read(&(*((int (*)[2])l))[__gen_e_acsl_iter_16])";
          __gen_e_acsl_assert_data_38.file = "array.i";
          __gen_e_acsl_assert_data_38.fct = "arrays";
          __gen_e_acsl_assert_data_38.line = 62;
          __gen_e_acsl_assert_data_38.name = "mem_access";
          __e_acsl_assert(__gen_e_acsl_valid_read_13,
                          & __gen_e_acsl_assert_data_38);
          __e_acsl_assert_clean(& __gen_e_acsl_assert_data_38);
          __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,
                                       "&(*((int (*)[2])n))[__gen_e_acsl_iter_16]",
                                       (void *)(& (*((int (*)[2])n))[__gen_e_acsl_iter_16]));
          __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_39,
                                         "sizeof(int)",0,sizeof(int));
          __gen_e_acsl_valid_read_14 = __e_acsl_valid_read((void *)(& (*((int (*)[2])n))[__gen_e_acsl_iter_16]),
                                                           sizeof(int),
                                                           (void *)(*((int (*)[2])n)),
                                                           (void *)0);
          __gen_e_acsl_assert_data_39.blocking = 1;
          __gen_e_acsl_assert_data_39.kind = "RTE";
          __gen_e_acsl_assert_data_39.pred_txt = "\\valid_read(&(*((int (*)[2])n))[__gen_e_acsl_iter_16])";
          __gen_e_acsl_assert_data_39.file = "array.i";
          __gen_e_acsl_assert_data_39.fct = "arrays";
          __gen_e_acsl_assert_data_39.line = 62;
          __gen_e_acsl_assert_data_39.name = "mem_access";
          __e_acsl_assert(__gen_e_acsl_valid_read_14,
                          & __gen_e_acsl_assert_data_39);
          __e_acsl_assert_clean(& __gen_e_acsl_assert_data_39);
          if ((*((int (*)[2])l))[__gen_e_acsl_iter_16] != (*((int (*)[2])n))[__gen_e_acsl_iter_16]) {
            __gen_e_acsl_eq_6 = 0;
            break;
          }
        }
        __gen_e_acsl_iter_16 ++;
      }
    }
    else __gen_e_acsl_eq_6 = 0;
    __gen_e_acsl_assert_data_37.blocking = 1;
    __gen_e_acsl_assert_data_37.kind = "Assertion";
    __gen_e_acsl_assert_data_37.pred_txt = "*((int (*)[2])l) == *((int (*)[2])n)";
    __gen_e_acsl_assert_data_37.file = "array.i";
    __gen_e_acsl_assert_data_37.fct = "arrays";
    __gen_e_acsl_assert_data_37.line = 62;
    __e_acsl_assert(__gen_e_acsl_eq_6,& __gen_e_acsl_assert_data_37);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_37);
  }
  /*@ assert *((int (*)[2])l) == *((int (*)[2])n); */ ;
  __e_acsl_delete_block((void *)(& n));
  __e_acsl_delete_block((void *)(& m));
  __e_acsl_delete_block((void *)(& l));
  __e_acsl_delete_block((void *)(k));
  __e_acsl_delete_block((void *)(j));
  __e_acsl_delete_block((void *)(i));
  __e_acsl_delete_block((void *)(& g));
  __e_acsl_delete_block((void *)(& f));
  __e_acsl_delete_block((void *)(c));
  __e_acsl_delete_block((void *)(b));
  return;
}

void vlas(int n)
{
  return;
}

int main(void)
{
  int __retres;
  __e_acsl_memory_init((int *)0,(char ***)0,8UL);
  {
    int i = 0;
    while (i < 3) {
      T1[i] = i;
      i ++;
    }
  }
  {
    int i_0 = 0;
    while (i_0 < 4) {
      T2[i_0] = 2 * i_0;
      i_0 ++;
    }
  }
  {
    __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"T1[0]",0,T1[0]);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"T2[0]",0,T2[0]);
    __gen_e_acsl_assert_data.blocking = 1;
    __gen_e_acsl_assert_data.kind = "Assertion";
    __gen_e_acsl_assert_data.pred_txt = "T1[0] == T2[0]";
    __gen_e_acsl_assert_data.file = "array.i";
    __gen_e_acsl_assert_data.fct = "main";
    __gen_e_acsl_assert_data.line = 110;
    __e_acsl_assert(T1[0] == T2[0],& __gen_e_acsl_assert_data);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
  }
  /*@ assert T1[0] == T2[0]; */ ;
  {
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
      {.values = (void *)0};
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,"T1[1]",0,
                                 T1[1]);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,"T2[1]",0,
                                 T2[1]);
    __gen_e_acsl_assert_data_2.blocking = 1;
    __gen_e_acsl_assert_data_2.kind = "Assertion";
    __gen_e_acsl_assert_data_2.pred_txt = "T1[1] != T2[1]";
    __gen_e_acsl_assert_data_2.file = "array.i";
    __gen_e_acsl_assert_data_2.fct = "main";
    __gen_e_acsl_assert_data_2.line = 111;
    __e_acsl_assert(T1[1] != T2[1],& __gen_e_acsl_assert_data_2);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
  }
  /*@ assert T1[1] != T2[1]; */ ;
  arrays();
  vlas(3);
  __retres = 0;
  __e_acsl_memory_clean();
  return __retres;
}


