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

struct S {
   int a[2] ;
   float *b ;
   float *c ;
};
/*@ requires !\valid(s + (3 .. n + 1000)); */
void __gen_e_acsl_f(char *s, long n);

void f(char *s, long n)
{
  return;
}

/*@ requires \valid(ptr + (0 .. size - 1));
    ensures !\valid(\old(ptr) + (0 .. \old(size) + 1));
 */
void __gen_e_acsl_g(long *ptr, size_t size);

void g(long *ptr, size_t size)
{
  __e_acsl_store_block((void *)(& ptr),8UL);
  __e_acsl_delete_block((void *)(& ptr));
  return;
}

int main(void)
{
  int __retres;
  int *a;
  char *b;
  double t2[4];
  float t3[7][2][4];
  int t4[10][10][10];
  struct S s;
  int **multi_dynamic;
  int i;
  __e_acsl_memory_init((int *)0,(char ***)0,8UL);
  __e_acsl_store_block((void *)(& multi_dynamic),8UL);
  __e_acsl_store_block((void *)(& s),24UL);
  __e_acsl_store_block((void *)(t4),4000UL);
  __e_acsl_store_block((void *)(t3),224UL);
  __e_acsl_store_block((void *)(t2),32UL);
  __e_acsl_store_block((void *)(& b),8UL);
  __e_acsl_store_block((void *)(& a),8UL);
  __e_acsl_full_init((void *)(& a));
  a = (int *)malloc((unsigned long)10 * sizeof(int));
  {
    int __gen_e_acsl_size;
    int __gen_e_acsl_if;
    int __gen_e_acsl_valid;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"a",(void *)a);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"sizeof(int)",0,
                                 4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"sizeof(int)",0,
                                 4);
    __gen_e_acsl_size = 4 * ((4 - 0) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"size",0,
                                 __gen_e_acsl_size);
    if (__gen_e_acsl_size <= 0) __gen_e_acsl_if = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"size",0,
                                   __gen_e_acsl_size);
      __gen_e_acsl_if = __gen_e_acsl_size;
    }
    __gen_e_acsl_valid = __e_acsl_valid((void *)((char *)a + 4 * 0),
                                        (size_t)__gen_e_acsl_if,(void *)a,
                                        (void *)(& a));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
                                 "\\valid(a + (0 .. 4))",0,
                                 __gen_e_acsl_valid);
    __gen_e_acsl_assert_data.blocking = 1;
    __gen_e_acsl_assert_data.kind = "Assertion";
    __gen_e_acsl_assert_data.pred_txt = "\\valid(a + (0 .. 4))";
    __gen_e_acsl_assert_data.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data.fct = "main";
    __gen_e_acsl_assert_data.line = 24;
    __e_acsl_assert(__gen_e_acsl_valid,& __gen_e_acsl_assert_data);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
  }
  /*@ assert \valid(a + (0 .. 4)); */ ;
  int j = 2;
  {
    long __gen_e_acsl_size_2;
    long __gen_e_acsl_if_2;
    int __gen_e_acsl_valid_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,"a",(void *)a);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,"sizeof(int)",
                                 0,4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,"sizeof(int)",
                                 0,4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,"j",0,j);
    __gen_e_acsl_size_2 = 4L * (((7L + j) - 4L) + 1L);
    __e_acsl_assert_register_long(& __gen_e_acsl_assert_data_2,"size",0,
                                  __gen_e_acsl_size_2);
    if (__gen_e_acsl_size_2 <= 0L) __gen_e_acsl_if_2 = 0L;
    else {
      __e_acsl_assert_register_long(& __gen_e_acsl_assert_data_2,"size",0,
                                    __gen_e_acsl_size_2);
      __gen_e_acsl_if_2 = __gen_e_acsl_size_2;
    }
    __gen_e_acsl_valid_2 = __e_acsl_valid((void *)((char *)a + 4 * 4),
                                          (size_t)__gen_e_acsl_if_2,
                                          (void *)a,(void *)(& a));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,
                                 "\\valid(a + (4 .. 7 + j))",0,
                                 __gen_e_acsl_valid_2);
    __gen_e_acsl_assert_data_2.blocking = 1;
    __gen_e_acsl_assert_data_2.kind = "Assertion";
    __gen_e_acsl_assert_data_2.pred_txt = "\\valid(a + (4 .. 7 + j))";
    __gen_e_acsl_assert_data_2.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_2.fct = "main";
    __gen_e_acsl_assert_data_2.line = 26;
    __e_acsl_assert(__gen_e_acsl_valid_2,& __gen_e_acsl_assert_data_2);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
  }
  /*@ assert \valid(a + (4 .. 7 + j)); */ ;
  {
    int __gen_e_acsl_size_3;
    int __gen_e_acsl_if_3;
    int __gen_e_acsl_valid_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,"a",(void *)a);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,"sizeof(int)",
                                 0,4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,"sizeof(int)",
                                 0,4);
    __gen_e_acsl_size_3 = 4 * ((11 - 10) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,"size",0,
                                 __gen_e_acsl_size_3);
    if (__gen_e_acsl_size_3 <= 0) __gen_e_acsl_if_3 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,"size",0,
                                   __gen_e_acsl_size_3);
      __gen_e_acsl_if_3 = __gen_e_acsl_size_3;
    }
    __gen_e_acsl_valid_3 = __e_acsl_valid((void *)((char *)a + 4 * 10),
                                          (size_t)__gen_e_acsl_if_3,
                                          (void *)a,(void *)(& a));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
                                 "\\valid(a + (10 .. 11))",0,
                                 __gen_e_acsl_valid_3);
    __gen_e_acsl_assert_data_3.blocking = 1;
    __gen_e_acsl_assert_data_3.kind = "Assertion";
    __gen_e_acsl_assert_data_3.pred_txt = "!\\valid(a + (10 .. 11))";
    __gen_e_acsl_assert_data_3.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_3.fct = "main";
    __gen_e_acsl_assert_data_3.line = 27;
    __e_acsl_assert(! __gen_e_acsl_valid_3,& __gen_e_acsl_assert_data_3);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
  }
  /*@ assert !\valid(a + (10 .. 11)); */ ;
  free((void *)a);
  __e_acsl_full_init((void *)(& b));
  b = (char *)malloc((unsigned long)10 * sizeof(char));
  {
    int __gen_e_acsl_size_4;
    int __gen_e_acsl_if_4;
    int __gen_e_acsl_valid_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,"b",(void *)b);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,"sizeof(char)",
                                 0,1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,"sizeof(char)",
                                 0,1);
    __gen_e_acsl_size_4 = 1 * ((9 - 0) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,"size",0,
                                 __gen_e_acsl_size_4);
    if (__gen_e_acsl_size_4 <= 0) __gen_e_acsl_if_4 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,"size",0,
                                   __gen_e_acsl_size_4);
      __gen_e_acsl_if_4 = __gen_e_acsl_size_4;
    }
    __gen_e_acsl_valid_4 = __e_acsl_valid((void *)(b + 1 * 0),
                                          (size_t)__gen_e_acsl_if_4,
                                          (void *)b,(void *)(& b));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,
                                 "\\valid(b + (0 .. 9))",0,
                                 __gen_e_acsl_valid_4);
    __gen_e_acsl_assert_data_4.blocking = 1;
    __gen_e_acsl_assert_data_4.kind = "Assertion";
    __gen_e_acsl_assert_data_4.pred_txt = "\\valid(b + (0 .. 9))";
    __gen_e_acsl_assert_data_4.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_4.fct = "main";
    __gen_e_acsl_assert_data_4.line = 32;
    __e_acsl_assert(__gen_e_acsl_valid_4,& __gen_e_acsl_assert_data_4);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
  }
  /*@ assert \valid(b + (0 .. 9)); */ ;
  {
    int __gen_e_acsl_size_5;
    int __gen_e_acsl_if_5;
    int __gen_e_acsl_valid_5;
    __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,"b",(void *)b);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,"sizeof(char)",
                                 0,1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,"sizeof(char)",
                                 0,1);
    __gen_e_acsl_size_5 = 1 * ((15 - 10) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,"size",0,
                                 __gen_e_acsl_size_5);
    if (__gen_e_acsl_size_5 <= 0) __gen_e_acsl_if_5 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,"size",0,
                                   __gen_e_acsl_size_5);
      __gen_e_acsl_if_5 = __gen_e_acsl_size_5;
    }
    __gen_e_acsl_valid_5 = __e_acsl_valid((void *)(b + 1 * 10),
                                          (size_t)__gen_e_acsl_if_5,
                                          (void *)b,(void *)(& b));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,
                                 "\\valid(b + (10 .. 15))",0,
                                 __gen_e_acsl_valid_5);
    __gen_e_acsl_assert_data_5.blocking = 1;
    __gen_e_acsl_assert_data_5.kind = "Assertion";
    __gen_e_acsl_assert_data_5.pred_txt = "!\\valid(b + (10 .. 15))";
    __gen_e_acsl_assert_data_5.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_5.fct = "main";
    __gen_e_acsl_assert_data_5.line = 33;
    __e_acsl_assert(! __gen_e_acsl_valid_5,& __gen_e_acsl_assert_data_5);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_5);
  }
  /*@ assert !\valid(b + (10 .. 15)); */ ;
  long t[3] = {7l, 8l, 9l};
  __e_acsl_store_block((void *)(t),24UL);
  __e_acsl_full_init((void *)(& t));
  {
    int __gen_e_acsl_size_6;
    int __gen_e_acsl_if_6;
    int __gen_e_acsl_valid_6;
    __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,"(long *)t",
                                 (void *)(t));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,"sizeof(long)",
                                 0,8);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,"sizeof(long)",
                                 0,8);
    __gen_e_acsl_size_6 = 8 * ((2 - 0) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,"size",0,
                                 __gen_e_acsl_size_6);
    if (__gen_e_acsl_size_6 <= 0) __gen_e_acsl_if_6 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,"size",0,
                                   __gen_e_acsl_size_6);
      __gen_e_acsl_if_6 = __gen_e_acsl_size_6;
    }
    __gen_e_acsl_valid_6 = __e_acsl_valid((void *)((char *)(t) + 8 * 0),
                                          (size_t)__gen_e_acsl_if_6,
                                          (void *)(t),(void *)0);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
                                 "\\valid(&t[0 .. 2])",0,
                                 __gen_e_acsl_valid_6);
    __gen_e_acsl_assert_data_6.blocking = 1;
    __gen_e_acsl_assert_data_6.kind = "Assertion";
    __gen_e_acsl_assert_data_6.pred_txt = "\\valid(&t[0 .. 2])";
    __gen_e_acsl_assert_data_6.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_6.fct = "main";
    __gen_e_acsl_assert_data_6.line = 36;
    __e_acsl_assert(__gen_e_acsl_valid_6,& __gen_e_acsl_assert_data_6);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_6);
  }
  /*@ assert \valid(&t[0 .. 2]); */ ;
  {
    int __gen_e_acsl_size_7;
    int __gen_e_acsl_if_7;
    int __gen_e_acsl_valid_7;
    __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,"(long *)t",
                                 (void *)(t));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,"sizeof(long)",
                                 0,8);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,"sizeof(long)",
                                 0,8);
    __gen_e_acsl_size_7 = 8 * ((5 - 3) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,"size",0,
                                 __gen_e_acsl_size_7);
    if (__gen_e_acsl_size_7 <= 0) __gen_e_acsl_if_7 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,"size",0,
                                   __gen_e_acsl_size_7);
      __gen_e_acsl_if_7 = __gen_e_acsl_size_7;
    }
    __gen_e_acsl_valid_7 = __e_acsl_valid((void *)((char *)(t) + 8 * 3),
                                          (size_t)__gen_e_acsl_if_7,
                                          (void *)(t),(void *)0);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,
                                 "\\valid(&t[3 .. 5])",0,
                                 __gen_e_acsl_valid_7);
    __gen_e_acsl_assert_data_7.blocking = 1;
    __gen_e_acsl_assert_data_7.kind = "Assertion";
    __gen_e_acsl_assert_data_7.pred_txt = "!\\valid(&t[3 .. 5])";
    __gen_e_acsl_assert_data_7.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_7.fct = "main";
    __gen_e_acsl_assert_data_7.line = 37;
    __e_acsl_assert(! __gen_e_acsl_valid_7,& __gen_e_acsl_assert_data_7);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_7);
  }
  /*@ assert !\valid(&t[3 .. 5]); */ ;
  __gen_e_acsl_g(t,(size_t)3);
  __e_acsl_initialize((void *)(t2),sizeof(double));
  t2[0] = 0.5;
  __e_acsl_initialize((void *)(& t2[1]),sizeof(double));
  t2[1] = 1.5;
  {
    int __gen_e_acsl_size_8;
    int __gen_e_acsl_if_8;
    int __gen_e_acsl_initialized;
    __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,"(double *)t2",
                                 (void *)(t2));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,
                                 "sizeof(double)",0,8);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,
                                 "sizeof(double)",0,8);
    __gen_e_acsl_size_8 = 8 * ((1 - 0) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,"size",0,
                                 __gen_e_acsl_size_8);
    if (__gen_e_acsl_size_8 <= 0) __gen_e_acsl_if_8 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,"size",0,
                                   __gen_e_acsl_size_8);
      __gen_e_acsl_if_8 = __gen_e_acsl_size_8;
    }
    __gen_e_acsl_initialized = __e_acsl_initialized((void *)((char *)(t2) + 
                                                             8 * 0),
                                                    (size_t)__gen_e_acsl_if_8);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,
                                 "\\initialized(&t2[0 .. 1])",0,
                                 __gen_e_acsl_initialized);
    __gen_e_acsl_assert_data_8.blocking = 1;
    __gen_e_acsl_assert_data_8.kind = "Assertion";
    __gen_e_acsl_assert_data_8.pred_txt = "\\initialized(&t2[0 .. 1])";
    __gen_e_acsl_assert_data_8.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_8.fct = "main";
    __gen_e_acsl_assert_data_8.line = 43;
    __e_acsl_assert(__gen_e_acsl_initialized,& __gen_e_acsl_assert_data_8);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_8);
  }
  /*@ assert \initialized(&t2[0 .. 1]); */ ;
  {
    int __gen_e_acsl_size_9;
    int __gen_e_acsl_if_9;
    int __gen_e_acsl_initialized_2;
    __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,"(double *)t2",
                                 (void *)(t2));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_9,
                                 "sizeof(double)",0,8);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_9,
                                 "sizeof(double)",0,8);
    __gen_e_acsl_size_9 = 8 * ((3 - 2) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_9,"size",0,
                                 __gen_e_acsl_size_9);
    if (__gen_e_acsl_size_9 <= 0) __gen_e_acsl_if_9 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_9,"size",0,
                                   __gen_e_acsl_size_9);
      __gen_e_acsl_if_9 = __gen_e_acsl_size_9;
    }
    __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)((char *)(t2) + 
                                                               8 * 2),
                                                      (size_t)__gen_e_acsl_if_9);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_9,
                                 "\\initialized(&t2[2 .. 3])",0,
                                 __gen_e_acsl_initialized_2);
    __gen_e_acsl_assert_data_9.blocking = 1;
    __gen_e_acsl_assert_data_9.kind = "Assertion";
    __gen_e_acsl_assert_data_9.pred_txt = "!\\initialized(&t2[2 .. 3])";
    __gen_e_acsl_assert_data_9.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_9.fct = "main";
    __gen_e_acsl_assert_data_9.line = 44;
    __e_acsl_assert(! __gen_e_acsl_initialized_2,
                    & __gen_e_acsl_assert_data_9);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_9);
  }
  /*@ assert !\initialized(&t2[2 .. 3]); */ ;
  {
    int __gen_e_acsl_size_10;
    int __gen_e_acsl_if_10;
    int __gen_e_acsl_initialized_3;
    __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,"b",(void *)b);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_10,
                                 "sizeof(char)",0,1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_10,
                                 "sizeof(char)",0,1);
    __gen_e_acsl_size_10 = 1 * ((9 - 0) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_10,"size",0,
                                 __gen_e_acsl_size_10);
    if (__gen_e_acsl_size_10 <= 0) __gen_e_acsl_if_10 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_10,"size",0,
                                   __gen_e_acsl_size_10);
      __gen_e_acsl_if_10 = __gen_e_acsl_size_10;
    }
    __gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(b + 1 * 0),
                                                      (size_t)__gen_e_acsl_if_10);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_10,
                                 "\\initialized(b + (0 .. 9))",0,
                                 __gen_e_acsl_initialized_3);
    __gen_e_acsl_assert_data_10.blocking = 1;
    __gen_e_acsl_assert_data_10.kind = "Assertion";
    __gen_e_acsl_assert_data_10.pred_txt = "!\\initialized(b + (0 .. 9))";
    __gen_e_acsl_assert_data_10.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_10.fct = "main";
    __gen_e_acsl_assert_data_10.line = 46;
    __e_acsl_assert(! __gen_e_acsl_initialized_3,
                    & __gen_e_acsl_assert_data_10);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_10);
  }
  /*@ assert !\initialized(b + (0 .. 9)); */ ;
  free((void *)b);
  int n = 2;
  {
    int __gen_e_acsl_forall;
    int __gen_e_acsl_range_2;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_11 =
      {.values = (void *)0};
    __gen_e_acsl_forall = 1;
    __gen_e_acsl_range_2 = 0;
    while (1) {
      if (__gen_e_acsl_range_2 <= 1) ; else break;
      {
        int __gen_e_acsl_forall_2;
        long __gen_e_acsl_range;
        __gen_e_acsl_forall_2 = 1;
        __gen_e_acsl_range = n - 1L;
        while (1) {
          if (__gen_e_acsl_range <= n + 2L) ; else break;
          {
            int __gen_e_acsl_initialized_4;
            __gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& t3[__gen_e_acsl_range][1][__gen_e_acsl_range_2]),
                                                              sizeof(float));
            if (__gen_e_acsl_initialized_4) ;
            else {
              __gen_e_acsl_forall_2 = 0;
              goto e_acsl_end_loop1;
            }
          }
          __gen_e_acsl_range ++;
        }
        e_acsl_end_loop1: ;
        if (__gen_e_acsl_forall_2) ;
        else {
          __gen_e_acsl_forall = 0;
          goto e_acsl_end_loop2;
        }
      }
      __gen_e_acsl_range_2 ++;
    }
    e_acsl_end_loop2: ;
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_11,
                                 "\\forall integer range_2;\n  0 <= range_2 <= 1 ==>\n  (\\forall integer range;\n     n - 1 <= range <= n + 2 ==> \\initialized(&t3[range][1][range_2]))",
                                 0,__gen_e_acsl_forall);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_11,
                                 "\\initialized(&t3[n - 1 .. n + 2][1][0 .. 1])",
                                 0,__gen_e_acsl_forall);
    __gen_e_acsl_assert_data_11.blocking = 1;
    __gen_e_acsl_assert_data_11.kind = "Assertion";
    __gen_e_acsl_assert_data_11.pred_txt = "!\\initialized(&t3[n - 1 .. n + 2][1][0 .. 1])";
    __gen_e_acsl_assert_data_11.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_11.fct = "main";
    __gen_e_acsl_assert_data_11.line = 51;
    __e_acsl_assert(! __gen_e_acsl_forall,& __gen_e_acsl_assert_data_11);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_11);
  }
  /*@ assert !\initialized(&t3[n - 1 .. n + 2][1][0 .. 1]); */ ;
  {
    int __gen_e_acsl_size_11;
    int __gen_e_acsl_if_11;
    int __gen_e_acsl_valid_read;
    __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,
                                 "&t3[6][1][0]",(void *)(& t3[6][1][0]));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_12,
                                 "sizeof(float)",0,4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_12,
                                 "sizeof(float)",0,4);
    __gen_e_acsl_size_11 = 4 * ((10 - 2) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_12,"size",0,
                                 __gen_e_acsl_size_11);
    if (__gen_e_acsl_size_11 <= 0) __gen_e_acsl_if_11 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_12,"size",0,
                                   __gen_e_acsl_size_11);
      __gen_e_acsl_if_11 = __gen_e_acsl_size_11;
    }
    __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)((char *)(& t3[6][1][0]) + 
                                                           4 * 2),
                                                  (size_t)__gen_e_acsl_if_11,
                                                  (void *)(& t3[0][0][0]),
                                                  (void *)0);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_12,
                                 "\\valid_read(&t3[6][1][0] + (2 .. 10))",0,
                                 __gen_e_acsl_valid_read);
    __gen_e_acsl_assert_data_12.blocking = 1;
    __gen_e_acsl_assert_data_12.kind = "Assertion";
    __gen_e_acsl_assert_data_12.pred_txt = "!\\valid_read(&t3[6][1][0] + (2 .. 10))";
    __gen_e_acsl_assert_data_12.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_12.fct = "main";
    __gen_e_acsl_assert_data_12.line = 53;
    __e_acsl_assert(! __gen_e_acsl_valid_read,& __gen_e_acsl_assert_data_12);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_12);
  }
  /*@ assert !\valid_read(&t3[6][1][0] + (2 .. 10)); */ ;
  {
    int __gen_e_acsl_forall_3;
    long __gen_e_acsl_range_3;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_13 =
      {.values = (void *)0};
    __gen_e_acsl_forall_3 = 1;
    __gen_e_acsl_range_3 = n - 1L;
    while (1) {
      if (__gen_e_acsl_range_3 <= n + 2L) ; else break;
      {
        int __gen_e_acsl_valid_read_2;
        __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(& t3[__gen_e_acsl_range_3][1]),
                                                        sizeof(float [4]),
                                                        (void *)(& t3[0][0]),
                                                        (void *)0);
        if (__gen_e_acsl_valid_read_2) ;
        else {
          __gen_e_acsl_forall_3 = 0;
          goto e_acsl_end_loop3;
        }
      }
      __gen_e_acsl_range_3 ++;
    }
    e_acsl_end_loop3: ;
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_13,
                                 "\\forall integer range_3;\n  n - 1 <= range_3 <= n + 2 ==> \\valid_read(&t3[range_3][1])",
                                 0,__gen_e_acsl_forall_3);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_13,
                                 "\\valid_read(&t3[n - 1 .. n + 2][1])",0,
                                 __gen_e_acsl_forall_3);
    __gen_e_acsl_assert_data_13.blocking = 1;
    __gen_e_acsl_assert_data_13.kind = "Assertion";
    __gen_e_acsl_assert_data_13.pred_txt = "\\valid_read(&t3[n - 1 .. n + 2][1])";
    __gen_e_acsl_assert_data_13.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_13.fct = "main";
    __gen_e_acsl_assert_data_13.line = 54;
    __e_acsl_assert(__gen_e_acsl_forall_3,& __gen_e_acsl_assert_data_13);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_13);
  }
  /*@ assert \valid_read(&t3[n - 1 .. n + 2][1]); */ ;
  {
    int __gen_e_acsl_x;
    int __gen_e_acsl_forall_4;
    int __gen_e_acsl_range_4;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_14 =
      {.values = (void *)0};
    __gen_e_acsl_x = 5;
    __gen_e_acsl_forall_4 = 1;
    __gen_e_acsl_range_4 = 0;
    while (1) {
      if (__gen_e_acsl_range_4 <= __gen_e_acsl_x) ; else break;
      {
        int __gen_e_acsl_valid_8;
        __gen_e_acsl_valid_8 = __e_acsl_valid((void *)(& t4[4][__gen_e_acsl_range_4][2]),
                                              sizeof(int),
                                              (void *)(& t4[0][0][0]),
                                              (void *)0);
        if (__gen_e_acsl_valid_8) ;
        else {
          __gen_e_acsl_forall_4 = 0;
          goto e_acsl_end_loop4;
        }
      }
      __gen_e_acsl_range_4 ++;
    }
    e_acsl_end_loop4: ;
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,
                                 "\\forall integer range_4; 0 <= range_4 <= x ==> \\valid(&t4[4][range_4][2])",
                                 0,__gen_e_acsl_forall_4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,
                                 "\\valid(&t4[4][0 .. x][2])",0,
                                 __gen_e_acsl_forall_4);
    __gen_e_acsl_assert_data_14.blocking = 1;
    __gen_e_acsl_assert_data_14.kind = "Assertion";
    __gen_e_acsl_assert_data_14.pred_txt = "\\let x = 5; \\valid(&t4[4][0 .. x][2])";
    __gen_e_acsl_assert_data_14.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_14.fct = "main";
    __gen_e_acsl_assert_data_14.line = 57;
    __e_acsl_assert(__gen_e_acsl_forall_4,& __gen_e_acsl_assert_data_14);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_14);
  }
  /*@ assert \let x = 5; \valid(&t4[4][0 .. x][2]); */ ;
  __e_acsl_initialize((void *)(& s.a[0]),sizeof(int));
  s.a[0] = 7;
  __e_acsl_initialize((void *)(& s.a[1]),sizeof(int));
  s.a[1] = 8;
  {
    int __gen_e_acsl_size_12;
    int __gen_e_acsl_if_12;
    int __gen_e_acsl_initialized_5;
    __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,"&s.a[0]",
                                 (void *)(& s.a[0]));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_15,"sizeof(int)",
                                 0,4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_15,"sizeof(int)",
                                 0,4);
    __gen_e_acsl_size_12 = 4 * ((1 - 1) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_15,"size",0,
                                 __gen_e_acsl_size_12);
    if (__gen_e_acsl_size_12 <= 0) __gen_e_acsl_if_12 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_15,"size",0,
                                   __gen_e_acsl_size_12);
      __gen_e_acsl_if_12 = __gen_e_acsl_size_12;
    }
    __gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)((char *)(& s.a[0]) + 
                                                               4 * 1),
                                                      (size_t)__gen_e_acsl_if_12);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_15,
                                 "\\initialized(&s.a[0] + (1 .. 1))",0,
                                 __gen_e_acsl_initialized_5);
    __gen_e_acsl_assert_data_15.blocking = 1;
    __gen_e_acsl_assert_data_15.kind = "Assertion";
    __gen_e_acsl_assert_data_15.pred_txt = "\\initialized(&s.a[0] + (1 .. 1))";
    __gen_e_acsl_assert_data_15.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_15.fct = "main";
    __gen_e_acsl_assert_data_15.line = 62;
    __e_acsl_assert(__gen_e_acsl_initialized_5,& __gen_e_acsl_assert_data_15);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_15);
  }
  /*@ assert \initialized(&s.a[0] + (1 .. 1)); */ ;
  {
    int __gen_e_acsl_size_13;
    int __gen_e_acsl_if_13;
    int __gen_e_acsl_initialized_6;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_16 =
      {.values = (void *)0};
    /*@ assert Eva: initialization: \initialized(&s.b); */
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_16,"s.b",
                                 (void *)s.b);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_16,
                                 "sizeof(float)",0,4);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_16,
                                 "sizeof(float)",0,4);
    __gen_e_acsl_size_13 = 4 * ((1 - 0) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_16,"size",0,
                                 __gen_e_acsl_size_13);
    if (__gen_e_acsl_size_13 <= 0) __gen_e_acsl_if_13 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_16,"size",0,
                                   __gen_e_acsl_size_13);
      __gen_e_acsl_if_13 = __gen_e_acsl_size_13;
    }
    __gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)((char *)s.b + 
                                                               4 * 0),
                                                      (size_t)__gen_e_acsl_if_13);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_16,
                                 "\\initialized(s.b + (0 .. 1))",0,
                                 __gen_e_acsl_initialized_6);
    __gen_e_acsl_assert_data_16.blocking = 1;
    __gen_e_acsl_assert_data_16.kind = "Assertion";
    __gen_e_acsl_assert_data_16.pred_txt = "!\\initialized(s.b + (0 .. 1))";
    __gen_e_acsl_assert_data_16.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_16.fct = "main";
    __gen_e_acsl_assert_data_16.line = 63;
    __e_acsl_assert(! __gen_e_acsl_initialized_6,
                    & __gen_e_acsl_assert_data_16);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_16);
  }
  /*@ assert !\initialized(s.b + (0 .. 1)); */ ;
  int size1 = 5;
  int size2 = 9;
  __e_acsl_full_init((void *)(& multi_dynamic));
  multi_dynamic = (int **)malloc((unsigned long)size1 * sizeof(*multi_dynamic));
  i = 0;
  while (i < size1) {
    __e_acsl_initialize((void *)(multi_dynamic + i),sizeof(int *));
    *(multi_dynamic + i) = (int *)malloc((unsigned long)size2 * sizeof(*(*(
                                         multi_dynamic + i))));
    i ++;
  }
  {
    int __gen_e_acsl_valid_read_3;
    int __gen_e_acsl_size_14;
    int __gen_e_acsl_if_14;
    int __gen_e_acsl_valid_9;
    __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,
                                 "*(multi_dynamic + 4)",
                                 (void *)*(multi_dynamic + 4));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_17,"sizeof(int)",
                                 0,4);
    __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,
                                 "multi_dynamic",(void *)multi_dynamic);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_18,
                                   "sizeof(int *)",0,sizeof(int *));
    __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(multi_dynamic + 4),
                                                    sizeof(int *),
                                                    (void *)multi_dynamic,
                                                    (void *)(& multi_dynamic));
    __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(multi_dynamic + 4)";
    __gen_e_acsl_assert_data_18.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_18.fct = "main";
    __gen_e_acsl_assert_data_18.line = 72;
    __gen_e_acsl_assert_data_18.name = "mem_access";
    __e_acsl_assert(__gen_e_acsl_valid_read_3,& __gen_e_acsl_assert_data_18);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_18);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_17,"sizeof(int)",
                                 0,4);
    __gen_e_acsl_size_14 = 4 * ((7 - 1) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_17,"size",0,
                                 __gen_e_acsl_size_14);
    if (__gen_e_acsl_size_14 <= 0) __gen_e_acsl_if_14 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_17,"size",0,
                                   __gen_e_acsl_size_14);
      __gen_e_acsl_if_14 = __gen_e_acsl_size_14;
    }
    __gen_e_acsl_valid_9 = __e_acsl_valid((void *)((char *)*(multi_dynamic + 4) + 
                                                   4 * 1),
                                          (size_t)__gen_e_acsl_if_14,
                                          (void *)*(multi_dynamic + 4),
                                          (void *)(multi_dynamic + 4));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_17,
                                 "\\valid(*(multi_dynamic + 4) + (1 .. 7))",
                                 0,__gen_e_acsl_valid_9);
    __gen_e_acsl_assert_data_17.blocking = 1;
    __gen_e_acsl_assert_data_17.kind = "Assertion";
    __gen_e_acsl_assert_data_17.pred_txt = "\\valid(*(multi_dynamic + 4) + (1 .. 7))";
    __gen_e_acsl_assert_data_17.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_17.fct = "main";
    __gen_e_acsl_assert_data_17.line = 72;
    __e_acsl_assert(__gen_e_acsl_valid_9,& __gen_e_acsl_assert_data_17);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_17);
  }
  /*@ assert \valid(*(multi_dynamic + 4) + (1 .. 7)); */ ;
  /*@ assert \valid(*(multi_dynamic + (2 .. 4)) + (1 .. 7)); */ ;
  i --;
  while (i >= 0) {
    free((void *)*(multi_dynamic + i));
    i --;
  }
  free((void *)multi_dynamic);
  char c = (char)'w';
  __e_acsl_store_block((void *)(& c),1UL);
  __e_acsl_full_init((void *)(& c));
  __gen_e_acsl_f(& c,(long)5);
  char t5[4] = {(char)'a', (char)'b', (char)'c', (char)'d'};
  __e_acsl_store_block((void *)(t5),4UL);
  __e_acsl_full_init((void *)(& t5));
  {
    int __gen_e_acsl_size_15;
    int __gen_e_acsl_if_15;
    int __gen_e_acsl_valid_10;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_20 =
      {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_20,"(char *)t5",
                                 (void *)(t5));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_20,
                                 "sizeof(char)",0,1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_20,
                                 "sizeof(char)",0,1);
    __gen_e_acsl_size_15 = 1 * ((3 - 2) + 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_20,"size",0,
                                 __gen_e_acsl_size_15);
    if (__gen_e_acsl_size_15 <= 0) __gen_e_acsl_if_15 = 0;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_20,"size",0,
                                   __gen_e_acsl_size_15);
      __gen_e_acsl_if_15 = __gen_e_acsl_size_15;
    }
    __gen_e_acsl_valid_10 = __e_acsl_valid((void *)(t5 + 1 * 2),
                                           (size_t)__gen_e_acsl_if_15,
                                           (void *)(t5),(void *)0);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_20,
                                 "\\valid(&t5[2 .. 3])",0,
                                 __gen_e_acsl_valid_10);
    __gen_e_acsl_assert_data_20.blocking = 1;
    __gen_e_acsl_assert_data_20.kind = "Assertion";
    __gen_e_acsl_assert_data_20.pred_txt = "\\valid(&t5[2 .. 3])";
    __gen_e_acsl_assert_data_20.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_20.fct = "main";
    __gen_e_acsl_assert_data_20.line = 84;
    __e_acsl_assert(__gen_e_acsl_valid_10,& __gen_e_acsl_assert_data_20);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_20);
  }
  /*@ assert \valid(&t5[2 .. 3]); */ ;
  __retres = 0;
  __e_acsl_delete_block((void *)(t5));
  __e_acsl_delete_block((void *)(& c));
  __e_acsl_delete_block((void *)(& multi_dynamic));
  __e_acsl_delete_block((void *)(& s));
  __e_acsl_delete_block((void *)(t4));
  __e_acsl_delete_block((void *)(t3));
  __e_acsl_delete_block((void *)(t2));
  __e_acsl_delete_block((void *)(t));
  __e_acsl_delete_block((void *)(& b));
  __e_acsl_delete_block((void *)(& a));
  __e_acsl_memory_clean();
  return __retres;
}

