/* Generated by Frama-C */
#include "stddef.h"
#include "stdio.h"
extern int __e_acsl_sound_verdict;

/*@ ensures
      ∀ ℤ 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),(size_t)8);
  __e_acsl_delete_block((void *)(& t));
  return;
}

void g(void)
{
  int *__gen_e_acsl_at;
  int m;
  __gen_e_acsl_at = (int *)malloc((size_t)12);
  m = 8;
  Q:
  {
    {
      int __gen_e_acsl_w_2;
      __gen_e_acsl_w_2 = 3;
      while (1) {
        if (__gen_e_acsl_w_2 < 6) ; else break;
        *(__gen_e_acsl_at + (__gen_e_acsl_w_2 - 3)) = m + (long)__gen_e_acsl_w_2 == 12L;
        __gen_e_acsl_w_2 ++;
      }
    }
    ;
  }
  m = 10;
  {
    int __gen_e_acsl_exists;
    int __gen_e_acsl_w;
    __gen_e_acsl_exists = 0;
    __gen_e_acsl_w = 3;
    while (1) {
      if (__gen_e_acsl_w < 6) ; else break;
      {
        int __gen_e_acsl_valid_read;
        __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(__gen_e_acsl_at + (int)(
                                                               __gen_e_acsl_w - 3L)),
                                                      sizeof(int),
                                                      (void *)__gen_e_acsl_at,
                                                      (void *)(& __gen_e_acsl_at));
        __e_acsl_assert(__gen_e_acsl_valid_read,"RTE","g",
                        "mem_access: \\valid_read(__gen_e_acsl_at + (int)(__gen_e_acsl_w - 3))",
                        "tests/arith/at_on-purely-logic-variables.c",16);
        /*@ assert
            Eva: initialization:
              \initialized(__gen_e_acsl_at + (int)(__gen_e_acsl_w - 3));
        */
        if (! *(__gen_e_acsl_at + (__gen_e_acsl_w - 3))) ;
        else {
          __gen_e_acsl_exists = 1;
          goto e_acsl_end_loop1;
        }
      }
      __gen_e_acsl_w ++;
    }
    e_acsl_end_loop1: ;
    __e_acsl_assert(__gen_e_acsl_exists,"Assertion","g",
                    "\\exists integer w; 3 <= w < 6 && \\at(m + w == 12,Q)",
                    "tests/arith/at_on-purely-logic-variables.c",16);
  }
  /*@ assert ∃ ℤ w; 3 ≤ w < 6 ∧ \at(m + w ≡ 12,Q); */ ;
  free((void *)__gen_e_acsl_at);
  return;
}

