/* 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;

/*@ ensures
      \forall integer n;
        1 < n <= 3 ==> \old(*(t + n) == 12) && \old(*(t + (n - 1)) > 5);
    ensures \let m = 4; \old(*(t + m) == -4) && \old(*(t + (m - 4))) == 9;
 */
void __gen_e_acsl_f(int *t);

void f(int *t)
{
  __e_acsl_store_block((void *)(& t),8UL);
  __e_acsl_delete_block((void *)(& t));
  return;
}

void g(void)
{
  int *__gen_e_acsl_at;
  int m;
  __gen_e_acsl_at = (int *)malloc(12UL);
  m = 8;
  Q:
  {
    int __gen_e_acsl_w;
    __gen_e_acsl_w = 3;
    while (1) {
      if (__gen_e_acsl_w < 6) ; else break;
      *(__gen_e_acsl_at + (__gen_e_acsl_w - 3)) = m + (long)__gen_e_acsl_w == 12L;
      __gen_e_acsl_w ++;
    }
  }
  ;
  m = 10;
  {
    int __gen_e_acsl_exists;
    int __gen_e_acsl_w_2;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
    __gen_e_acsl_exists = 0;
    __gen_e_acsl_w_2 = 3;
    while (1) {
      if (__gen_e_acsl_w_2 < 6) ; else break;
      {
        int __gen_e_acsl_valid_read;
        __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
          {.values = (void *)0};
        __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_2,
                                     "__gen_e_acsl_at",
                                     (void *)__gen_e_acsl_at);
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,
                                     "__gen_e_acsl_w_2",0,__gen_e_acsl_w_2);
        __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_2,
                                       "sizeof(int)",0,sizeof(int));
        __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(__gen_e_acsl_at + (int)(
                                                               __gen_e_acsl_w_2 - 3L)),
                                                      sizeof(int),
                                                      (void *)__gen_e_acsl_at,
                                                      (void *)(& __gen_e_acsl_at));
        __gen_e_acsl_assert_data_2.blocking = 1;
        __gen_e_acsl_assert_data_2.kind = "RTE";
        __gen_e_acsl_assert_data_2.pred_txt = "\\valid_read(__gen_e_acsl_at + (int)(__gen_e_acsl_w_2 - 3))";
        __gen_e_acsl_assert_data_2.file = "at_on-purely-logic-variables.c";
        __gen_e_acsl_assert_data_2.fct = "g";
        __gen_e_acsl_assert_data_2.line = 16;
        __gen_e_acsl_assert_data_2.name = "mem_access";
        __e_acsl_assert(__gen_e_acsl_valid_read,& __gen_e_acsl_assert_data_2);
        __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
        if (! *(__gen_e_acsl_at + (__gen_e_acsl_w_2 - 3))) ;
        else {
          __gen_e_acsl_exists = 1;
          goto e_acsl_end_loop1;
        }
      }
      __gen_e_acsl_w_2 ++;
    }
    e_acsl_end_loop1: ;
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
                                 "\\exists integer w; 3 <= w < 6 && \\at(m + w == 12,Q)",
                                 0,__gen_e_acsl_exists);
    __gen_e_acsl_assert_data.blocking = 1;
    __gen_e_acsl_assert_data.kind = "Assertion";
    __gen_e_acsl_assert_data.pred_txt = "\\exists integer w; 3 <= w < 6 && \\at(m + w == 12,Q)";
    __gen_e_acsl_assert_data.file = "at_on-purely-logic-variables.c";
    __gen_e_acsl_assert_data.fct = "g";
    __gen_e_acsl_assert_data.line = 16;
    __e_acsl_assert(__gen_e_acsl_exists,& __gen_e_acsl_assert_data);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
  }
  /*@ assert \exists integer w; 3 <= w < 6 && \at(m + w == 12,Q); */ ;
  free((void *)__gen_e_acsl_at);
  return;
}