/*@ requires \valid(ptr + (0 .. size - 1));
    ensures !\valid(\old(ptr) + (0 .. \old(size) + 1));
 */
void __gen_e_acsl_g(long *ptr, size_t size)
{
  __e_acsl_mpz_t __gen_e_acsl_at_2;
  long *__gen_e_acsl_at;
  {
    __e_acsl_mpz_t __gen_e_acsl_size;
    __e_acsl_mpz_t __gen_e_acsl_size_2;
    __e_acsl_mpz_t __gen_e_acsl_sizeof;
    __e_acsl_mpz_t __gen_e_acsl_size_3;
    __e_acsl_mpz_t __gen_e_acsl_;
    __e_acsl_mpz_t __gen_e_acsl_sub;
    __e_acsl_mpz_t __gen_e_acsl__2;
    __e_acsl_mpz_t __gen_e_acsl_sub_2;
    __e_acsl_mpz_t __gen_e_acsl_add;
    __e_acsl_mpz_t __gen_e_acsl_mul;
    int __gen_e_acsl_le;
    __e_acsl_mpz_t __gen_e_acsl_if;
    __e_acsl_mpz_t __gen_e_acsl__4;
    int __gen_e_acsl_le_2;
    unsigned long __gen_e_acsl_size_4;
    int __gen_e_acsl_valid;
    __e_acsl_store_block((void *)(& ptr),8UL);
    __gen_e_acsl_at = ptr;
    __gmpz_init_set_ui(__gen_e_acsl_size,size);
    __gmpz_init_set(__gen_e_acsl_at_2,
                    (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
    __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"ptr",
                                 (void *)ptr);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"sizeof(long)",0,
                                 8);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"sizeof(long)",0,
                                 8);
    __gmpz_init_set_si(__gen_e_acsl_sizeof,8L);
    __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data,"size",0,size);
    __gmpz_init_set_ui(__gen_e_acsl_size_3,size);
    __gmpz_init_set_si(__gen_e_acsl_,1L);
    __gmpz_init(__gen_e_acsl_sub);
    __gmpz_sub(__gen_e_acsl_sub,
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_3),
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_));
    __gmpz_init_set_si(__gen_e_acsl__2,0L);
    __gmpz_init(__gen_e_acsl_sub_2);
    __gmpz_sub(__gen_e_acsl_sub_2,
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_sub),
               (__e_acsl_mpz_struct const *)(__gen_e_acsl__2));
    __gmpz_init(__gen_e_acsl_add);
    __gmpz_add(__gen_e_acsl_add,
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_sub_2),
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_));
    __gmpz_init(__gen_e_acsl_mul);
    __gmpz_mul(__gen_e_acsl_mul,
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_sizeof),
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_add));
    __gmpz_init_set(__gen_e_acsl_size_2,
                    (__e_acsl_mpz_struct const *)(__gen_e_acsl_mul));
    __e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data,"size",0,
                                 (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2));
    __gen_e_acsl_le = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2),
                                 (__e_acsl_mpz_struct const *)(__gen_e_acsl__2));
    if (__gen_e_acsl_le <= 0) {
      __e_acsl_mpz_t __gen_e_acsl__3;
      __gmpz_init_set_si(__gen_e_acsl__3,0L);
      __gmpz_init_set(__gen_e_acsl_if,
                      (__e_acsl_mpz_struct const *)(__gen_e_acsl__3));
      __gmpz_clear(__gen_e_acsl__3);
    }
    else {
      __e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data,"size",0,
                                   (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2));
      __gmpz_init_set(__gen_e_acsl_if,
                      (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2));
    }
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
      {.values = (void *)0};
    __e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_2,
                                 "__gen_e_acsl_if",0,
                                 (__e_acsl_mpz_struct const *)(__gen_e_acsl_if));
    __gmpz_init_set_ui(__gen_e_acsl__4,18446744073709551615UL);
    __gen_e_acsl_le_2 = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_if),
                                   (__e_acsl_mpz_struct const *)(__gen_e_acsl__4));
    __e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data,
                                 "__gen_e_acsl_if",0,
                                 (__e_acsl_mpz_struct const *)(__gen_e_acsl_if));
    __gen_e_acsl_assert_data_2.blocking = 1;
    __gen_e_acsl_assert_data_2.kind = "RTE";
    __gen_e_acsl_assert_data_2.pred_txt = "(\\let size = sizeof(long) * (((size - 1) - 0) + 1); size <= 0? 0: size) <=\n18446744073709551615";
    __gen_e_acsl_assert_data_2.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_2.fct = "g";
    __gen_e_acsl_assert_data_2.line = 8;
    __gen_e_acsl_assert_data_2.name = "offset_lesser_or_eq_than_SIZE_MAX";
    __e_acsl_assert(__gen_e_acsl_le_2 <= 0,& __gen_e_acsl_assert_data_2);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
    __gen_e_acsl_size_4 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_if));
    __gen_e_acsl_valid = __e_acsl_valid((void *)((char *)ptr + 8 * 0),
                                        __gen_e_acsl_size_4,(void *)ptr,
                                        (void *)(& ptr));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
                                 "\\valid(ptr + (0 .. size - 1))",0,
                                 __gen_e_acsl_valid);
    __gen_e_acsl_assert_data.blocking = 1;
    __gen_e_acsl_assert_data.kind = "Precondition";
    __gen_e_acsl_assert_data.pred_txt = "\\valid(ptr + (0 .. size - 1))";
    __gen_e_acsl_assert_data.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data.fct = "g";
    __gen_e_acsl_assert_data.line = 8;
    __e_acsl_assert(__gen_e_acsl_valid,& __gen_e_acsl_assert_data);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
    __gmpz_clear(__gen_e_acsl_size);
    __gmpz_clear(__gen_e_acsl_size_2);
    __gmpz_clear(__gen_e_acsl_sizeof);
    __gmpz_clear(__gen_e_acsl_size_3);
    __gmpz_clear(__gen_e_acsl_);
    __gmpz_clear(__gen_e_acsl_sub);
    __gmpz_clear(__gen_e_acsl__2);
    __gmpz_clear(__gen_e_acsl_sub_2);
    __gmpz_clear(__gen_e_acsl_add);
    __gmpz_clear(__gen_e_acsl_mul);
    __gmpz_clear(__gen_e_acsl_if);
    __gmpz_clear(__gen_e_acsl__4);
  }
  g(ptr,size);
  {
    __e_acsl_mpz_t __gen_e_acsl_size_5;
    __e_acsl_mpz_t __gen_e_acsl_sizeof_2;
    __e_acsl_mpz_t __gen_e_acsl__5;
    __e_acsl_mpz_t __gen_e_acsl_add_2;
    __e_acsl_mpz_t __gen_e_acsl__6;
    __e_acsl_mpz_t __gen_e_acsl_sub_3;
    __e_acsl_mpz_t __gen_e_acsl_add_3;
    __e_acsl_mpz_t __gen_e_acsl_mul_2;
    int __gen_e_acsl_le_3;
    __e_acsl_mpz_t __gen_e_acsl_if_2;
    __e_acsl_mpz_t __gen_e_acsl__8;
    int __gen_e_acsl_le_4;
    unsigned long __gen_e_acsl_size_6;
    int __gen_e_acsl_valid_2;
    __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,"\\old(ptr)",
                                 (void *)__gen_e_acsl_at);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,"sizeof(long)",
                                 0,8);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,"sizeof(long)",
                                 0,8);
    __gmpz_init_set_si(__gen_e_acsl_sizeof_2,8L);
    __e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_3,"\\old(size)",
                                 0,
                                 (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_2));
    __gmpz_init_set_si(__gen_e_acsl__5,1L);
    __gmpz_init(__gen_e_acsl_add_2);
    __gmpz_add(__gen_e_acsl_add_2,
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_2),
               (__e_acsl_mpz_struct const *)(__gen_e_acsl__5));
    __gmpz_init_set_si(__gen_e_acsl__6,0L);
    __gmpz_init(__gen_e_acsl_sub_3);
    __gmpz_sub(__gen_e_acsl_sub_3,
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_add_2),
               (__e_acsl_mpz_struct const *)(__gen_e_acsl__6));
    __gmpz_init(__gen_e_acsl_add_3);
    __gmpz_add(__gen_e_acsl_add_3,
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_sub_3),
               (__e_acsl_mpz_struct const *)(__gen_e_acsl__5));
    __gmpz_init(__gen_e_acsl_mul_2);
    __gmpz_mul(__gen_e_acsl_mul_2,
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_sizeof_2),
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_add_3));
    __gmpz_init_set(__gen_e_acsl_size_5,
                    (__e_acsl_mpz_struct const *)(__gen_e_acsl_mul_2));
    __e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_3,"size",0,
                                 (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_5));
    __gen_e_acsl_le_3 = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_size_5),
                                   (__e_acsl_mpz_struct const *)(__gen_e_acsl__6));
    if (__gen_e_acsl_le_3 <= 0) {
      __e_acsl_mpz_t __gen_e_acsl__7;
      __gmpz_init_set_si(__gen_e_acsl__7,0L);
      __gmpz_init_set(__gen_e_acsl_if_2,
                      (__e_acsl_mpz_struct const *)(__gen_e_acsl__7));
      __gmpz_clear(__gen_e_acsl__7);
    }
    else {
      __e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_3,"size",0,
                                   (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_5));
      __gmpz_init_set(__gen_e_acsl_if_2,
                      (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_5));
    }
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
      {.values = (void *)0};
    __e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_4,
                                 "__gen_e_acsl_if_2",0,
                                 (__e_acsl_mpz_struct const *)(__gen_e_acsl_if_2));
    __gmpz_init_set_ui(__gen_e_acsl__8,18446744073709551615UL);
    __gen_e_acsl_le_4 = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_if_2),
                                   (__e_acsl_mpz_struct const *)(__gen_e_acsl__8));
    __e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_3,
                                 "__gen_e_acsl_if_2",0,
                                 (__e_acsl_mpz_struct const *)(__gen_e_acsl_if_2));
    __gen_e_acsl_assert_data_4.blocking = 1;
    __gen_e_acsl_assert_data_4.kind = "RTE";
    __gen_e_acsl_assert_data_4.pred_txt = "(\\let size = sizeof(long) * (((\\old(size) + 1) - 0) + 1); size <= 0? 0: size)\n<= 18446744073709551615";
    __gen_e_acsl_assert_data_4.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_4.fct = "g";
    __gen_e_acsl_assert_data_4.line = 9;
    __gen_e_acsl_assert_data_4.name = "offset_lesser_or_eq_than_SIZE_MAX";
    __e_acsl_assert(__gen_e_acsl_le_4 <= 0,& __gen_e_acsl_assert_data_4);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
    __gen_e_acsl_size_6 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_if_2));
    __gen_e_acsl_valid_2 = __e_acsl_valid((void *)((char *)__gen_e_acsl_at + 
                                                   8 * 0),
                                          __gen_e_acsl_size_6,
                                          (void *)__gen_e_acsl_at,
                                          (void *)(& __gen_e_acsl_at));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
                                 "\\valid(\\old(ptr) + (0 .. \\old(size) + 1))",
                                 0,__gen_e_acsl_valid_2);
    __gen_e_acsl_assert_data_3.blocking = 1;
    __gen_e_acsl_assert_data_3.kind = "Postcondition";
    __gen_e_acsl_assert_data_3.pred_txt = "!\\valid(\\old(ptr) + (0 .. \\old(size) + 1))";
    __gen_e_acsl_assert_data_3.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_3.fct = "g";
    __gen_e_acsl_assert_data_3.line = 9;
    __e_acsl_assert(! __gen_e_acsl_valid_2,& __gen_e_acsl_assert_data_3);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
    __e_acsl_delete_block((void *)(& ptr));
    __gmpz_clear(__gen_e_acsl_size_5);
    __gmpz_clear(__gen_e_acsl_sizeof_2);
    __gmpz_clear(__gen_e_acsl__5);
    __gmpz_clear(__gen_e_acsl_add_2);
    __gmpz_clear(__gen_e_acsl__6);
    __gmpz_clear(__gen_e_acsl_sub_3);
    __gmpz_clear(__gen_e_acsl_add_3);
    __gmpz_clear(__gen_e_acsl_mul_2);
    __gmpz_clear(__gen_e_acsl_if_2);
    __gmpz_clear(__gen_e_acsl__8);
    __gmpz_clear(__gen_e_acsl_at_2);
    return;
  }
}