int main(void)
{
  int *__gen_e_acsl_at_7;
  int *__gen_e_acsl_at_6;
  long *__gen_e_acsl_at_5;
  long *__gen_e_acsl_at_4;
  int *__gen_e_acsl_at_3;
  int *__gen_e_acsl_at_2;
  int *__gen_e_acsl_at;
  int __retres;
  int n;
  __e_acsl_memory_init((int *)0,(char ***)0,(size_t)8);
  __gen_e_acsl_at_7 = (int *)malloc((size_t)12000);
  __gen_e_acsl_at_6 = (int *)malloc((size_t)1536);
  __gen_e_acsl_at_5 = (long *)malloc((size_t)64);
  __gen_e_acsl_at_4 = (long *)malloc((size_t)8);
  __gen_e_acsl_at_3 = (int *)malloc((size_t)528);
  __gen_e_acsl_at_2 = (int *)malloc((size_t)12);
  __gen_e_acsl_at = (int *)malloc((size_t)4);
  __e_acsl_store_block((void *)(& n),(size_t)4);
  __e_acsl_full_init((void *)(& n));
  n = 7;
  L:
  {
    {
      int __gen_e_acsl_i_4;
      __gen_e_acsl_i_4 = 3;
      *(__gen_e_acsl_at_4 + 0) = n + (long)__gen_e_acsl_i_4;
    }
    {
      int __gen_e_acsl_j_2;
      __gen_e_acsl_j_2 = 2;
      while (1) {
        if (__gen_e_acsl_j_2 < 5) ; else break;
        *(__gen_e_acsl_at_2 + (__gen_e_acsl_j_2 - 2)) = n + (long)__gen_e_acsl_j_2 == 11L;
        __gen_e_acsl_j_2 ++;
      }
    }
    {
      int __gen_e_acsl_i_2;
      __gen_e_acsl_i_2 = 3;
      *(__gen_e_acsl_at + 0) = n + (long)__gen_e_acsl_i_2 == 10L;
    }
    ;
  }
  __e_acsl_full_init((void *)(& n));
  n = 9;
  K:
  {
    {
      int __gen_e_acsl_u_6;
      int __gen_e_acsl_v_6;
      int __gen_e_acsl_w_2;
      __gen_e_acsl_u_6 = 10;
      while (1) {
        if (__gen_e_acsl_u_6 < 20) ; else break;
        __gen_e_acsl_v_6 = -10 + 1;
        while (1) {
          {
            int __gen_e_acsl_u_8;
            __gen_e_acsl_u_8 = -2;
            if (__gen_e_acsl_v_6 <= -5 + __gen_e_acsl_u_8) ; else break;
          }
          __gen_e_acsl_w_2 = 100 + 1;
          while (1) {
            if (__gen_e_acsl_w_2 <= 200) ; else break;
            {
              int __gen_e_acsl_u_7;
              __gen_e_acsl_u_7 = 42;
              *(__gen_e_acsl_at_7 + ((__gen_e_acsl_u_6 - 10) * 300 + (
                                     ((__gen_e_acsl_v_6 - -10) - 1) * 100 + (
                                     (__gen_e_acsl_w_2 - 100) - 1)))) = 
              (((n - (long)__gen_e_acsl_u_6) + __gen_e_acsl_u_7) + __gen_e_acsl_v_6) + __gen_e_acsl_w_2 > 0L;
            }
            __gen_e_acsl_w_2 ++;
          }
          __gen_e_acsl_v_6 ++;
        }
        __gen_e_acsl_u_6 ++;
      }
    }
    {
      int __gen_e_acsl_u_4;
      int __gen_e_acsl_v_4;
      __gen_e_acsl_u_4 = 9;
      while (1) {
        if (__gen_e_acsl_u_4 < 21) ; else break;
        __gen_e_acsl_v_4 = -5 + 1;
        while (1) {
          {
            int __gen_e_acsl_if_2;
            if (__gen_e_acsl_u_4 < 15) __gen_e_acsl_if_2 = __gen_e_acsl_u_4 + 6;
            else __gen_e_acsl_if_2 = 3;
            if (__gen_e_acsl_v_4 <= __gen_e_acsl_if_2) ; else break;
          }
          *(__gen_e_acsl_at_6 + ((__gen_e_acsl_u_4 - 9) * 32 + ((__gen_e_acsl_v_4 - -5) - 1))) = 
          (n + (long)__gen_e_acsl_u_4) + __gen_e_acsl_v_4 > 0L;
          __gen_e_acsl_v_4 ++;
        }
        __gen_e_acsl_u_4 ++;
      }
    }
    {
      int __gen_e_acsl_k_2;
      int __gen_e_acsl_u_2;
      int __gen_e_acsl_v_2;
      __gen_e_acsl_k_2 = -7;
      __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) {
          if (__gen_e_acsl_v_2 <= 6) ; else break;
          {
            long __gen_e_acsl_if;
            if (__gen_e_acsl_u_2 > 0) __gen_e_acsl_if = n + (long)__gen_e_acsl_k_2;
            else __gen_e_acsl_if = __gen_e_acsl_u_2 + __gen_e_acsl_v_2;
            *(__gen_e_acsl_at_3 + ((__gen_e_acsl_u_2 - 9) * 11 + ((__gen_e_acsl_v_2 - -5) - 1))) = 
            __gen_e_acsl_if > 0L;
          }
          __gen_e_acsl_v_2 ++;
        }
        __gen_e_acsl_u_2 ++;
      }
    }
    ;
  }
  __e_acsl_full_init((void *)(& n));
  n = 666;
  {
    int __gen_e_acsl_i;
    int __gen_e_acsl_valid_read;
    __gen_e_acsl_i = 3;
    __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));
    __e_acsl_assert(__gen_e_acsl_valid_read,"RTE","main",
                    "mem_access: \\valid_read(__gen_e_acsl_at + 0)",
                    "tests/arith/at_on-purely-logic-variables.c",28);
    __e_acsl_assert(*(__gen_e_acsl_at + 0),"Assertion","main",
                    "\\let i = 3; \\at(n + i == 10,L)",
                    "tests/arith/at_on-purely-logic-variables.c",28);
  }
  /*@ assert \let i = 3; \at(n + i ≡ 10,L); */ ;
  {
    int __gen_e_acsl_exists;
    int __gen_e_acsl_j;
    __gen_e_acsl_exists = 0;
    __gen_e_acsl_j = 2;
    while (1) {
      if (__gen_e_acsl_j < 5) ; else break;
      {
        int __gen_e_acsl_valid_read_2;
        __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_2 + (int)(
                                                                 __gen_e_acsl_j - 2L)),
                                                        sizeof(int),
                                                        (void *)__gen_e_acsl_at_2,
                                                        (void *)(& __gen_e_acsl_at_2));
        __e_acsl_assert(__gen_e_acsl_valid_read_2,"RTE","main",
                        "mem_access: \\valid_read(__gen_e_acsl_at_2 + (int)(__gen_e_acsl_j - 2))",
                        "tests/arith/at_on-purely-logic-variables.c",29);
        /*@ assert
            Eva: initialization:
              \initialized(__gen_e_acsl_at_2 + (int)(__gen_e_acsl_j - 2));
        */
        if (! *(__gen_e_acsl_at_2 + (__gen_e_acsl_j - 2))) ;
        else {
          __gen_e_acsl_exists = 1;
          goto e_acsl_end_loop2;
        }
      }
      __gen_e_acsl_j ++;
    }
    e_acsl_end_loop2: ;
    __e_acsl_assert(__gen_e_acsl_exists,"Assertion","main",
                    "\\exists integer j; 2 <= j < 5 && \\at(n + j == 11,L)",
                    "tests/arith/at_on-purely-logic-variables.c",29);
  }
  /*@ assert ∃ ℤ j; 2 ≤ j < 5 ∧ \at(n + j ≡ 11,L); */ ;
  {
    int __gen_e_acsl_k;
    int __gen_e_acsl_exists_2;
    int __gen_e_acsl_u;
    __gen_e_acsl_k = -7;
    __gen_e_acsl_exists_2 = 0;
    __gen_e_acsl_u = 9;
    while (1) {
      if (__gen_e_acsl_u < 21) ; else break;
      {
        int __gen_e_acsl_forall;
        int __gen_e_acsl_v;
        __gen_e_acsl_forall = 1;
        __gen_e_acsl_v = -5 + 1;
        while (1) {
          if (__gen_e_acsl_v <= 6) ; else break;
          {
            int __gen_e_acsl_valid_read_3;
            __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(
                                                            __gen_e_acsl_at_3 + (int)(
                                                            (long)((int)(
                                                            (long)((int)(
                                                            __gen_e_acsl_u - 9L)) * 11L)) + (int)(
                                                            (int)(__gen_e_acsl_v - -5L) - 1))),
                                                            sizeof(int),
                                                            (void *)__gen_e_acsl_at_3,
                                                            (void *)(& __gen_e_acsl_at_3));
            __e_acsl_assert(__gen_e_acsl_valid_read_3,"RTE","main",
                            "mem_access:\n  \\valid_read(__gen_e_acsl_at_3 +\n              (int)((int)((int)(__gen_e_acsl_u - 9) * 11) +\n                    (int)((int)(__gen_e_acsl_v - -5) - 1)))",
                            "tests/arith/at_on-purely-logic-variables.c",34);
            /*@ assert
                Eva: initialization:
                  \initialized(__gen_e_acsl_at_3 +
                               (int)((int)((int)(__gen_e_acsl_u - 9) * 11) +
                                     (int)((int)(__gen_e_acsl_v - -5) - 1)));
            */
            if (*(__gen_e_acsl_at_3 + ((__gen_e_acsl_u - 9) * 11 + ((
                                                                    __gen_e_acsl_v - -5) - 1)))) 
              ;
            else {
              __gen_e_acsl_forall = 0;
              goto e_acsl_end_loop3;
            }
          }
          __gen_e_acsl_v ++;
        }
        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 ++;
    }
    e_acsl_end_loop4: ;
    __e_acsl_assert(__gen_e_acsl_exists_2,"Assertion","main",
                    "\\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))",
                    "tests/arith/at_on-purely-logic-variables.c",31);
  }
  /*@
  assert \let k = -7;
  ∃ ℤ u;
    9 ≤ u < 21 ∧
    (∀ ℤ v; -5 < v ≤ 6 ⇒ \at((u > 0? n + k: u + v) > 0,K));
   */
  ;
  {
    int __gen_e_acsl_i_3;
    int __gen_e_acsl_valid_read_4;
    __gen_e_acsl_i_3 = 3;
    __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_4 + 0),
                                                    sizeof(long),
                                                    (void *)__gen_e_acsl_at_4,
                                                    (void *)(& __gen_e_acsl_at_4));
    __e_acsl_assert(__gen_e_acsl_valid_read_4,"RTE","main",
                    "mem_access: \\valid_read(__gen_e_acsl_at_4 + 0)",
                    "tests/arith/at_on-purely-logic-variables.c",37);
    __e_acsl_assert(*(__gen_e_acsl_at_4 + 0) == 10L,"Assertion","main",
                    "\\let i = 3; \\at(n + i,L) == 10",
                    "tests/arith/at_on-purely-logic-variables.c",37);
  }
  /*@ assert \let i = 3; \at(n + i,L) ≡ 10; */ ;
  unsigned int m = (unsigned int)3;
  G:
  {
    {
      int __gen_e_acsl_k_4;
      __gen_e_acsl_k_4 = -9 + 1;
      while (1) {
        if (__gen_e_acsl_k_4 < 0) ; else break;
        *(__gen_e_acsl_at_5 + ((__gen_e_acsl_k_4 - -9) - 1)) = m + (long)__gen_e_acsl_k_4;
        __gen_e_acsl_k_4 ++;
      }
    }
    ;
  }
  m = (unsigned int)(-3);
  {
    int __gen_e_acsl_exists_3;
    int __gen_e_acsl_k_3;
    __gen_e_acsl_exists_3 = 0;
    __gen_e_acsl_k_3 = -9 + 1;
    while (1) {
      if (__gen_e_acsl_k_3 < 0) ; else break;
      {
        int __gen_e_acsl_valid_read_5;
        __gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_5 + (
                                                                 (int)(
                                                                 __gen_e_acsl_k_3 - -9L) - 1)),
                                                        sizeof(long),
                                                        (void *)__gen_e_acsl_at_5,
                                                        (void *)(& __gen_e_acsl_at_5));
        __e_acsl_assert(__gen_e_acsl_valid_read_5,"RTE","main",
                        "mem_access:\n  \\valid_read(__gen_e_acsl_at_5 + (int)((int)(__gen_e_acsl_k_3 - -9) - 1))",
                        "tests/arith/at_on-purely-logic-variables.c",41);
        /*@ assert
            Eva: initialization:
              \initialized(__gen_e_acsl_at_5 +
                           (int)((int)(__gen_e_acsl_k_3 - -9) - 1));
        */
        if (! (*(__gen_e_acsl_at_5 + ((__gen_e_acsl_k_3 - -9) - 1)) == 0L)) 
          ;
        else {
          __gen_e_acsl_exists_3 = 1;
          goto e_acsl_end_loop5;
        }
      }
      __gen_e_acsl_k_3 ++;
    }
    e_acsl_end_loop5: ;
    __e_acsl_assert(__gen_e_acsl_exists_3,"Assertion","main",
                    "\\exists integer k; -9 < k < 0 && \\at(m + k,G) == 0",
                    "tests/arith/at_on-purely-logic-variables.c",41);
  }
  /*@ assert ∃ ℤ k; -9 < k < 0 ∧ \at(m + k,G) ≡ 0; */ ;
  {
    int __gen_e_acsl_exists_4;
    int __gen_e_acsl_u_3;
    __gen_e_acsl_exists_4 = 0;
    __gen_e_acsl_u_3 = 9;
    while (1) {
      if (__gen_e_acsl_u_3 < 21) ; else break;
      {
        int __gen_e_acsl_forall_2;
        int __gen_e_acsl_v_3;
        __gen_e_acsl_forall_2 = 1;
        __gen_e_acsl_v_3 = -5 + 1;
        while (1) {
          {
            int __gen_e_acsl_if_3;
            if (__gen_e_acsl_u_3 < 15) __gen_e_acsl_if_3 = __gen_e_acsl_u_3 + 6;
            else __gen_e_acsl_if_3 = 3;
            if (__gen_e_acsl_v_3 <= __gen_e_acsl_if_3) ; else break;
          }
          {
            int __gen_e_acsl_valid_read_6;
            __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_3 - 9L)) * 32L)) + (int)(
                                                            (int)(__gen_e_acsl_v_3 - -5L) - 1))),
                                                            sizeof(int),
                                                            (void *)__gen_e_acsl_at_6,
                                                            (void *)(& __gen_e_acsl_at_6));
            __e_acsl_assert(__gen_e_acsl_valid_read_6,"RTE","main",
                            "mem_access:\n  \\valid_read(__gen_e_acsl_at_6 +\n              (int)((int)((int)(__gen_e_acsl_u_3 - 9) * 32) +\n                    (int)((int)(__gen_e_acsl_v_3 - -5) - 1)))",
                            "tests/arith/at_on-purely-logic-variables.c",45);
            /*@ assert
                Eva: initialization:
                  \initialized(__gen_e_acsl_at_6 +
                               (int)((int)((int)(__gen_e_acsl_u_3 - 9) * 32)
                                     +
                                     (int)((int)(__gen_e_acsl_v_3 - -5) - 1)));
            */
            if (*(__gen_e_acsl_at_6 + ((__gen_e_acsl_u_3 - 9) * 32 + (
                                       (__gen_e_acsl_v_3 - -5) - 1)))) 
              ;
            else {
              __gen_e_acsl_forall_2 = 0;
              goto e_acsl_end_loop6;
            }
          }
          __gen_e_acsl_v_3 ++;
        }
        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_3 ++;
    }
    e_acsl_end_loop7: ;
    __e_acsl_assert(__gen_e_acsl_exists_4,"Assertion","main",
                    "\\exists integer u;\n  9 <= u < 21 &&\n  (\\forall integer v; -5 < v <= (u < 15? u + 6: 3) ==> \\at((n + u) + v > 0,K))",
                    "tests/arith/at_on-purely-logic-variables.c",43);
  }
  /*@
  assert
  ∃ ℤ u;
    9 ≤ u < 21 ∧
    (∀ ℤ v; -5 < v ≤ (u < 15? u + 6: 3) ⇒ \at((n + u) + v > 0,K));
   */
  ;
  int t[5] = {9, 12, 12, 12, -4};
  __e_acsl_store_block((void *)(t),(size_t)20);
  __e_acsl_full_init((void *)(& t));
  __gen_e_acsl_f(t);
  g();
  {
    int __gen_e_acsl_exists_5;
    int __gen_e_acsl_u_5;
    __gen_e_acsl_exists_5 = 0;
    __gen_e_acsl_u_5 = 10;
    while (1) {
      if (__gen_e_acsl_u_5 < 20) ; else break;
      {
        int __gen_e_acsl_exists_6;
        int __gen_e_acsl_v_5;
        __gen_e_acsl_exists_6 = 0;
        __gen_e_acsl_v_5 = -10 + 1;
        while (1) {
          {
            int __gen_e_acsl_u_9;
            __gen_e_acsl_u_9 = -2;
            if (__gen_e_acsl_v_5 <= -5 + __gen_e_acsl_u_9) ; else break;
          }
          {
            int __gen_e_acsl_exists_7;
            int __gen_e_acsl_w;
            __gen_e_acsl_exists_7 = 0;
            __gen_e_acsl_w = 100 + 1;
            while (1) {
              if (__gen_e_acsl_w <= 200) ; else break;
              {
                int __gen_e_acsl_valid_read_7;
                __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_5 - 10L)) * 300L)) + (int)(
                                                                (long)((int)(
                                                                (long)((int)(
                                                                (int)(
                                                                __gen_e_acsl_v_5 - -10L) - 1)) * 100L)) + (int)(
                                                                (long)((int)(
                                                                __gen_e_acsl_w - 100L)) - 1L)))),
                                                                sizeof(int),
                                                                (void *)__gen_e_acsl_at_7,
                                                                (void *)(& __gen_e_acsl_at_7));
                __e_acsl_assert(__gen_e_acsl_valid_read_7,"RTE","main",
                                "mem_access:\n  \\valid_read(__gen_e_acsl_at_7 +\n              (int)((int)((int)(__gen_e_acsl_u_5 - 10) * 300) +\n                    (int)((int)((int)((int)(__gen_e_acsl_v_5 - -10) - 1) *\n                                100)\n                          + (int)((int)(__gen_e_acsl_w - 100) - 1))))",
                                "tests/arith/at_on-purely-logic-variables.c",
                                57);
                /*@ assert
                    Eva: initialization:
                      \initialized(__gen_e_acsl_at_7 +
                                   (int)((int)((int)(__gen_e_acsl_u_5 - 10) *
                                               300)
                                         +
                                         (int)((int)((int)((int)(__gen_e_acsl_v_5
                                                                 - -10)
                                                           - 1)
                                                     * 100)
                                               +
                                               (int)((int)(__gen_e_acsl_w -
                                                           100)
                                                     - 1))));
                */
                if (! *(__gen_e_acsl_at_7 + ((__gen_e_acsl_u_5 - 10) * 300 + (
                                             ((__gen_e_acsl_v_5 - -10) - 1) * 100 + (
                                             (__gen_e_acsl_w - 100) - 1))))) 
                  ;
                else {
                  __gen_e_acsl_exists_7 = 1;
                  goto e_acsl_end_loop8;
                }
              }
              __gen_e_acsl_w ++;
            }
            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_5 ++;
        }
        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_5 ++;
    }
    e_acsl_end_loop10: ;
    __e_acsl_assert(__gen_e_acsl_exists_5,"Assertion","main",
                    "\\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)))",
                    "tests/arith/at_on-purely-logic-variables.c",54);
  }
  /*@
  assert
  ∃ ℤ u;
    10 ≤ u < 20 ∧
    (∃ ℤ v;
       -10 < v ≤ -5 + (\let u = -2; u) ∧
       (∃ ℤ w;
          100 < w ≤ 200 ∧
          \at((((n - u) + (\let u = 42; u)) + v) + w > 0,K)));
   */
  ;
  /*@ assert ∃ ℤ 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_4);
  free((void *)__gen_e_acsl_at_5);
  free((void *)__gen_e_acsl_at_6);
  free((void *)__gen_e_acsl_at_7);
  __e_acsl_memory_clean();
  return __retres;
}

/*@ ensures
      ∀ ℤ 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((size_t)4);
  __gen_e_acsl_at_3 = (int *)malloc((size_t)4);
  __gen_e_acsl_at_2 = (int *)malloc((size_t)8);
  __gen_e_acsl_at = (int *)malloc((size_t)8);
  __e_acsl_store_block((void *)(& t),(size_t)8);
  {
    int __gen_e_acsl_m_3;
    __gen_e_acsl_m_3 = 4;
    *(__gen_e_acsl_at_4 + 0) = *(t + (__gen_e_acsl_m_3 - 4));
  }
  {
    int __gen_e_acsl_m_2;
    __gen_e_acsl_m_2 = 4;
    *(__gen_e_acsl_at_3 + 0) = *(t + __gen_e_acsl_m_2) == -4;
  }
  {
    int __gen_e_acsl_n_3;
    __gen_e_acsl_n_3 = 1 + 1;
    while (1) {
      if (__gen_e_acsl_n_3 <= 3) ; else break;
      *(__gen_e_acsl_at_2 + ((__gen_e_acsl_n_3 - 1) - 1)) = *(t + (__gen_e_acsl_n_3 - 1)) > 5;
      __gen_e_acsl_n_3 ++;
    }
  }
  {
    int __gen_e_acsl_n_2;
    __gen_e_acsl_n_2 = 1 + 1;
    while (1) {
      if (__gen_e_acsl_n_2 <= 3) ; else break;
      *(__gen_e_acsl_at + ((__gen_e_acsl_n_2 - 1) - 1)) = *(t + __gen_e_acsl_n_2) == 12;
      __gen_e_acsl_n_2 ++;
    }
  }
  f(t);
  {
    int __gen_e_acsl_forall;
    int __gen_e_acsl_n;
    int __gen_e_acsl_m;
    int __gen_e_acsl_valid_read_3;
    int __gen_e_acsl_and_2;
    __gen_e_acsl_forall = 1;
    __gen_e_acsl_n = 1 + 1;
    while (1) {
      if (__gen_e_acsl_n <= 3) ; else break;
      {
        int __gen_e_acsl_valid_read;
        int __gen_e_acsl_and;
        __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(__gen_e_acsl_at + (int)(
                                                               (long)((int)(
                                                               __gen_e_acsl_n - 1L)) - 1L)),
                                                      sizeof(int),
                                                      (void *)__gen_e_acsl_at,
                                                      (void *)(& __gen_e_acsl_at));
        __e_acsl_assert(__gen_e_acsl_valid_read,"RTE","f",
                        "mem_access:\n  \\valid_read(__gen_e_acsl_at + (int)((int)(__gen_e_acsl_n - 1) - 1))",
                        "tests/arith/at_on-purely-logic-variables.c",7);
        /*@ assert
            Eva: initialization:
              \initialized(__gen_e_acsl_at +
                           (int)((int)(__gen_e_acsl_n - 1) - 1));
        */
        if (*(__gen_e_acsl_at + ((__gen_e_acsl_n - 1) - 1))) {
          int __gen_e_acsl_valid_read_2;
          __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_2 + (int)(
                                                                   (long)((int)(
                                                                   __gen_e_acsl_n - 1L)) - 1L)),
                                                          sizeof(int),
                                                          (void *)__gen_e_acsl_at_2,
                                                          (void *)(& __gen_e_acsl_at_2));
          __e_acsl_assert(__gen_e_acsl_valid_read_2,"RTE","f",
                          "mem_access:\n  \\valid_read(__gen_e_acsl_at_2 + (int)((int)(__gen_e_acsl_n - 1) - 1))",
                          "tests/arith/at_on-purely-logic-variables.c",7);
          /*@ assert
              Eva: initialization:
                \initialized(__gen_e_acsl_at_2 +
                             (int)((int)(__gen_e_acsl_n - 1) - 1));
          */
          __gen_e_acsl_and = *(__gen_e_acsl_at_2 + ((__gen_e_acsl_n - 1) - 1));
        }
        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 ++;
    }
    e_acsl_end_loop11: ;
    __e_acsl_assert(__gen_e_acsl_forall,"Postcondition","f",
                    "\\forall integer n;\n  1 < n <= 3 ==> \\old(*(t + n) == 12) && \\old(*(t + (n - 1)) > 5)",
                    "tests/arith/at_on-purely-logic-variables.c",6);
    __gen_e_acsl_m = 4;
    __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_3 + 0),
                                                    sizeof(int),
                                                    (void *)__gen_e_acsl_at_3,
                                                    (void *)(& __gen_e_acsl_at_3));
    __e_acsl_assert(__gen_e_acsl_valid_read_3,"RTE","f",
                    "mem_access: \\valid_read(__gen_e_acsl_at_3 + 0)",
                    "tests/arith/at_on-purely-logic-variables.c",8);
    if (*(__gen_e_acsl_at_3 + 0)) {
      int __gen_e_acsl_valid_read_4;
      __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_4 + 0),
                                                      sizeof(int),
                                                      (void *)__gen_e_acsl_at_4,
                                                      (void *)(& __gen_e_acsl_at_4));
      __e_acsl_assert(__gen_e_acsl_valid_read_4,"RTE","f",
                      "mem_access: \\valid_read(__gen_e_acsl_at_4 + 0)",
                      "tests/arith/at_on-purely-logic-variables.c",8);
      __gen_e_acsl_and_2 = *(__gen_e_acsl_at_4 + 0) == 9;
    }
    else __gen_e_acsl_and_2 = 0;
    __e_acsl_assert(__gen_e_acsl_and_2,"Postcondition","f",
                    "\\let m = 4; \\old(*(t + m) == -4) && \\old(*(t + (m - 4))) == 9",
                    "tests/arith/at_on-purely-logic-variables.c",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;
  }
}