int main(void)
{
  long *__gen_e_acsl_at_8;
  int *__gen_e_acsl_at_7;
  long *__gen_e_acsl_at_6;
  int *__gen_e_acsl_at_5;
  int *__gen_e_acsl_at_3;
  long *__gen_e_acsl_at_2;
  int *__gen_e_acsl_at;
  int __retres;
  int n;
  __e_acsl_memory_init((int *)0,(char ***)0,8UL);
  __gen_e_acsl_at_8 = (long *)malloc(64UL);
  __gen_e_acsl_at_7 = (int *)malloc(12000UL);
  __gen_e_acsl_at_6 = (long *)malloc(3072UL);
  __gen_e_acsl_at_5 = (int *)malloc(528UL);
  __gen_e_acsl_at_3 = (int *)malloc(12UL);
  __gen_e_acsl_at_2 = (long *)malloc(8UL);
  __gen_e_acsl_at = (int *)malloc(4UL);
  __e_acsl_store_block((void *)(& n),4UL);
  __e_acsl_full_init((void *)(& n));
  n = 7;
  L:
  {
    int __gen_e_acsl_i;
    __gen_e_acsl_i = 3;
    *(__gen_e_acsl_at + 0) = n + (long)__gen_e_acsl_i == 10L;
  }
  {
    int __gen_e_acsl_i_2;
    __gen_e_acsl_i_2 = 3;
    *(__gen_e_acsl_at_2 + 0) = n + (long)__gen_e_acsl_i_2;
  }
  {
    int __gen_e_acsl_j;
    __gen_e_acsl_j = 2;
    while (1) {
      if (__gen_e_acsl_j < 5) ; else break;
      *(__gen_e_acsl_at_3 + (__gen_e_acsl_j - 2)) = n + (long)__gen_e_acsl_j == 11L;
      __gen_e_acsl_j ++;
    }
  }
  ;
  __e_acsl_full_init((void *)(& n));
  n = 9;
  K:
  {
    int __gen_e_acsl_k;
    int __gen_e_acsl_u;
    int __gen_e_acsl_v;
    __gen_e_acsl_k = -7;
    __gen_e_acsl_u = 9;
    while (1) {
      if (__gen_e_acsl_u < 21) ; else break;
      __gen_e_acsl_v = -5 + 1;
      while (1) {
        if (__gen_e_acsl_v <= 6) ; else break;
        {
          long __gen_e_acsl_if;
          if (__gen_e_acsl_u > 0) __gen_e_acsl_if = n + (long)__gen_e_acsl_k;
          else __gen_e_acsl_if = __gen_e_acsl_u + __gen_e_acsl_v;
          *(__gen_e_acsl_at_5 + ((__gen_e_acsl_u - 9) * 11 + (__gen_e_acsl_v - -4))) = 
          __gen_e_acsl_if > 0L;
        }
        __gen_e_acsl_v ++;
      }
      __gen_e_acsl_u ++;
    }
  }
  {
    int __gen_e_acsl_u_2;
    int __gen_e_acsl_v_2;
    __gen_e_acsl_u_2 = 9;
    while (1) {
      if (__gen_e_acsl_u_2 < 21) ; else break;
      __gen_e_acsl_v_2 = -5 + 1;
      while (1) {
        {
          int __gen_e_acsl_if_2;
          if (__gen_e_acsl_u_2 < 15) __gen_e_acsl_if_2 = __gen_e_acsl_u_2 + 6;
          else __gen_e_acsl_if_2 = 3;
          if (__gen_e_acsl_v_2 <= __gen_e_acsl_if_2) ; else break;
        }
        *(__gen_e_acsl_at_6 + ((__gen_e_acsl_u_2 - 9) * 32 + (__gen_e_acsl_v_2 - -4))) = 
        (n + (long)__gen_e_acsl_u_2) + __gen_e_acsl_v_2;
        __gen_e_acsl_v_2 ++;
      }
      __gen_e_acsl_u_2 ++;
    }
  }
  {
    int __gen_e_acsl_u_3;
    int __gen_e_acsl_v_3;
    int __gen_e_acsl_w;
    __gen_e_acsl_u_3 = 10;
    while (1) {
      if (__gen_e_acsl_u_3 < 20) ; else break;
      __gen_e_acsl_v_3 = -10 + 1;
      while (1) {
        {
          int __gen_e_acsl_u_5;
          __gen_e_acsl_u_5 = -2;
          if (__gen_e_acsl_v_3 <= -5 + __gen_e_acsl_u_5) ; else break;
        }
        __gen_e_acsl_w = 100 + 1;
        while (1) {
          if (__gen_e_acsl_w <= 200) ; else break;
          {
            int __gen_e_acsl_u_4;
            __gen_e_acsl_u_4 = 42;
            *(__gen_e_acsl_at_7 + ((__gen_e_acsl_u_3 - 10) * 300 + ((
                                                                    __gen_e_acsl_v_3 - -9) * 100 + (
                                                                    __gen_e_acsl_w - 101)))) = 
            (((n - (long)__gen_e_acsl_u_3) + __gen_e_acsl_u_4) + __gen_e_acsl_v_3) + __gen_e_acsl_w > 0L;
          }
          __gen_e_acsl_w ++;
        }
        __gen_e_acsl_v_3 ++;
      }
      __gen_e_acsl_u_3 ++;
    }
  }
  ;
  __e_acsl_full_init((void *)(& n));
  n = 666;
  {
    int __gen_e_acsl_i_3;
    int __gen_e_acsl_valid_read;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
    __gen_e_acsl_i_3 = 3;
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
                                 "\\at(n + i == 10,L)",0,
                                 *(__gen_e_acsl_at + 0));
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_2,
                                 "__gen_e_acsl_at",(void *)__gen_e_acsl_at);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_2,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(__gen_e_acsl_at + 0),
                                                  sizeof(int),
                                                  (void *)__gen_e_acsl_at,
                                                  (void *)(& __gen_e_acsl_at));
    __gen_e_acsl_assert_data_2.blocking = 1;
    __gen_e_acsl_assert_data_2.kind = "RTE";
    __gen_e_acsl_assert_data_2.pred_txt = "\\valid_read(__gen_e_acsl_at + 0)";
    __gen_e_acsl_assert_data_2.file = "at_on-purely-logic-variables.c";
    __gen_e_acsl_assert_data_2.fct = "main";
    __gen_e_acsl_assert_data_2.line = 28;
    __gen_e_acsl_assert_data_2.name = "mem_access";
    __e_acsl_assert(__gen_e_acsl_valid_read,& __gen_e_acsl_assert_data_2);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
    __gen_e_acsl_assert_data.blocking = 1;
    __gen_e_acsl_assert_data.kind = "Assertion";
    __gen_e_acsl_assert_data.pred_txt = "\\let i = 3; \\at(n + i == 10,L)";
    __gen_e_acsl_assert_data.file = "at_on-purely-logic-variables.c";
    __gen_e_acsl_assert_data.fct = "main";
    __gen_e_acsl_assert_data.line = 28;
    __e_acsl_assert(*(__gen_e_acsl_at + 0),& __gen_e_acsl_assert_data);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
  }
  /*@ assert \let i = 3; \at(n + i == 10,L); */ ;
  {
    int __gen_e_acsl_exists;
    int __gen_e_acsl_j_2;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
      {.values = (void *)0};
    __gen_e_acsl_exists = 0;
    __gen_e_acsl_j_2 = 2;
    while (1) {
      if (__gen_e_acsl_j_2 < 5) ; else break;
      {
        int __gen_e_acsl_valid_read_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,
                                     "__gen_e_acsl_at_3",
                                     (void *)__gen_e_acsl_at_3);
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,
                                     "__gen_e_acsl_j_2",0,__gen_e_acsl_j_2);
        __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_4,
                                       "sizeof(int)",0,sizeof(int));
        __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_3 + (int)(
                                                                 __gen_e_acsl_j_2 - 2L)),
                                                        sizeof(int),
                                                        (void *)__gen_e_acsl_at_3,
                                                        (void *)(& __gen_e_acsl_at_3));
        __gen_e_acsl_assert_data_4.blocking = 1;
        __gen_e_acsl_assert_data_4.kind = "RTE";
        __gen_e_acsl_assert_data_4.pred_txt = "\\valid_read(__gen_e_acsl_at_3 + (int)(__gen_e_acsl_j_2 - 2))";
        __gen_e_acsl_assert_data_4.file = "at_on-purely-logic-variables.c";
        __gen_e_acsl_assert_data_4.fct = "main";
        __gen_e_acsl_assert_data_4.line = 29;
        __gen_e_acsl_assert_data_4.name = "mem_access";
        __e_acsl_assert(__gen_e_acsl_valid_read_2,
                        & __gen_e_acsl_assert_data_4);
        __e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
        if (! *(__gen_e_acsl_at_3 + (__gen_e_acsl_j_2 - 2))) ;
        else {
          __gen_e_acsl_exists = 1;
          goto e_acsl_end_loop2;
        }
      }
      __gen_e_acsl_j_2 ++;
    }
    e_acsl_end_loop2: ;
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
                                 "\\exists integer j; 2 <= j < 5 && \\at(n + j == 11,L)",
                                 0,__gen_e_acsl_exists);
    __gen_e_acsl_assert_data_3.blocking = 1;
    __gen_e_acsl_assert_data_3.kind = "Assertion";
    __gen_e_acsl_assert_data_3.pred_txt = "\\exists integer j; 2 <= j < 5 && \\at(n + j == 11,L)";
    __gen_e_acsl_assert_data_3.file = "at_on-purely-logic-variables.c";
    __gen_e_acsl_assert_data_3.fct = "main";
    __gen_e_acsl_assert_data_3.line = 29;
    __e_acsl_assert(__gen_e_acsl_exists,& __gen_e_acsl_assert_data_3);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
  }
  /*@ assert \exists integer j; 2 <= j < 5 && \at(n + j == 11,L); */ ;
  {
    int __gen_e_acsl_k_2;
    int __gen_e_acsl_exists_2;
    int __gen_e_acsl_u_6;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_5 =
      {.values = (void *)0};
    __gen_e_acsl_k_2 = -7;
    __gen_e_acsl_exists_2 = 0;
    __gen_e_acsl_u_6 = 9;
    while (1) {
      if (__gen_e_acsl_u_6 < 21) ; else break;
      {
        int __gen_e_acsl_forall;
        int __gen_e_acsl_v_4;
        __gen_e_acsl_forall = 1;
        __gen_e_acsl_v_4 = -5 + 1;
        while (1) {
          if (__gen_e_acsl_v_4 <= 6) ; else break;
          {
            int __gen_e_acsl_valid_read_3;
            __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,
                                         "__gen_e_acsl_at_5",
                                         (void *)__gen_e_acsl_at_5);
            __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
                                         "__gen_e_acsl_u_6",0,
                                         __gen_e_acsl_u_6);
            __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
                                         "__gen_e_acsl_v_4",0,
                                         __gen_e_acsl_v_4);
            __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_6,
                                           "sizeof(int)",0,sizeof(int));
            __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(
                                                            __gen_e_acsl_at_5 + (int)(
                                                            (long)((int)(
                                                            (long)((int)(
                                                            __gen_e_acsl_u_6 - 9L)) * 11L)) + (int)(
                                                            __gen_e_acsl_v_4 - -4L))),
                                                            sizeof(int),
                                                            (void *)__gen_e_acsl_at_5,
                                                            (void *)(& __gen_e_acsl_at_5));
            __gen_e_acsl_assert_data_6.blocking = 1;
            __gen_e_acsl_assert_data_6.kind = "RTE";
            __gen_e_acsl_assert_data_6.pred_txt = "\\valid_read(__gen_e_acsl_at_5 +\n            (int)((int)((int)(__gen_e_acsl_u_6 - 9) * 11) +\n                  (int)(__gen_e_acsl_v_4 - -4)))";
            __gen_e_acsl_assert_data_6.file = "at_on-purely-logic-variables.c";
            __gen_e_acsl_assert_data_6.fct = "main";
            __gen_e_acsl_assert_data_6.line = 34;
            __gen_e_acsl_assert_data_6.name = "mem_access";
            __e_acsl_assert(__gen_e_acsl_valid_read_3,
                            & __gen_e_acsl_assert_data_6);
            __e_acsl_assert_clean(& __gen_e_acsl_assert_data_6);
            if (*(__gen_e_acsl_at_5 + ((__gen_e_acsl_u_6 - 9) * 11 + (
                                       __gen_e_acsl_v_4 - -4)))) ;
            else {
              __gen_e_acsl_forall = 0;
              goto e_acsl_end_loop3;
            }
          }
          __gen_e_acsl_v_4 ++;
        }
        e_acsl_end_loop3: ;
        if (! __gen_e_acsl_forall) ;
        else {
          __gen_e_acsl_exists_2 = 1;
          goto e_acsl_end_loop4;
        }
      }
      __gen_e_acsl_u_6 ++;
    }
    e_acsl_end_loop4: ;
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,
                                 "\\exists integer u;\n  9 <= u < 21 &&\n  (\\forall integer v; -5 < v <= 6 ==> \\at((u > 0? n + k: u + v) > 0,K))",
                                 0,__gen_e_acsl_exists_2);
    __gen_e_acsl_assert_data_5.blocking = 1;
    __gen_e_acsl_assert_data_5.kind = "Assertion";
    __gen_e_acsl_assert_data_5.pred_txt = "\\let k = -7;\n\\exists integer u;\n  9 <= u < 21 &&\n  (\\forall integer v; -5 < v <= 6 ==> \\at((u > 0? n + k: u + v) > 0,K))";
    __gen_e_acsl_assert_data_5.file = "at_on-purely-logic-variables.c";
    __gen_e_acsl_assert_data_5.fct = "main";
    __gen_e_acsl_assert_data_5.line = 31;
    __e_acsl_assert(__gen_e_acsl_exists_2,& __gen_e_acsl_assert_data_5);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_5);
  }
  /*@
  assert \let k = -7;
  \exists integer u;
    9 <= u < 21 &&
    (\forall integer v; -5 < v <= 6 ==> \at((u > 0? n + k: u + v) > 0,K));
   */
  ;
  {
    int __gen_e_acsl_i_4;
    int __gen_e_acsl_valid_read_4;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_7 =
      {.values = (void *)0};
    __gen_e_acsl_i_4 = 3;
    __e_acsl_assert_register_long(& __gen_e_acsl_assert_data_7,
                                  "\\at(n + i,L)",0,*(__gen_e_acsl_at_2 + 0));
    __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,
                                 "__gen_e_acsl_at_2",
                                 (void *)__gen_e_acsl_at_2);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_8,
                                   "sizeof(long)",0,sizeof(long));
    __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_2 + 0),
                                                    sizeof(long),
                                                    (void *)__gen_e_acsl_at_2,
                                                    (void *)(& __gen_e_acsl_at_2));
    __gen_e_acsl_assert_data_8.blocking = 1;
    __gen_e_acsl_assert_data_8.kind = "RTE";
    __gen_e_acsl_assert_data_8.pred_txt = "\\valid_read(__gen_e_acsl_at_2 + 0)";
    __gen_e_acsl_assert_data_8.file = "at_on-purely-logic-variables.c";
    __gen_e_acsl_assert_data_8.fct = "main";
    __gen_e_acsl_assert_data_8.line = 38;
    __gen_e_acsl_assert_data_8.name = "mem_access";
    __e_acsl_assert(__gen_e_acsl_valid_read_4,& __gen_e_acsl_assert_data_8);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_8);
    __gen_e_acsl_assert_data_7.blocking = 1;
    __gen_e_acsl_assert_data_7.kind = "Assertion";
    __gen_e_acsl_assert_data_7.pred_txt = "\\let i = 3; \\at(n + i,L) == 10";
    __gen_e_acsl_assert_data_7.file = "at_on-purely-logic-variables.c";
    __gen_e_acsl_assert_data_7.fct = "main";
    __gen_e_acsl_assert_data_7.line = 38;
    __e_acsl_assert(*(__gen_e_acsl_at_2 + 0) == 10L,
                    & __gen_e_acsl_assert_data_7);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_7);
  }
  /*@ assert \let i = 3; \at(n + i,L) == 10; */ ;
  unsigned int m = (unsigned int)3;
  G:
  {
    int __gen_e_acsl_k_3;
    __gen_e_acsl_k_3 = -9 + 1;
    while (1) {
      if (__gen_e_acsl_k_3 < 0) ; else break;
      *(__gen_e_acsl_at_8 + (__gen_e_acsl_k_3 - -8)) = m + (long)__gen_e_acsl_k_3;
      __gen_e_acsl_k_3 ++;
    }
  }
  ;
  m = (unsigned int)(-3);
  {
    int __gen_e_acsl_exists_3;
    int __gen_e_acsl_k_4;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_9 =
      {.values = (void *)0};
    __gen_e_acsl_exists_3 = 0;
    __gen_e_acsl_k_4 = -9 + 1;
    while (1) {
      if (__gen_e_acsl_k_4 < 0) ; else break;
      {
        int __gen_e_acsl_valid_read_5;
        __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,
                                     "__gen_e_acsl_at_8",
                                     (void *)__gen_e_acsl_at_8);
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_10,
                                     "__gen_e_acsl_k_4",0,__gen_e_acsl_k_4);
        __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_10,
                                       "sizeof(long)",0,sizeof(long));
        __gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_8 + (int)(
                                                                 __gen_e_acsl_k_4 - -8L)),
                                                        sizeof(long),
                                                        (void *)__gen_e_acsl_at_8,
                                                        (void *)(& __gen_e_acsl_at_8));
        __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(__gen_e_acsl_at_8 + (int)(__gen_e_acsl_k_4 - -8))";
        __gen_e_acsl_assert_data_10.file = "at_on-purely-logic-variables.c";
        __gen_e_acsl_assert_data_10.fct = "main";
        __gen_e_acsl_assert_data_10.line = 42;
        __gen_e_acsl_assert_data_10.name = "mem_access";
        __e_acsl_assert(__gen_e_acsl_valid_read_5,
                        & __gen_e_acsl_assert_data_10);
        __e_acsl_assert_clean(& __gen_e_acsl_assert_data_10);
        if (! (*(__gen_e_acsl_at_8 + (__gen_e_acsl_k_4 - -8)) == 0L)) 
          ;
        else {
          __gen_e_acsl_exists_3 = 1;
          goto e_acsl_end_loop5;
        }
      }
      __gen_e_acsl_k_4 ++;
    }
    e_acsl_end_loop5: ;
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_9,
                                 "\\exists integer k; -9 < k < 0 && \\at(m + k,G) == 0",
                                 0,__gen_e_acsl_exists_3);
    __gen_e_acsl_assert_data_9.blocking = 1;
    __gen_e_acsl_assert_data_9.kind = "Assertion";
    __gen_e_acsl_assert_data_9.pred_txt = "\\exists integer k; -9 < k < 0 && \\at(m + k,G) == 0";
    __gen_e_acsl_assert_data_9.file = "at_on-purely-logic-variables.c";
    __gen_e_acsl_assert_data_9.fct = "main";
    __gen_e_acsl_assert_data_9.line = 42;
    __e_acsl_assert(__gen_e_acsl_exists_3,& __gen_e_acsl_assert_data_9);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_9);
  }
  /*@ assert \exists integer k; -9 < k < 0 && \at(m + k,G) == 0; */ ;
  {
    int __gen_e_acsl_exists_4;
    int __gen_e_acsl_u_7;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_11 =
      {.values = (void *)0};
    __gen_e_acsl_exists_4 = 0;
    __gen_e_acsl_u_7 = 9;
    while (1) {
      if (__gen_e_acsl_u_7 < 21) ; else break;
      {
        int __gen_e_acsl_forall_2;
        int __gen_e_acsl_v_5;
        __gen_e_acsl_forall_2 = 1;
        __gen_e_acsl_v_5 = -5 + 1;
        while (1) {
          {
            int __gen_e_acsl_if_3;
            if (__gen_e_acsl_u_7 < 15) __gen_e_acsl_if_3 = __gen_e_acsl_u_7 + 6;
            else __gen_e_acsl_if_3 = 3;
            if (__gen_e_acsl_v_5 <= __gen_e_acsl_if_3) ; else break;
          }
          {
            int __gen_e_acsl_valid_read_6;
            __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,
                                         "__gen_e_acsl_at_6",
                                         (void *)__gen_e_acsl_at_6);
            __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_12,
                                         "__gen_e_acsl_u_7",0,
                                         __gen_e_acsl_u_7);
            __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_12,
                                         "__gen_e_acsl_v_5",0,
                                         __gen_e_acsl_v_5);
            __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_12,
                                           "sizeof(long)",0,sizeof(long));
            __gen_e_acsl_valid_read_6 = __e_acsl_valid_read((void *)(
                                                            __gen_e_acsl_at_6 + (int)(
                                                            (long)((int)(
                                                            (long)((int)(
                                                            __gen_e_acsl_u_7 - 9L)) * 32L)) + (int)(
                                                            __gen_e_acsl_v_5 - -4L))),
                                                            sizeof(long),
                                                            (void *)__gen_e_acsl_at_6,
                                                            (void *)(& __gen_e_acsl_at_6));
            __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(__gen_e_acsl_at_6 +\n            (int)((int)((int)(__gen_e_acsl_u_7 - 9) * 32) +\n                  (int)(__gen_e_acsl_v_5 - -4)))";
            __gen_e_acsl_assert_data_12.file = "at_on-purely-logic-variables.c";
            __gen_e_acsl_assert_data_12.fct = "main";
            __gen_e_acsl_assert_data_12.line = 46;
            __gen_e_acsl_assert_data_12.name = "mem_access";
            __e_acsl_assert(__gen_e_acsl_valid_read_6,
                            & __gen_e_acsl_assert_data_12);
            __e_acsl_assert_clean(& __gen_e_acsl_assert_data_12);
            /*@ assert
                Eva: initialization:
                  \initialized(__gen_e_acsl_at_6 +
                               (int)((int)((int)(__gen_e_acsl_u_7 - 9) * 32)
                                     + (int)(__gen_e_acsl_v_5 - -4)));
            */
            if (*(__gen_e_acsl_at_6 + ((__gen_e_acsl_u_7 - 9) * 32 + (
                                       __gen_e_acsl_v_5 - -4))) > 0L) 
              ;
            else {
              __gen_e_acsl_forall_2 = 0;
              goto e_acsl_end_loop6;
            }
          }
          __gen_e_acsl_v_5 ++;
        }
        e_acsl_end_loop6: ;
        if (! __gen_e_acsl_forall_2) ;
        else {
          __gen_e_acsl_exists_4 = 1;
          goto e_acsl_end_loop7;
        }
      }
      __gen_e_acsl_u_7 ++;
    }
    e_acsl_end_loop7: ;
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_11,
                                 "\\exists integer u;\n  9 <= u < 21 &&\n  (\\forall integer v; -5 < v <= (u < 15? u + 6: 3) ==> \\at((n + u) + v,K) > 0)",
                                 0,__gen_e_acsl_exists_4);
    __gen_e_acsl_assert_data_11.blocking = 1;
    __gen_e_acsl_assert_data_11.kind = "Assertion";
    __gen_e_acsl_assert_data_11.pred_txt = "\\exists integer u;\n  9 <= u < 21 &&\n  (\\forall integer v; -5 < v <= (u < 15? u + 6: 3) ==> \\at((n + u) + v,K) > 0)";
    __gen_e_acsl_assert_data_11.file = "at_on-purely-logic-variables.c";
    __gen_e_acsl_assert_data_11.fct = "main";
    __gen_e_acsl_assert_data_11.line = 44;
    __e_acsl_assert(__gen_e_acsl_exists_4,& __gen_e_acsl_assert_data_11);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_11);
  }
  /*@
  assert
  \exists integer u;
    9 <= u < 21 &&
    (\forall integer v;
       -5 < v <= (u < 15? u + 6: 3) ==> \at((n + u) + v,K) > 0);
   */
  ;
  int t[5] = {9, 12, 12, 12, -4};
  __e_acsl_store_block((void *)(t),20UL);
  __e_acsl_full_init((void *)(& t));
  __gen_e_acsl_f(t);
  g();
  {
    int __gen_e_acsl_exists_5;
    int __gen_e_acsl_u_8;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_13 =
      {.values = (void *)0};
    __gen_e_acsl_exists_5 = 0;
    __gen_e_acsl_u_8 = 10;
    while (1) {
      if (__gen_e_acsl_u_8 < 20) ; else break;
      {
        int __gen_e_acsl_exists_6;
        int __gen_e_acsl_v_6;
        __gen_e_acsl_exists_6 = 0;
        __gen_e_acsl_v_6 = -10 + 1;
        while (1) {
          {
            int __gen_e_acsl_u_9;
            __gen_e_acsl_u_9 = -2;
            if (__gen_e_acsl_v_6 <= -5 + __gen_e_acsl_u_9) ; else break;
          }
          {
            int __gen_e_acsl_exists_7;
            int __gen_e_acsl_w_2;
            __gen_e_acsl_exists_7 = 0;
            __gen_e_acsl_w_2 = 100 + 1;
            while (1) {
              if (__gen_e_acsl_w_2 <= 200) ; else break;
              {
                int __gen_e_acsl_valid_read_7;
                __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,
                                             "__gen_e_acsl_at_7",
                                             (void *)__gen_e_acsl_at_7);
                __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,
                                             "__gen_e_acsl_u_8",0,
                                             __gen_e_acsl_u_8);
                __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,
                                             "__gen_e_acsl_v_6",0,
                                             __gen_e_acsl_v_6);
                __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,
                                             "__gen_e_acsl_w_2",0,
                                             __gen_e_acsl_w_2);
                __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_14,
                                               "sizeof(int)",0,sizeof(int));
                __gen_e_acsl_valid_read_7 = __e_acsl_valid_read((void *)(
                                                                __gen_e_acsl_at_7 + (int)(
                                                                (long)((int)(
                                                                (long)((int)(
                                                                __gen_e_acsl_u_8 - 10L)) * 300L)) + (int)(
                                                                (long)((int)(
                                                                (long)((int)(
                                                                __gen_e_acsl_v_6 - -9L)) * 100L)) + (int)(
                                                                __gen_e_acsl_w_2 - 101L)))),
                                                                sizeof(int),
                                                                (void *)__gen_e_acsl_at_7,
                                                                (void *)(& __gen_e_acsl_at_7));
                __gen_e_acsl_assert_data_14.blocking = 1;
                __gen_e_acsl_assert_data_14.kind = "RTE";
                __gen_e_acsl_assert_data_14.pred_txt = "\\valid_read(__gen_e_acsl_at_7 +\n            (int)((int)((int)(__gen_e_acsl_u_8 - 10) * 300) +\n                  (int)((int)((int)(__gen_e_acsl_v_6 - -9) * 100) +\n                        (int)(__gen_e_acsl_w_2 - 101))))";
                __gen_e_acsl_assert_data_14.file = "at_on-purely-logic-variables.c";
                __gen_e_acsl_assert_data_14.fct = "main";
                __gen_e_acsl_assert_data_14.line = 59;
                __gen_e_acsl_assert_data_14.name = "mem_access";
                __e_acsl_assert(__gen_e_acsl_valid_read_7,
                                & __gen_e_acsl_assert_data_14);
                __e_acsl_assert_clean(& __gen_e_acsl_assert_data_14);
                if (! *(__gen_e_acsl_at_7 + ((__gen_e_acsl_u_8 - 10) * 300 + (
                                             (__gen_e_acsl_v_6 - -9) * 100 + (
                                             __gen_e_acsl_w_2 - 101))))) 
                  ;
                else {
                  __gen_e_acsl_exists_7 = 1;
                  goto e_acsl_end_loop8;
                }
              }
              __gen_e_acsl_w_2 ++;
            }
            e_acsl_end_loop8: ;
            if (! __gen_e_acsl_exists_7) ;
            else {
              __gen_e_acsl_exists_6 = 1;
              goto e_acsl_end_loop9;
            }
          }
          __gen_e_acsl_v_6 ++;
        }
        e_acsl_end_loop9: ;
        if (! __gen_e_acsl_exists_6) ;
        else {
          __gen_e_acsl_exists_5 = 1;
          goto e_acsl_end_loop10;
        }
      }
      __gen_e_acsl_u_8 ++;
    }
    e_acsl_end_loop10: ;
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_13,
                                 "\\exists integer u;\n  10 <= u < 20 &&\n  (\\exists integer v;\n     -10 < v <= -5 + (\\let u = -2; u) &&\n     (\\exists integer w;\n        100 < w <= 200 && \\at((((n - u) + (\\let u = 42; u)) + v) + w > 0,K)))",
                                 0,__gen_e_acsl_exists_5);
    __gen_e_acsl_assert_data_13.blocking = 1;
    __gen_e_acsl_assert_data_13.kind = "Assertion";
    __gen_e_acsl_assert_data_13.pred_txt = "\\exists integer u;\n  10 <= u < 20 &&\n  (\\exists integer v;\n     -10 < v <= -5 + (\\let u = -2; u) &&\n     (\\exists integer w;\n        100 < w <= 200 && \\at((((n - u) + (\\let u = 42; u)) + v) + w > 0,K)))";
    __gen_e_acsl_assert_data_13.file = "at_on-purely-logic-variables.c";
    __gen_e_acsl_assert_data_13.fct = "main";
    __gen_e_acsl_assert_data_13.line = 56;
    __e_acsl_assert(__gen_e_acsl_exists_5,& __gen_e_acsl_assert_data_13);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_13);
  }
  /*@
  assert
  \exists integer u;
    10 <= u < 20 &&
    (\exists integer v;
       -10 < v <= -5 + (\let u = -2; u) &&
       (\exists integer w;
          100 < w <= 200 && \at((((n - u) + (\let u = 42; u)) + v) + w > 0,K)));
   */
  ;
  /*@
  assert \exists integer j; 2 <= j < 10000000000000000 && \at(n + j == 11,L);
   */
  ;
  /*@ assert \let i = n; \at(n + i == 10,L); */ ;
  __retres = 0;
  __e_acsl_delete_block((void *)(t));
  __e_acsl_delete_block((void *)(& n));
  free((void *)__gen_e_acsl_at);
  free((void *)__gen_e_acsl_at_2);
  free((void *)__gen_e_acsl_at_3);
  free((void *)__gen_e_acsl_at_5);
  free((void *)__gen_e_acsl_at_6);
  free((void *)__gen_e_acsl_at_7);
  free((void *)__gen_e_acsl_at_8);
  __e_acsl_memory_clean();
  return __retres;
}