/*@ requires !\valid(s + (3 .. n + 1000)); */
void __gen_e_acsl_f(char *s, long n)
{
  {
    __e_acsl_mpz_t __gen_e_acsl_size;
    __e_acsl_mpz_t __gen_e_acsl_sizeof;
    __e_acsl_mpz_t __gen_e_acsl_n;
    __e_acsl_mpz_t __gen_e_acsl_;
    __e_acsl_mpz_t __gen_e_acsl_add;
    __e_acsl_mpz_t __gen_e_acsl__2;
    __e_acsl_mpz_t __gen_e_acsl_sub;
    __e_acsl_mpz_t __gen_e_acsl__3;
    __e_acsl_mpz_t __gen_e_acsl_add_2;
    __e_acsl_mpz_t __gen_e_acsl_mul;
    __e_acsl_mpz_t __gen_e_acsl__4;
    int __gen_e_acsl_le;
    __e_acsl_mpz_t __gen_e_acsl_if;
    __e_acsl_mpz_t __gen_e_acsl__6;
    int __gen_e_acsl_le_2;
    unsigned long __gen_e_acsl_size_2;
    int __gen_e_acsl_valid;
    __e_acsl_store_block((void *)(& s),8UL);
    __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
    __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"s",(void *)s);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"sizeof(char)",0,
                                 1);
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"sizeof(char)",0,
                                 1);
    __gmpz_init_set_si(__gen_e_acsl_sizeof,1L);
    __e_acsl_assert_register_long(& __gen_e_acsl_assert_data,"n",0,n);
    __gmpz_init_set_si(__gen_e_acsl_n,n);
    __gmpz_init_set_si(__gen_e_acsl_,1000L);
    __gmpz_init(__gen_e_acsl_add);
    __gmpz_add(__gen_e_acsl_add,
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_n),
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_));
    __gmpz_init_set_si(__gen_e_acsl__2,3L);
    __gmpz_init(__gen_e_acsl_sub);
    __gmpz_sub(__gen_e_acsl_sub,
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_add),
               (__e_acsl_mpz_struct const *)(__gen_e_acsl__2));
    __gmpz_init_set_si(__gen_e_acsl__3,1L);
    __gmpz_init(__gen_e_acsl_add_2);
    __gmpz_add(__gen_e_acsl_add_2,
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_sub),
               (__e_acsl_mpz_struct const *)(__gen_e_acsl__3));
    __gmpz_init(__gen_e_acsl_mul);
    __gmpz_mul(__gen_e_acsl_mul,
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_sizeof),
               (__e_acsl_mpz_struct const *)(__gen_e_acsl_add_2));
    __gmpz_init_set(__gen_e_acsl_size,
                    (__e_acsl_mpz_struct const *)(__gen_e_acsl_mul));
    __e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data,"size",0,
                                 (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
    __gmpz_init_set_si(__gen_e_acsl__4,0L);
    __gen_e_acsl_le = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_size),
                                 (__e_acsl_mpz_struct const *)(__gen_e_acsl__4));
    if (__gen_e_acsl_le <= 0) {
      __e_acsl_mpz_t __gen_e_acsl__5;
      __gmpz_init_set_si(__gen_e_acsl__5,0L);
      __gmpz_init_set(__gen_e_acsl_if,
                      (__e_acsl_mpz_struct const *)(__gen_e_acsl__5));
      __gmpz_clear(__gen_e_acsl__5);
    }
    else {
      __e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data,"size",0,
                                   (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
      __gmpz_init_set(__gen_e_acsl_if,
                      (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
    }
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
      {.values = (void *)0};
    __e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_2,
                                 "__gen_e_acsl_if",0,
                                 (__e_acsl_mpz_struct const *)(__gen_e_acsl_if));
    __gmpz_init_set_ui(__gen_e_acsl__6,18446744073709551615UL);
    __gen_e_acsl_le_2 = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_if),
                                   (__e_acsl_mpz_struct const *)(__gen_e_acsl__6));
    __e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data,
                                 "__gen_e_acsl_if",0,
                                 (__e_acsl_mpz_struct const *)(__gen_e_acsl_if));
    __gen_e_acsl_assert_data_2.blocking = 1;
    __gen_e_acsl_assert_data_2.kind = "RTE";
    __gen_e_acsl_assert_data_2.pred_txt = "(\\let size = sizeof(char) * (((n + 1000) - 3) + 1); size <= 0? 0: size) <=\n18446744073709551615";
    __gen_e_acsl_assert_data_2.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data_2.fct = "f";
    __gen_e_acsl_assert_data_2.line = 6;
    __gen_e_acsl_assert_data_2.name = "offset_lesser_or_eq_than_SIZE_MAX";
    __e_acsl_assert(__gen_e_acsl_le_2 <= 0,& __gen_e_acsl_assert_data_2);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
    __gen_e_acsl_size_2 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_if));
    __gen_e_acsl_valid = __e_acsl_valid((void *)(s + 1 * 3),
                                        __gen_e_acsl_size_2,(void *)s,
                                        (void *)(& s));
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
                                 "\\valid(s + (3 .. n + 1000))",0,
                                 __gen_e_acsl_valid);
    __gen_e_acsl_assert_data.blocking = 1;
    __gen_e_acsl_assert_data.kind = "Precondition";
    __gen_e_acsl_assert_data.pred_txt = "!\\valid(s + (3 .. n + 1000))";
    __gen_e_acsl_assert_data.file = "ranges_in_builtins.c";
    __gen_e_acsl_assert_data.fct = "f";
    __gen_e_acsl_assert_data.line = 6;
    __e_acsl_assert(! __gen_e_acsl_valid,& __gen_e_acsl_assert_data);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
    __gmpz_clear(__gen_e_acsl_size);
    __gmpz_clear(__gen_e_acsl_sizeof);
    __gmpz_clear(__gen_e_acsl_n);
    __gmpz_clear(__gen_e_acsl_);
    __gmpz_clear(__gen_e_acsl_add);
    __gmpz_clear(__gen_e_acsl__2);
    __gmpz_clear(__gen_e_acsl_sub);
    __gmpz_clear(__gen_e_acsl__3);
    __gmpz_clear(__gen_e_acsl_add_2);
    __gmpz_clear(__gen_e_acsl_mul);
    __gmpz_clear(__gen_e_acsl__4);
    __gmpz_clear(__gen_e_acsl_if);
    __gmpz_clear(__gen_e_acsl__6);
  }
  f(s,n);
  __e_acsl_delete_block((void *)(& s));
  return;
}