/*@ ensures
      \forall integer n;
        1 < n <= 3 ==> \old(*(t + n) == 12) && \old(*(t + (n - 1)) > 5);
    ensures \let m = 4; \old(*(t + m) == -4) && \old(*(t + (m - 4))) == 9;
 */
void __gen_e_acsl_f(int *t)
{
  int *__gen_e_acsl_at_4;
  int *__gen_e_acsl_at_3;
  int *__gen_e_acsl_at_2;
  int *__gen_e_acsl_at;
  __gen_e_acsl_at_4 = (int *)malloc(8UL);
  __gen_e_acsl_at_3 = (int *)malloc(8UL);
  __gen_e_acsl_at_2 = (int *)malloc(4UL);
  __gen_e_acsl_at = (int *)malloc(4UL);
  __e_acsl_store_block((void *)(& t),8UL);
  {
    int __gen_e_acsl_m;
    __gen_e_acsl_m = 4;
    {
      int __gen_e_acsl_valid_read;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"t",(void *)t);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
                                   "__gen_e_acsl_m",0,__gen_e_acsl_m);
      __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data,
                                     "sizeof(int)",0,sizeof(int));
      __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(t + __gen_e_acsl_m),
                                                    sizeof(int),(void *)t,
                                                    (void *)(& t));
      __gen_e_acsl_assert_data.blocking = 1;
      __gen_e_acsl_assert_data.kind = "RTE";
      __gen_e_acsl_assert_data.pred_txt = "\\valid_read(t + __gen_e_acsl_m)";
      __gen_e_acsl_assert_data.file = "at_on-purely-logic-variables.c";
      __gen_e_acsl_assert_data.fct = "f";
      __gen_e_acsl_assert_data.line = 8;
      __gen_e_acsl_assert_data.name = "mem_access";
      __e_acsl_assert(__gen_e_acsl_valid_read,& __gen_e_acsl_assert_data);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
      *(__gen_e_acsl_at + 0) = *(t + __gen_e_acsl_m) == -4;
    }
  }
  {
    int __gen_e_acsl_m_2;
    __gen_e_acsl_m_2 = 4;
    {
      int __gen_e_acsl_valid_read_2;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_2,"t",
                                   (void *)t);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,
                                   "__gen_e_acsl_m_2",0,__gen_e_acsl_m_2);
      __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_2,
                                     "sizeof(int)",0,sizeof(int));
      __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(t + (int)(
                                                               __gen_e_acsl_m_2 - 4L)),
                                                      sizeof(int),(void *)t,
                                                      (void *)(& t));
      __gen_e_acsl_assert_data_2.blocking = 1;
      __gen_e_acsl_assert_data_2.kind = "RTE";
      __gen_e_acsl_assert_data_2.pred_txt = "\\valid_read(t + (int)(__gen_e_acsl_m_2 - 4))";
      __gen_e_acsl_assert_data_2.file = "at_on-purely-logic-variables.c";
      __gen_e_acsl_assert_data_2.fct = "f";
      __gen_e_acsl_assert_data_2.line = 8;
      __gen_e_acsl_assert_data_2.name = "mem_access";
      __e_acsl_assert(__gen_e_acsl_valid_read_2,& __gen_e_acsl_assert_data_2);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
      *(__gen_e_acsl_at_2 + 0) = *(t + (__gen_e_acsl_m_2 - 4));
    }
  }
  {
    int __gen_e_acsl_n;
    __gen_e_acsl_n = 1 + 1;
    while (1) {
      if (__gen_e_acsl_n <= 3) ; else break;
      {
        int __gen_e_acsl_valid_read_3;
        __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,"t",
                                     (void *)t);
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
                                     "__gen_e_acsl_n",0,__gen_e_acsl_n);
        __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_3,
                                       "sizeof(int)",0,sizeof(int));
        __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(t + (int)(
                                                                 __gen_e_acsl_n - 1L)),
                                                        sizeof(int),
                                                        (void *)t,
                                                        (void *)(& t));
        __gen_e_acsl_assert_data_3.blocking = 1;
        __gen_e_acsl_assert_data_3.kind = "RTE";
        __gen_e_acsl_assert_data_3.pred_txt = "\\valid_read(t + (int)(__gen_e_acsl_n - 1))";
        __gen_e_acsl_assert_data_3.file = "at_on-purely-logic-variables.c";
        __gen_e_acsl_assert_data_3.fct = "f";
        __gen_e_acsl_assert_data_3.line = 7;
        __gen_e_acsl_assert_data_3.name = "mem_access";
        __e_acsl_assert(__gen_e_acsl_valid_read_3,
                        & __gen_e_acsl_assert_data_3);
        __e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
        *(__gen_e_acsl_at_3 + (__gen_e_acsl_n - 2)) = *(t + (__gen_e_acsl_n - 1)) > 5;
      }
      __gen_e_acsl_n ++;
    }
  }
  {
    int __gen_e_acsl_n_2;
    __gen_e_acsl_n_2 = 1 + 1;
    while (1) {
      if (__gen_e_acsl_n_2 <= 3) ; else break;
      {
        int __gen_e_acsl_valid_read_4;
        __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,"t",
                                     (void *)t);
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,
                                     "__gen_e_acsl_n_2",0,__gen_e_acsl_n_2);
        __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_4,
                                       "sizeof(int)",0,sizeof(int));
        __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(t + __gen_e_acsl_n_2),
                                                        sizeof(int),
                                                        (void *)t,
                                                        (void *)(& t));
        __gen_e_acsl_assert_data_4.blocking = 1;
        __gen_e_acsl_assert_data_4.kind = "RTE";
        __gen_e_acsl_assert_data_4.pred_txt = "\\valid_read(t + __gen_e_acsl_n_2)";
        __gen_e_acsl_assert_data_4.file = "at_on-purely-logic-variables.c";
        __gen_e_acsl_assert_data_4.fct = "f";
        __gen_e_acsl_assert_data_4.line = 7;
        __gen_e_acsl_assert_data_4.name = "mem_access";
        __e_acsl_assert(__gen_e_acsl_valid_read_4,
                        & __gen_e_acsl_assert_data_4);
        __e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
        *(__gen_e_acsl_at_4 + (__gen_e_acsl_n_2 - 2)) = *(t + __gen_e_acsl_n_2) == 12;
      }
      __gen_e_acsl_n_2 ++;
    }
  }
  f(t);
  {
    int __gen_e_acsl_forall;
    int __gen_e_acsl_n_3;
    int __gen_e_acsl_m_3;
    int __gen_e_acsl_valid_read_7;
    int __gen_e_acsl_and_2;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_5 =
      {.values = (void *)0};
    __gen_e_acsl_forall = 1;
    __gen_e_acsl_n_3 = 1 + 1;
    while (1) {
      if (__gen_e_acsl_n_3 <= 3) ; else break;
      {
        int __gen_e_acsl_valid_read_5;
        int __gen_e_acsl_and;
        __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,
                                     "__gen_e_acsl_at_4",
                                     (void *)__gen_e_acsl_at_4);
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
                                     "__gen_e_acsl_n_3",0,__gen_e_acsl_n_3);
        __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_6,
                                       "sizeof(int)",0,sizeof(int));
        __gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_4 + (int)(
                                                                 __gen_e_acsl_n_3 - 2L)),
                                                        sizeof(int),
                                                        (void *)__gen_e_acsl_at_4,
                                                        (void *)(& __gen_e_acsl_at_4));
        __gen_e_acsl_assert_data_6.blocking = 1;
        __gen_e_acsl_assert_data_6.kind = "RTE";
        __gen_e_acsl_assert_data_6.pred_txt = "\\valid_read(__gen_e_acsl_at_4 + (int)(__gen_e_acsl_n_3 - 2))";
        __gen_e_acsl_assert_data_6.file = "at_on-purely-logic-variables.c";
        __gen_e_acsl_assert_data_6.fct = "f";
        __gen_e_acsl_assert_data_6.line = 7;
        __gen_e_acsl_assert_data_6.name = "mem_access";
        __e_acsl_assert(__gen_e_acsl_valid_read_5,
                        & __gen_e_acsl_assert_data_6);
        __e_acsl_assert_clean(& __gen_e_acsl_assert_data_6);
        if (*(__gen_e_acsl_at_4 + (__gen_e_acsl_n_3 - 2))) {
          int __gen_e_acsl_valid_read_6;
          __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,
                                       "__gen_e_acsl_at_3",
                                       (void *)__gen_e_acsl_at_3);
          __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,
                                       "__gen_e_acsl_n_3",0,__gen_e_acsl_n_3);
          __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_7,
                                         "sizeof(int)",0,sizeof(int));
          __gen_e_acsl_valid_read_6 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_3 + (int)(
                                                                   __gen_e_acsl_n_3 - 2L)),
                                                          sizeof(int),
                                                          (void *)__gen_e_acsl_at_3,
                                                          (void *)(& __gen_e_acsl_at_3));
          __gen_e_acsl_assert_data_7.blocking = 1;
          __gen_e_acsl_assert_data_7.kind = "RTE";
          __gen_e_acsl_assert_data_7.pred_txt = "\\valid_read(__gen_e_acsl_at_3 + (int)(__gen_e_acsl_n_3 - 2))";
          __gen_e_acsl_assert_data_7.file = "at_on-purely-logic-variables.c";
          __gen_e_acsl_assert_data_7.fct = "f";
          __gen_e_acsl_assert_data_7.line = 7;
          __gen_e_acsl_assert_data_7.name = "mem_access";
          __e_acsl_assert(__gen_e_acsl_valid_read_6,
                          & __gen_e_acsl_assert_data_7);
          __e_acsl_assert_clean(& __gen_e_acsl_assert_data_7);
          __gen_e_acsl_and = *(__gen_e_acsl_at_3 + (__gen_e_acsl_n_3 - 2));
        }
        else __gen_e_acsl_and = 0;
        if (__gen_e_acsl_and) ;
        else {
          __gen_e_acsl_forall = 0;
          goto e_acsl_end_loop11;
        }
      }
      __gen_e_acsl_n_3 ++;
    }
    e_acsl_end_loop11: ;
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,
                                 "\\forall integer n;\n  1 < n <= 3 ==> \\old(*(t + n) == 12) && \\old(*(t + (n - 1)) > 5)",
                                 0,__gen_e_acsl_forall);
    __gen_e_acsl_assert_data_5.blocking = 1;
    __gen_e_acsl_assert_data_5.kind = "Postcondition";
    __gen_e_acsl_assert_data_5.pred_txt = "\\forall integer n;\n  1 < n <= 3 ==> \\old(*(t + n) == 12) && \\old(*(t + (n - 1)) > 5)";
    __gen_e_acsl_assert_data_5.file = "at_on-purely-logic-variables.c";
    __gen_e_acsl_assert_data_5.fct = "f";
    __gen_e_acsl_assert_data_5.line = 6;
    __e_acsl_assert(__gen_e_acsl_forall,& __gen_e_acsl_assert_data_5);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_5);
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_8 =
      {.values = (void *)0};
    __gen_e_acsl_m_3 = 4;
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,
                                 "\\old(*(t + m) == -4)",0,
                                 *(__gen_e_acsl_at + 0));
    __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,
                                 "__gen_e_acsl_at",(void *)__gen_e_acsl_at);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_9,
                                   "sizeof(int)",0,sizeof(int));
    __gen_e_acsl_valid_read_7 = __e_acsl_valid_read((void *)(__gen_e_acsl_at + 0),
                                                    sizeof(int),
                                                    (void *)__gen_e_acsl_at,
                                                    (void *)(& __gen_e_acsl_at));
    __gen_e_acsl_assert_data_9.blocking = 1;
    __gen_e_acsl_assert_data_9.kind = "RTE";
    __gen_e_acsl_assert_data_9.pred_txt = "\\valid_read(__gen_e_acsl_at + 0)";
    __gen_e_acsl_assert_data_9.file = "at_on-purely-logic-variables.c";
    __gen_e_acsl_assert_data_9.fct = "f";
    __gen_e_acsl_assert_data_9.line = 8;
    __gen_e_acsl_assert_data_9.name = "mem_access";
    __e_acsl_assert(__gen_e_acsl_valid_read_7,& __gen_e_acsl_assert_data_9);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_9);
    if (*(__gen_e_acsl_at + 0)) {
      int __gen_e_acsl_valid_read_8;
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,
                                   "\\old(*(t + (m - 4)))",0,
                                   *(__gen_e_acsl_at_2 + 0));
      __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,
                                   "__gen_e_acsl_at_2",
                                   (void *)__gen_e_acsl_at_2);
      __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_10,
                                     "sizeof(int)",0,sizeof(int));
      __gen_e_acsl_valid_read_8 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_2 + 0),
                                                      sizeof(int),
                                                      (void *)__gen_e_acsl_at_2,
                                                      (void *)(& __gen_e_acsl_at_2));
      __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(__gen_e_acsl_at_2 + 0)";
      __gen_e_acsl_assert_data_10.file = "at_on-purely-logic-variables.c";
      __gen_e_acsl_assert_data_10.fct = "f";
      __gen_e_acsl_assert_data_10.line = 8;
      __gen_e_acsl_assert_data_10.name = "mem_access";
      __e_acsl_assert(__gen_e_acsl_valid_read_8,
                      & __gen_e_acsl_assert_data_10);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_10);
      __gen_e_acsl_and_2 = *(__gen_e_acsl_at_2 + 0) == 9;
    }
    else __gen_e_acsl_and_2 = 0;
    __gen_e_acsl_assert_data_8.blocking = 1;
    __gen_e_acsl_assert_data_8.kind = "Postcondition";
    __gen_e_acsl_assert_data_8.pred_txt = "\\let m = 4; \\old(*(t + m) == -4) && \\old(*(t + (m - 4))) == 9";
    __gen_e_acsl_assert_data_8.file = "at_on-purely-logic-variables.c";
    __gen_e_acsl_assert_data_8.fct = "f";
    __gen_e_acsl_assert_data_8.line = 8;
    __e_acsl_assert(__gen_e_acsl_and_2,& __gen_e_acsl_assert_data_8);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_8);
    __e_acsl_delete_block((void *)(& t));
    free((void *)__gen_e_acsl_at);
    free((void *)__gen_e_acsl_at_2);
    free((void *)__gen_e_acsl_at_3);
    free((void *)__gen_e_acsl_at_4);
    return;
  }
}


