/* Generated by Frama-C */
#include "stddef.h"
#include "stdio.h"
#include "stdlib.h"
int main(void)
{
  int __retres;
  __e_acsl_memory_init((int *)0,(char ***)0,(size_t)8);
  {
    int a;
    int b;
    int c;
    __e_acsl_store_block((void *)(& c),(size_t)4);
    __e_acsl_store_block((void *)(& b),(size_t)4);
    __e_acsl_store_block((void *)(& a),(size_t)4);
    __e_acsl_full_init((void *)(& c));
    c = 0;
    __e_acsl_full_init((void *)(& b));
    b = c;
    __e_acsl_full_init((void *)(& a));
    a = b;
    int *d = & a;
    __e_acsl_store_block((void *)(& d),(size_t)8);
    __e_acsl_full_init((void *)(& d));
    {
      int __gen_e_acsl_valid_read;
      int __gen_e_acsl_valid_read_2;
      int __gen_e_acsl_valid_read_3;
      int __gen_e_acsl_separated;
      __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(& a),
                                                    sizeof(int),
                                                    (void *)(& a),(void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&a); */
      __e_acsl_assert(__gen_e_acsl_valid_read,"RTE","main",
                      "separated_guard: \\valid_read(&a)",
                      "tests/memory/separated.c",14);
      __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(& b),
                                                      sizeof(int),
                                                      (void *)(& b),
                                                      (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&b); */
      __e_acsl_assert(__gen_e_acsl_valid_read_2,"RTE","main",
                      "separated_guard: \\valid_read(&b)",
                      "tests/memory/separated.c",14);
      __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(& c),
                                                      sizeof(int),
                                                      (void *)(& c),
                                                      (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&c); */
      __e_acsl_assert(__gen_e_acsl_valid_read_3,"RTE","main",
                      "separated_guard: \\valid_read(&c)",
                      "tests/memory/separated.c",14);
      __gen_e_acsl_separated = __e_acsl_separated((size_t)3,& a,sizeof(int),
                                                  & b,sizeof(int),& c,
                                                  sizeof(int));
      __e_acsl_assert(__gen_e_acsl_separated,"Assertion","main",
                      "\\separated(&a, &b, &c)","tests/memory/separated.c",
                      14);
    }
    /*@ assert \separated(&a, &b, &c); */ ;
    {
      int __gen_e_acsl_valid_read_4;
      int __gen_e_acsl_valid_read_5;
      int __gen_e_acsl_valid_read_6;
      int __gen_e_acsl_initialized;
      int __gen_e_acsl_and;
      int __gen_e_acsl_separated_2;
      __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(& a),
                                                      sizeof(int),
                                                      (void *)(& a),
                                                      (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&a); */
      __e_acsl_assert(__gen_e_acsl_valid_read_4,"RTE","main",
                      "separated_guard: \\valid_read(&a)",
                      "tests/memory/separated.c",15);
      __gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)(& b),
                                                      sizeof(int),
                                                      (void *)(& b),
                                                      (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&b); */
      __e_acsl_assert(__gen_e_acsl_valid_read_5,"RTE","main",
                      "separated_guard: \\valid_read(&b)",
                      "tests/memory/separated.c",15);
      __gen_e_acsl_valid_read_6 = __e_acsl_valid_read((void *)(& c),
                                                      sizeof(int),
                                                      (void *)(& c),
                                                      (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&c); */
      __e_acsl_assert(__gen_e_acsl_valid_read_6,"RTE","main",
                      "separated_guard: \\valid_read(&c)",
                      "tests/memory/separated.c",15);
      __gen_e_acsl_initialized = __e_acsl_initialized((void *)(& d),
                                                      sizeof(int *));
      if (__gen_e_acsl_initialized) {
        int __gen_e_acsl_valid_read_7;
        __gen_e_acsl_valid_read_7 = __e_acsl_valid_read((void *)d,
                                                        sizeof(int),
                                                        (void *)d,
                                                        (void *)(& d));
        __gen_e_acsl_and = __gen_e_acsl_valid_read_7;
      }
      else __gen_e_acsl_and = 0;
      /*@ assert E_ACSL: separated_guard: \valid_read(d); */
      __e_acsl_assert(__gen_e_acsl_and,"RTE","main",
                      "separated_guard: \\valid_read(d)",
                      "tests/memory/separated.c",15);
      __gen_e_acsl_separated_2 = __e_acsl_separated((size_t)4,& a,
                                                    sizeof(int),& b,
                                                    sizeof(int),& c,
                                                    sizeof(int),d,
                                                    sizeof(int));
      __e_acsl_assert(! __gen_e_acsl_separated_2,"Assertion","main",
                      "!\\separated(&a, &b, &c, d)",
                      "tests/memory/separated.c",15);
    }
    /*@ assert ¬\separated(&a, &b, &c, d); */ ;
    __e_acsl_delete_block((void *)(& d));
    __e_acsl_delete_block((void *)(& c));
    __e_acsl_delete_block((void *)(& b));
    __e_acsl_delete_block((void *)(& a));
  }
  {
    double array[20] = {(double)0};
    __e_acsl_store_block((void *)(array),(size_t)160);
    __e_acsl_full_init((void *)(& array));
    {
      int __gen_e_acsl_size;
      int __gen_e_acsl_if;
      int __gen_e_acsl_valid_read_8;
      int __gen_e_acsl_size_2;
      int __gen_e_acsl_if_2;
      int __gen_e_acsl_valid_read_9;
      int __gen_e_acsl_size_3;
      int __gen_e_acsl_if_3;
      int __gen_e_acsl_size_4;
      int __gen_e_acsl_if_4;
      int __gen_e_acsl_separated_3;
      __gen_e_acsl_size = 8 * ((9 - 0) + 1);
      if (__gen_e_acsl_size <= 0) __gen_e_acsl_if = 0;
      else __gen_e_acsl_if = __gen_e_acsl_size;
      __gen_e_acsl_valid_read_8 = __e_acsl_valid_read((void *)((char *)(& array) + 
                                                               8 * 0),
                                                      (size_t)__gen_e_acsl_if,
                                                      (void *)(& array),
                                                      (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&array[0 .. 9]); */
      __e_acsl_assert(__gen_e_acsl_valid_read_8,"RTE","main",
                      "separated_guard: \\valid_read(&array[0 .. 9])",
                      "tests/memory/separated.c",21);
      __gen_e_acsl_size_2 = 8 * ((19 - 10) + 1);
      if (__gen_e_acsl_size_2 <= 0) __gen_e_acsl_if_2 = 0;
      else __gen_e_acsl_if_2 = __gen_e_acsl_size_2;
      __gen_e_acsl_valid_read_9 = __e_acsl_valid_read((void *)((char *)(& array) + 
                                                               8 * 10),
                                                      (size_t)__gen_e_acsl_if_2,
                                                      (void *)(& array),
                                                      (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&array[10 .. 19]); */
      __e_acsl_assert(__gen_e_acsl_valid_read_9,"RTE","main",
                      "separated_guard: \\valid_read(&array[10 .. 19])",
                      "tests/memory/separated.c",21);
      __gen_e_acsl_size_3 = 8 * ((9 - 0) + 1);
      if (__gen_e_acsl_size_3 <= 0) __gen_e_acsl_if_3 = 0;
      else __gen_e_acsl_if_3 = __gen_e_acsl_size_3;
      __gen_e_acsl_size_4 = 8 * ((19 - 10) + 1);
      if (__gen_e_acsl_size_4 <= 0) __gen_e_acsl_if_4 = 0;
      else __gen_e_acsl_if_4 = __gen_e_acsl_size_4;
      __gen_e_acsl_separated_3 = __e_acsl_separated((size_t)2,
                                                    (char *)(& array) + 8 * 0,
                                                    __gen_e_acsl_if_3,
                                                    (char *)(& array) + 
                                                    8 * 10,__gen_e_acsl_if_4);
      __e_acsl_assert(__gen_e_acsl_separated_3,"Assertion","main",
                      "\\separated(&array[0 .. 9], &array[10 .. 19])",
                      "tests/memory/separated.c",21);
    }
    /*@ assert \separated(&array[0 .. 9], &array[10 .. 19]); */ ;
    {
      int __gen_e_acsl_size_5;
      int __gen_e_acsl_if_5;
      int __gen_e_acsl_valid_read_10;
      int __gen_e_acsl_size_6;
      int __gen_e_acsl_if_6;
      int __gen_e_acsl_valid_read_11;
      int __gen_e_acsl_size_7;
      int __gen_e_acsl_if_7;
      int __gen_e_acsl_size_8;
      int __gen_e_acsl_if_8;
      int __gen_e_acsl_separated_4;
      __gen_e_acsl_size_5 = 8 * ((10 - 0) + 1);
      if (__gen_e_acsl_size_5 <= 0) __gen_e_acsl_if_5 = 0;
      else __gen_e_acsl_if_5 = __gen_e_acsl_size_5;
      __gen_e_acsl_valid_read_10 = __e_acsl_valid_read((void *)((char *)(& array) + 
                                                                8 * 0),
                                                       (size_t)__gen_e_acsl_if_5,
                                                       (void *)(& array),
                                                       (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&array[0 .. 10]); */
      __e_acsl_assert(__gen_e_acsl_valid_read_10,"RTE","main",
                      "separated_guard: \\valid_read(&array[0 .. 10])",
                      "tests/memory/separated.c",22);
      __gen_e_acsl_size_6 = 8 * ((15 - 5) + 1);
      if (__gen_e_acsl_size_6 <= 0) __gen_e_acsl_if_6 = 0;
      else __gen_e_acsl_if_6 = __gen_e_acsl_size_6;
      __gen_e_acsl_valid_read_11 = __e_acsl_valid_read((void *)((char *)(& array) + 
                                                                8 * 5),
                                                       (size_t)__gen_e_acsl_if_6,
                                                       (void *)(& array),
                                                       (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&array[5 .. 15]); */
      __e_acsl_assert(__gen_e_acsl_valid_read_11,"RTE","main",
                      "separated_guard: \\valid_read(&array[5 .. 15])",
                      "tests/memory/separated.c",22);
      __gen_e_acsl_size_7 = 8 * ((10 - 0) + 1);
      if (__gen_e_acsl_size_7 <= 0) __gen_e_acsl_if_7 = 0;
      else __gen_e_acsl_if_7 = __gen_e_acsl_size_7;
      __gen_e_acsl_size_8 = 8 * ((15 - 5) + 1);
      if (__gen_e_acsl_size_8 <= 0) __gen_e_acsl_if_8 = 0;
      else __gen_e_acsl_if_8 = __gen_e_acsl_size_8;
      __gen_e_acsl_separated_4 = __e_acsl_separated((size_t)2,
                                                    (char *)(& array) + 8 * 0,
                                                    __gen_e_acsl_if_7,
                                                    (char *)(& array) + 8 * 5,
                                                    __gen_e_acsl_if_8);
      __e_acsl_assert(! __gen_e_acsl_separated_4,"Assertion","main",
                      "!\\separated(&array[0 .. 10], &array[5 .. 15])",
                      "tests/memory/separated.c",22);
    }
    /*@ assert ¬\separated(&array[0 .. 10], &array[5 .. 15]); */ ;
    {
      int __gen_e_acsl_size_9;
      int __gen_e_acsl_if_9;
      int __gen_e_acsl_valid_read_12;
      int __gen_e_acsl_size_10;
      int __gen_e_acsl_if_10;
      int __gen_e_acsl_valid_read_13;
      int __gen_e_acsl_size_11;
      int __gen_e_acsl_if_11;
      int __gen_e_acsl_size_12;
      int __gen_e_acsl_if_12;
      int __gen_e_acsl_separated_5;
      __gen_e_acsl_size_9 = 8 * ((19 - 0) + 1);
      if (__gen_e_acsl_size_9 <= 0) __gen_e_acsl_if_9 = 0;
      else __gen_e_acsl_if_9 = __gen_e_acsl_size_9;
      __gen_e_acsl_valid_read_12 = __e_acsl_valid_read((void *)((char *)(& array) + 
                                                                8 * 0),
                                                       (size_t)__gen_e_acsl_if_9,
                                                       (void *)(& array),
                                                       (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&array[0 .. 19]); */
      __e_acsl_assert(__gen_e_acsl_valid_read_12,"RTE","main",
                      "separated_guard: \\valid_read(&array[0 .. 19])",
                      "tests/memory/separated.c",23);
      __gen_e_acsl_size_10 = 8 * ((15 - 5) + 1);
      if (__gen_e_acsl_size_10 <= 0) __gen_e_acsl_if_10 = 0;
      else __gen_e_acsl_if_10 = __gen_e_acsl_size_10;
      __gen_e_acsl_valid_read_13 = __e_acsl_valid_read((void *)((char *)(& array) + 
                                                                8 * 5),
                                                       (size_t)__gen_e_acsl_if_10,
                                                       (void *)(& array),
                                                       (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&array[5 .. 15]); */
      __e_acsl_assert(__gen_e_acsl_valid_read_13,"RTE","main",
                      "separated_guard: \\valid_read(&array[5 .. 15])",
                      "tests/memory/separated.c",23);
      __gen_e_acsl_size_11 = 8 * ((19 - 0) + 1);
      if (__gen_e_acsl_size_11 <= 0) __gen_e_acsl_if_11 = 0;
      else __gen_e_acsl_if_11 = __gen_e_acsl_size_11;
      __gen_e_acsl_size_12 = 8 * ((15 - 5) + 1);
      if (__gen_e_acsl_size_12 <= 0) __gen_e_acsl_if_12 = 0;
      else __gen_e_acsl_if_12 = __gen_e_acsl_size_12;
      __gen_e_acsl_separated_5 = __e_acsl_separated((size_t)2,
                                                    (char *)(& array) + 8 * 0,
                                                    __gen_e_acsl_if_11,
                                                    (char *)(& array) + 8 * 5,
                                                    __gen_e_acsl_if_12);
      __e_acsl_assert(! __gen_e_acsl_separated_5,"Assertion","main",
                      "!\\separated(&array[0 .. 19], &array[5 .. 15])",
                      "tests/memory/separated.c",23);
    }
    /*@ assert ¬\separated(&array[0 .. 19], &array[5 .. 15]); */ ;
    {
      int __gen_e_acsl_valid_read_14;
      int __gen_e_acsl_valid_read_15;
      int __gen_e_acsl_separated_6;
      __gen_e_acsl_valid_read_14 = __e_acsl_valid_read((void *)(array),
                                                       sizeof(double),
                                                       (void *)(array),
                                                       (void *)(array));
      /*@ assert E_ACSL: separated_guard: \valid_read((double *)array); */
      __e_acsl_assert(__gen_e_acsl_valid_read_14,"RTE","main",
                      "separated_guard: \\valid_read((double *)array)",
                      "tests/memory/separated.c",24);
      __gen_e_acsl_valid_read_15 = __e_acsl_valid_read((void *)(& array[1]),
                                                       sizeof(double),
                                                       (void *)(& array[1]),
                                                       (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&array[1]); */
      __e_acsl_assert(__gen_e_acsl_valid_read_15,"RTE","main",
                      "separated_guard: \\valid_read(&array[1])",
                      "tests/memory/separated.c",24);
      __gen_e_acsl_separated_6 = __e_acsl_separated((size_t)2,array,
                                                    sizeof(double),
                                                    & array[1],
                                                    sizeof(double));
      __e_acsl_assert(__gen_e_acsl_separated_6,"Assertion","main",
                      "\\separated((double *)array, &array[1])",
                      "tests/memory/separated.c",24);
    }
    /*@ assert \separated((double *)array, &array[1]); */ ;
    {
      int __gen_e_acsl_size_13;
      int __gen_e_acsl_if_13;
      int __gen_e_acsl_valid_read_16;
      int __gen_e_acsl_size_14;
      int __gen_e_acsl_if_14;
      int __gen_e_acsl_valid_read_17;
      int __gen_e_acsl_size_15;
      int __gen_e_acsl_if_15;
      int __gen_e_acsl_size_16;
      int __gen_e_acsl_if_16;
      int __gen_e_acsl_separated_7;
      __gen_e_acsl_size_13 = 8 * ((1 - 0) + 1);
      if (__gen_e_acsl_size_13 <= 0) __gen_e_acsl_if_13 = 0;
      else __gen_e_acsl_if_13 = __gen_e_acsl_size_13;
      __gen_e_acsl_valid_read_16 = __e_acsl_valid_read((void *)((char *)(& array) + 
                                                                8 * 0),
                                                       (size_t)__gen_e_acsl_if_13,
                                                       (void *)(& array),
                                                       (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&array[0 .. 1]); */
      __e_acsl_assert(__gen_e_acsl_valid_read_16,"RTE","main",
                      "separated_guard: \\valid_read(&array[0 .. 1])",
                      "tests/memory/separated.c",25);
      __gen_e_acsl_size_14 = 8 * ((2 - 1) + 1);
      if (__gen_e_acsl_size_14 <= 0) __gen_e_acsl_if_14 = 0;
      else __gen_e_acsl_if_14 = __gen_e_acsl_size_14;
      __gen_e_acsl_valid_read_17 = __e_acsl_valid_read((void *)((char *)(& array) + 
                                                                8 * 1),
                                                       (size_t)__gen_e_acsl_if_14,
                                                       (void *)(& array),
                                                       (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&array[1 .. 2]); */
      __e_acsl_assert(__gen_e_acsl_valid_read_17,"RTE","main",
                      "separated_guard: \\valid_read(&array[1 .. 2])",
                      "tests/memory/separated.c",25);
      __gen_e_acsl_size_15 = 8 * ((1 - 0) + 1);
      if (__gen_e_acsl_size_15 <= 0) __gen_e_acsl_if_15 = 0;
      else __gen_e_acsl_if_15 = __gen_e_acsl_size_15;
      __gen_e_acsl_size_16 = 8 * ((2 - 1) + 1);
      if (__gen_e_acsl_size_16 <= 0) __gen_e_acsl_if_16 = 0;
      else __gen_e_acsl_if_16 = __gen_e_acsl_size_16;
      __gen_e_acsl_separated_7 = __e_acsl_separated((size_t)2,
                                                    (char *)(& array) + 8 * 0,
                                                    __gen_e_acsl_if_15,
                                                    (char *)(& array) + 8 * 1,
                                                    __gen_e_acsl_if_16);
      __e_acsl_assert(! __gen_e_acsl_separated_7,"Assertion","main",
                      "!\\separated(&array[0 .. 1], &array[1 .. 2])",
                      "tests/memory/separated.c",25);
    }
    /*@ assert ¬\separated(&array[0 .. 1], &array[1 .. 2]); */ ;
    {
      int __gen_e_acsl_size_17;
      int __gen_e_acsl_if_17;
      int __gen_e_acsl_valid_read_18;
      int __gen_e_acsl_size_18;
      int __gen_e_acsl_if_18;
      int __gen_e_acsl_valid_read_19;
      int __gen_e_acsl_size_19;
      int __gen_e_acsl_if_19;
      int __gen_e_acsl_size_20;
      int __gen_e_acsl_if_20;
      int __gen_e_acsl_separated_8;
      __gen_e_acsl_size_17 = 8 * ((5 - 15) + 1);
      if (__gen_e_acsl_size_17 <= 0) __gen_e_acsl_if_17 = 0;
      else __gen_e_acsl_if_17 = __gen_e_acsl_size_17;
      __gen_e_acsl_valid_read_18 = __e_acsl_valid_read((void *)((char *)(& array) + 
                                                                8 * 15),
                                                       (size_t)__gen_e_acsl_if_17,
                                                       (void *)(& array),
                                                       (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&array[15 .. 5]); */
      __e_acsl_assert(__gen_e_acsl_valid_read_18,"RTE","main",
                      "separated_guard: \\valid_read(&array[15 .. 5])",
                      "tests/memory/separated.c",26);
      __gen_e_acsl_size_18 = 8 * ((19 - 0) + 1);
      if (__gen_e_acsl_size_18 <= 0) __gen_e_acsl_if_18 = 0;
      else __gen_e_acsl_if_18 = __gen_e_acsl_size_18;
      __gen_e_acsl_valid_read_19 = __e_acsl_valid_read((void *)((char *)(& array) + 
                                                                8 * 0),
                                                       (size_t)__gen_e_acsl_if_18,
                                                       (void *)(& array),
                                                       (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&array[0 .. 19]); */
      __e_acsl_assert(__gen_e_acsl_valid_read_19,"RTE","main",
                      "separated_guard: \\valid_read(&array[0 .. 19])",
                      "tests/memory/separated.c",26);
      __gen_e_acsl_size_19 = 8 * ((5 - 15) + 1);
      if (__gen_e_acsl_size_19 <= 0) __gen_e_acsl_if_19 = 0;
      else __gen_e_acsl_if_19 = __gen_e_acsl_size_19;
      __gen_e_acsl_size_20 = 8 * ((19 - 0) + 1);
      if (__gen_e_acsl_size_20 <= 0) __gen_e_acsl_if_20 = 0;
      else __gen_e_acsl_if_20 = __gen_e_acsl_size_20;
      __gen_e_acsl_separated_8 = __e_acsl_separated((size_t)2,
                                                    (char *)(& array) + 
                                                    8 * 15,
                                                    __gen_e_acsl_if_19,
                                                    (char *)(& array) + 8 * 0,
                                                    __gen_e_acsl_if_20);
      __e_acsl_assert(__gen_e_acsl_separated_8,"Assertion","main",
                      "\\separated(&array[15 .. 5], &array[0 .. 19])",
                      "tests/memory/separated.c",26);
    }
    /*@ assert \separated(&array[15 .. 5], &array[0 .. 19]); */ ;
    {
      int __gen_e_acsl_size_21;
      int __gen_e_acsl_if_21;
      int __gen_e_acsl_valid_read_20;
      int __gen_e_acsl_size_22;
      int __gen_e_acsl_if_22;
      int __gen_e_acsl_valid_read_21;
      int __gen_e_acsl_size_23;
      int __gen_e_acsl_if_23;
      int __gen_e_acsl_size_24;
      int __gen_e_acsl_if_24;
      int __gen_e_acsl_separated_9;
      __gen_e_acsl_size_21 = 8 * ((-3 - 0) + 1);
      if (__gen_e_acsl_size_21 <= 0) __gen_e_acsl_if_21 = 0;
      else __gen_e_acsl_if_21 = __gen_e_acsl_size_21;
      __gen_e_acsl_valid_read_20 = __e_acsl_valid_read((void *)((char *)(& array) + 
                                                                8 * 0),
                                                       (size_t)__gen_e_acsl_if_21,
                                                       (void *)(& array),
                                                       (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&array[0 .. -3]); */
      __e_acsl_assert(__gen_e_acsl_valid_read_20,"RTE","main",
                      "separated_guard: \\valid_read(&array[0 .. -3])",
                      "tests/memory/separated.c",27);
      __gen_e_acsl_size_22 = 8 * ((19 - 0) + 1);
      if (__gen_e_acsl_size_22 <= 0) __gen_e_acsl_if_22 = 0;
      else __gen_e_acsl_if_22 = __gen_e_acsl_size_22;
      __gen_e_acsl_valid_read_21 = __e_acsl_valid_read((void *)((char *)(& array) + 
                                                                8 * 0),
                                                       (size_t)__gen_e_acsl_if_22,
                                                       (void *)(& array),
                                                       (void *)0);
      /*@ assert E_ACSL: separated_guard: \valid_read(&array[0 .. 19]); */
      __e_acsl_assert(__gen_e_acsl_valid_read_21,"RTE","main",
                      "separated_guard: \\valid_read(&array[0 .. 19])",
                      "tests/memory/separated.c",27);
      __gen_e_acsl_size_23 = 8 * ((-3 - 0) + 1);
      if (__gen_e_acsl_size_23 <= 0) __gen_e_acsl_if_23 = 0;
      else __gen_e_acsl_if_23 = __gen_e_acsl_size_23;
      __gen_e_acsl_size_24 = 8 * ((19 - 0) + 1);
      if (__gen_e_acsl_size_24 <= 0) __gen_e_acsl_if_24 = 0;
      else __gen_e_acsl_if_24 = __gen_e_acsl_size_24;
      __gen_e_acsl_separated_9 = __e_acsl_separated((size_t)2,
                                                    (char *)(& array) + 8 * 0,
                                                    __gen_e_acsl_if_23,
                                                    (char *)(& array) + 8 * 0,
                                                    __gen_e_acsl_if_24);
      __e_acsl_assert(__gen_e_acsl_separated_9,"Assertion","main",
                      "\\separated(&array[0 .. -3], &array[0 .. 19])",
                      "tests/memory/separated.c",27);
    }
    /*@ assert \separated(&array[0 .. -3], &array[0 .. 19]); */ ;
    __e_acsl_delete_block((void *)(array));
  }
  {
    int *a_0 = malloc(sizeof(int));
    __e_acsl_store_block((void *)(& a_0),(size_t)8);
    __e_acsl_full_init((void *)(& a_0));
    int *b_0 = malloc(sizeof(int));
    __e_acsl_store_block((void *)(& b_0),(size_t)8);
    __e_acsl_full_init((void *)(& b_0));
    int *c_0 = a_0;
    __e_acsl_store_block((void *)(& c_0),(size_t)8);
    __e_acsl_full_init((void *)(& c_0));
    {
      int __gen_e_acsl_initialized_2;
      int __gen_e_acsl_and_2;
      int __gen_e_acsl_initialized_3;
      int __gen_e_acsl_and_3;
      int __gen_e_acsl_separated_10;
      __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& a_0),
                                                        sizeof(int *));
      if (__gen_e_acsl_initialized_2) {
        int __gen_e_acsl_valid_read_22;
        __gen_e_acsl_valid_read_22 = __e_acsl_valid_read((void *)a_0,
                                                         sizeof(int),
                                                         (void *)a_0,
                                                         (void *)(& a_0));
        __gen_e_acsl_and_2 = __gen_e_acsl_valid_read_22;
      }
      else __gen_e_acsl_and_2 = 0;
      /*@ assert E_ACSL: separated_guard: \valid_read(a_0); */
      __e_acsl_assert(__gen_e_acsl_and_2,"RTE","main",
                      "separated_guard: \\valid_read(a_0)",
                      "tests/memory/separated.c",36);
      __gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& b_0),
                                                        sizeof(int *));
      if (__gen_e_acsl_initialized_3) {
        int __gen_e_acsl_valid_read_23;
        __gen_e_acsl_valid_read_23 = __e_acsl_valid_read((void *)b_0,
                                                         sizeof(int),
                                                         (void *)b_0,
                                                         (void *)(& b_0));
        __gen_e_acsl_and_3 = __gen_e_acsl_valid_read_23;
      }
      else __gen_e_acsl_and_3 = 0;
      /*@ assert E_ACSL: separated_guard: \valid_read(b_0); */
      __e_acsl_assert(__gen_e_acsl_and_3,"RTE","main",
                      "separated_guard: \\valid_read(b_0)",
                      "tests/memory/separated.c",36);
      __gen_e_acsl_separated_10 = __e_acsl_separated((size_t)2,a_0,
                                                     sizeof(int),b_0,
                                                     sizeof(int));
      __e_acsl_assert(__gen_e_acsl_separated_10,"Assertion","main",
                      "\\separated(a_0, b_0)","tests/memory/separated.c",36);
    }
    /*@ assert \separated(a_0, b_0); */ ;
    {
      int __gen_e_acsl_initialized_4;
      int __gen_e_acsl_and_4;
      int __gen_e_acsl_initialized_5;
      int __gen_e_acsl_and_5;
      int __gen_e_acsl_initialized_6;
      int __gen_e_acsl_and_6;
      int __gen_e_acsl_separated_11;
      __gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& a_0),
                                                        sizeof(int *));
      if (__gen_e_acsl_initialized_4) {
        int __gen_e_acsl_valid_read_24;
        __gen_e_acsl_valid_read_24 = __e_acsl_valid_read((void *)a_0,
                                                         sizeof(int),
                                                         (void *)a_0,
                                                         (void *)(& a_0));
        __gen_e_acsl_and_4 = __gen_e_acsl_valid_read_24;
      }
      else __gen_e_acsl_and_4 = 0;
      /*@ assert E_ACSL: separated_guard: \valid_read(a_0); */
      __e_acsl_assert(__gen_e_acsl_and_4,"RTE","main",
                      "separated_guard: \\valid_read(a_0)",
                      "tests/memory/separated.c",37);
      __gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)(& b_0),
                                                        sizeof(int *));
      if (__gen_e_acsl_initialized_5) {
        int __gen_e_acsl_valid_read_25;
        __gen_e_acsl_valid_read_25 = __e_acsl_valid_read((void *)b_0,
                                                         sizeof(int),
                                                         (void *)b_0,
                                                         (void *)(& b_0));
        __gen_e_acsl_and_5 = __gen_e_acsl_valid_read_25;
      }
      else __gen_e_acsl_and_5 = 0;
      /*@ assert E_ACSL: separated_guard: \valid_read(b_0); */
      __e_acsl_assert(__gen_e_acsl_and_5,"RTE","main",
                      "separated_guard: \\valid_read(b_0)",
                      "tests/memory/separated.c",37);
      __gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(& c_0),
                                                        sizeof(int *));
      if (__gen_e_acsl_initialized_6) {
        int __gen_e_acsl_valid_read_26;
        __gen_e_acsl_valid_read_26 = __e_acsl_valid_read((void *)c_0,
                                                         sizeof(int),
                                                         (void *)c_0,
                                                         (void *)(& c_0));
        __gen_e_acsl_and_6 = __gen_e_acsl_valid_read_26;
      }
      else __gen_e_acsl_and_6 = 0;
      /*@ assert E_ACSL: separated_guard: \valid_read(c_0); */
      __e_acsl_assert(__gen_e_acsl_and_6,"RTE","main",
                      "separated_guard: \\valid_read(c_0)",
                      "tests/memory/separated.c",37);
      __gen_e_acsl_separated_11 = __e_acsl_separated((size_t)3,a_0,
                                                     sizeof(int),b_0,
                                                     sizeof(int),c_0,
                                                     sizeof(int));
      __e_acsl_assert(! __gen_e_acsl_separated_11,"Assertion","main",
                      "!\\separated(a_0, b_0, c_0)",
                      "tests/memory/separated.c",37);
    }
    /*@ assert ¬\separated(a_0, b_0, c_0); */ ;
    free((void *)a_0);
    free((void *)b_0);
    __e_acsl_delete_block((void *)(& c_0));
    __e_acsl_delete_block((void *)(& b_0));
    __e_acsl_delete_block((void *)(& a_0));
  }
  {
    double *array_0 = malloc(sizeof(double [20]));
    __e_acsl_store_block((void *)(& array_0),(size_t)8);
    __e_acsl_full_init((void *)(& array_0));
    {
      int __gen_e_acsl_size_25;
      int __gen_e_acsl_if_25;
      int __gen_e_acsl_valid_read_27;
      int __gen_e_acsl_size_26;
      int __gen_e_acsl_if_26;
      int __gen_e_acsl_valid_read_28;
      int __gen_e_acsl_size_27;
      int __gen_e_acsl_if_27;
      int __gen_e_acsl_size_28;
      int __gen_e_acsl_if_28;
      int __gen_e_acsl_separated_12;
      __gen_e_acsl_size_25 = 8 * ((9 - 0) + 1);
      if (__gen_e_acsl_size_25 <= 0) __gen_e_acsl_if_25 = 0;
      else __gen_e_acsl_if_25 = __gen_e_acsl_size_25;
      __gen_e_acsl_valid_read_27 = __e_acsl_valid_read((void *)((char *)array_0 + 
                                                                8 * 0),
                                                       (size_t)__gen_e_acsl_if_25,
                                                       (void *)array_0,
                                                       (void *)(& array_0));
      /*@ assert E_ACSL: separated_guard: \valid_read(array_0 + (0 .. 9)); */
      __e_acsl_assert(__gen_e_acsl_valid_read_27,"RTE","main",
                      "separated_guard: \\valid_read(array_0 + (0 .. 9))",
                      "tests/memory/separated.c",46);
      __gen_e_acsl_size_26 = 8 * ((19 - 10) + 1);
      if (__gen_e_acsl_size_26 <= 0) __gen_e_acsl_if_26 = 0;
      else __gen_e_acsl_if_26 = __gen_e_acsl_size_26;
      __gen_e_acsl_valid_read_28 = __e_acsl_valid_read((void *)((char *)array_0 + 
                                                                8 * 10),
                                                       (size_t)__gen_e_acsl_if_26,
                                                       (void *)array_0,
                                                       (void *)(& array_0));
      /*@ assert E_ACSL: separated_guard: \valid_read(array_0 + (10 .. 19));
      */
      __e_acsl_assert(__gen_e_acsl_valid_read_28,"RTE","main",
                      "separated_guard: \\valid_read(array_0 + (10 .. 19))",
                      "tests/memory/separated.c",46);
      __gen_e_acsl_size_27 = 8 * ((9 - 0) + 1);
      if (__gen_e_acsl_size_27 <= 0) __gen_e_acsl_if_27 = 0;
      else __gen_e_acsl_if_27 = __gen_e_acsl_size_27;
      __gen_e_acsl_size_28 = 8 * ((19 - 10) + 1);
      if (__gen_e_acsl_size_28 <= 0) __gen_e_acsl_if_28 = 0;
      else __gen_e_acsl_if_28 = __gen_e_acsl_size_28;
      __gen_e_acsl_separated_12 = __e_acsl_separated((size_t)2,
                                                     (char *)array_0 + 8 * 0,
                                                     __gen_e_acsl_if_27,
                                                     (char *)array_0 + 8 * 10,
                                                     __gen_e_acsl_if_28);
      __e_acsl_assert(__gen_e_acsl_separated_12,"Assertion","main",
                      "\\separated(array_0 + (0 .. 9), array_0 + (10 .. 19))",
                      "tests/memory/separated.c",46);
    }
    /*@ assert \separated(array_0 + (0 .. 9), array_0 + (10 .. 19)); */ ;
    {
      int __gen_e_acsl_size_29;
      int __gen_e_acsl_if_29;
      int __gen_e_acsl_valid_read_29;
      int __gen_e_acsl_size_30;
      int __gen_e_acsl_if_30;
      int __gen_e_acsl_valid_read_30;
      int __gen_e_acsl_size_31;
      int __gen_e_acsl_if_31;
      int __gen_e_acsl_size_32;
      int __gen_e_acsl_if_32;
      int __gen_e_acsl_separated_13;
      __gen_e_acsl_size_29 = 8 * ((10 - 0) + 1);
      if (__gen_e_acsl_size_29 <= 0) __gen_e_acsl_if_29 = 0;
      else __gen_e_acsl_if_29 = __gen_e_acsl_size_29;
      __gen_e_acsl_valid_read_29 = __e_acsl_valid_read((void *)((char *)array_0 + 
                                                                8 * 0),
                                                       (size_t)__gen_e_acsl_if_29,
                                                       (void *)array_0,
                                                       (void *)(& array_0));
      /*@ assert E_ACSL: separated_guard: \valid_read(array_0 + (0 .. 10));
      */
      __e_acsl_assert(__gen_e_acsl_valid_read_29,"RTE","main",
                      "separated_guard: \\valid_read(array_0 + (0 .. 10))",
                      "tests/memory/separated.c",47);
      __gen_e_acsl_size_30 = 8 * ((15 - 5) + 1);
      if (__gen_e_acsl_size_30 <= 0) __gen_e_acsl_if_30 = 0;
      else __gen_e_acsl_if_30 = __gen_e_acsl_size_30;
      __gen_e_acsl_valid_read_30 = __e_acsl_valid_read((void *)((char *)array_0 + 
                                                                8 * 5),
                                                       (size_t)__gen_e_acsl_if_30,
                                                       (void *)array_0,
                                                       (void *)(& array_0));
      /*@ assert E_ACSL: separated_guard: \valid_read(array_0 + (5 .. 15));
      */
      __e_acsl_assert(__gen_e_acsl_valid_read_30,"RTE","main",
                      "separated_guard: \\valid_read(array_0 + (5 .. 15))",
                      "tests/memory/separated.c",47);
      __gen_e_acsl_size_31 = 8 * ((10 - 0) + 1);
      if (__gen_e_acsl_size_31 <= 0) __gen_e_acsl_if_31 = 0;
      else __gen_e_acsl_if_31 = __gen_e_acsl_size_31;
      __gen_e_acsl_size_32 = 8 * ((15 - 5) + 1);
      if (__gen_e_acsl_size_32 <= 0) __gen_e_acsl_if_32 = 0;
      else __gen_e_acsl_if_32 = __gen_e_acsl_size_32;
      __gen_e_acsl_separated_13 = __e_acsl_separated((size_t)2,
                                                     (char *)array_0 + 8 * 0,
                                                     __gen_e_acsl_if_31,
                                                     (char *)array_0 + 8 * 5,
                                                     __gen_e_acsl_if_32);
      __e_acsl_assert(! __gen_e_acsl_separated_13,"Assertion","main",
                      "!\\separated(array_0 + (0 .. 10), array_0 + (5 .. 15))",
                      "tests/memory/separated.c",47);
    }
    /*@ assert ¬\separated(array_0 + (0 .. 10), array_0 + (5 .. 15)); */ ;
    {
      int __gen_e_acsl_size_33;
      int __gen_e_acsl_if_33;
      int __gen_e_acsl_valid_read_31;
      int __gen_e_acsl_size_34;
      int __gen_e_acsl_if_34;
      int __gen_e_acsl_valid_read_32;
      int __gen_e_acsl_size_35;
      int __gen_e_acsl_if_35;
      int __gen_e_acsl_size_36;
      int __gen_e_acsl_if_36;
      int __gen_e_acsl_separated_14;
      __gen_e_acsl_size_33 = 8 * ((19 - 0) + 1);
      if (__gen_e_acsl_size_33 <= 0) __gen_e_acsl_if_33 = 0;
      else __gen_e_acsl_if_33 = __gen_e_acsl_size_33;
      __gen_e_acsl_valid_read_31 = __e_acsl_valid_read((void *)((char *)array_0 + 
                                                                8 * 0),
                                                       (size_t)__gen_e_acsl_if_33,
                                                       (void *)array_0,
                                                       (void *)(& array_0));
      /*@ assert E_ACSL: separated_guard: \valid_read(array_0 + (0 .. 19));
      */
      __e_acsl_assert(__gen_e_acsl_valid_read_31,"RTE","main",
                      "separated_guard: \\valid_read(array_0 + (0 .. 19))",
                      "tests/memory/separated.c",48);
      __gen_e_acsl_size_34 = 8 * ((15 - 5) + 1);
      if (__gen_e_acsl_size_34 <= 0) __gen_e_acsl_if_34 = 0;
      else __gen_e_acsl_if_34 = __gen_e_acsl_size_34;
      __gen_e_acsl_valid_read_32 = __e_acsl_valid_read((void *)((char *)array_0 + 
                                                                8 * 5),
                                                       (size_t)__gen_e_acsl_if_34,
                                                       (void *)array_0,
                                                       (void *)(& array_0));
      /*@ assert E_ACSL: separated_guard: \valid_read(array_0 + (5 .. 15));
      */
      __e_acsl_assert(__gen_e_acsl_valid_read_32,"RTE","main",
                      "separated_guard: \\valid_read(array_0 + (5 .. 15))",
                      "tests/memory/separated.c",48);
      __gen_e_acsl_size_35 = 8 * ((19 - 0) + 1);
      if (__gen_e_acsl_size_35 <= 0) __gen_e_acsl_if_35 = 0;
      else __gen_e_acsl_if_35 = __gen_e_acsl_size_35;
      __gen_e_acsl_size_36 = 8 * ((15 - 5) + 1);
      if (__gen_e_acsl_size_36 <= 0) __gen_e_acsl_if_36 = 0;
      else __gen_e_acsl_if_36 = __gen_e_acsl_size_36;
      __gen_e_acsl_separated_14 = __e_acsl_separated((size_t)2,
                                                     (char *)array_0 + 8 * 0,
                                                     __gen_e_acsl_if_35,
                                                     (char *)array_0 + 8 * 5,
                                                     __gen_e_acsl_if_36);
      __e_acsl_assert(! __gen_e_acsl_separated_14,"Assertion","main",
                      "!\\separated(array_0 + (0 .. 19), array_0 + (5 .. 15))",
                      "tests/memory/separated.c",48);
    }
    /*@ assert ¬\separated(array_0 + (0 .. 19), array_0 + (5 .. 15)); */ ;
    {
      int __gen_e_acsl_valid_read_33;
      int __gen_e_acsl_valid_read_34;
      int __gen_e_acsl_separated_15;
      __gen_e_acsl_valid_read_33 = __e_acsl_valid_read((void *)(array_0 + 0),
                                                       sizeof(double),
                                                       (void *)array_0,
                                                       (void *)(& array_0));
      /*@ assert E_ACSL: separated_guard: \valid_read(array_0 + 0); */
      __e_acsl_assert(__gen_e_acsl_valid_read_33,"RTE","main",
                      "separated_guard: \\valid_read(array_0 + 0)",
                      "tests/memory/separated.c",49);
      __gen_e_acsl_valid_read_34 = __e_acsl_valid_read((void *)(array_0 + 1),
                                                       sizeof(double),
                                                       (void *)array_0,
                                                       (void *)(& array_0));
      /*@ assert E_ACSL: separated_guard: \valid_read(array_0 + 1); */
      __e_acsl_assert(__gen_e_acsl_valid_read_34,"RTE","main",
                      "separated_guard: \\valid_read(array_0 + 1)",
                      "tests/memory/separated.c",49);
      __gen_e_acsl_separated_15 = __e_acsl_separated((size_t)2,array_0 + 0,
                                                     sizeof(double),
                                                     array_0 + 1,
                                                     sizeof(double));
      __e_acsl_assert(__gen_e_acsl_separated_15,"Assertion","main",
                      "\\separated(array_0 + 0, array_0 + 1)",
                      "tests/memory/separated.c",49);
    }
    /*@ assert \separated(array_0 + 0, array_0 + 1); */ ;
    {
      int __gen_e_acsl_size_37;
      int __gen_e_acsl_if_37;
      int __gen_e_acsl_valid_read_35;
      int __gen_e_acsl_size_38;
      int __gen_e_acsl_if_38;
      int __gen_e_acsl_valid_read_36;
      int __gen_e_acsl_size_39;
      int __gen_e_acsl_if_39;
      int __gen_e_acsl_size_40;
      int __gen_e_acsl_if_40;
      int __gen_e_acsl_separated_16;
      __gen_e_acsl_size_37 = 8 * ((1 - 0) + 1);
      if (__gen_e_acsl_size_37 <= 0) __gen_e_acsl_if_37 = 0;
      else __gen_e_acsl_if_37 = __gen_e_acsl_size_37;
      __gen_e_acsl_valid_read_35 = __e_acsl_valid_read((void *)((char *)array_0 + 
                                                                8 * 0),
                                                       (size_t)__gen_e_acsl_if_37,
                                                       (void *)array_0,
                                                       (void *)(& array_0));
      /*@ assert E_ACSL: separated_guard: \valid_read(array_0 + (0 .. 1)); */
      __e_acsl_assert(__gen_e_acsl_valid_read_35,"RTE","main",
                      "separated_guard: \\valid_read(array_0 + (0 .. 1))",
                      "tests/memory/separated.c",50);
      __gen_e_acsl_size_38 = 8 * ((2 - 1) + 1);
      if (__gen_e_acsl_size_38 <= 0) __gen_e_acsl_if_38 = 0;
      else __gen_e_acsl_if_38 = __gen_e_acsl_size_38;
      __gen_e_acsl_valid_read_36 = __e_acsl_valid_read((void *)((char *)array_0 + 
                                                                8 * 1),
                                                       (size_t)__gen_e_acsl_if_38,
                                                       (void *)array_0,
                                                       (void *)(& array_0));
      /*@ assert E_ACSL: separated_guard: \valid_read(array_0 + (1 .. 2)); */
      __e_acsl_assert(__gen_e_acsl_valid_read_36,"RTE","main",
                      "separated_guard: \\valid_read(array_0 + (1 .. 2))",
                      "tests/memory/separated.c",50);
      __gen_e_acsl_size_39 = 8 * ((1 - 0) + 1);
      if (__gen_e_acsl_size_39 <= 0) __gen_e_acsl_if_39 = 0;
      else __gen_e_acsl_if_39 = __gen_e_acsl_size_39;
      __gen_e_acsl_size_40 = 8 * ((2 - 1) + 1);
      if (__gen_e_acsl_size_40 <= 0) __gen_e_acsl_if_40 = 0;
      else __gen_e_acsl_if_40 = __gen_e_acsl_size_40;
      __gen_e_acsl_separated_16 = __e_acsl_separated((size_t)2,
                                                     (char *)array_0 + 8 * 0,
                                                     __gen_e_acsl_if_39,
                                                     (char *)array_0 + 8 * 1,
                                                     __gen_e_acsl_if_40);
      __e_acsl_assert(! __gen_e_acsl_separated_16,"Assertion","main",
                      "!\\separated(array_0 + (0 .. 1), array_0 + (1 .. 2))",
                      "tests/memory/separated.c",50);
    }
    /*@ assert ¬\separated(array_0 + (0 .. 1), array_0 + (1 .. 2)); */ ;
    {
      int __gen_e_acsl_size_41;
      int __gen_e_acsl_if_41;
      int __gen_e_acsl_valid_read_37;
      int __gen_e_acsl_size_42;
      int __gen_e_acsl_if_42;
      int __gen_e_acsl_valid_read_38;
      int __gen_e_acsl_size_43;
      int __gen_e_acsl_if_43;
      int __gen_e_acsl_size_44;
      int __gen_e_acsl_if_44;
      int __gen_e_acsl_separated_17;
      __gen_e_acsl_size_41 = 8 * ((5 - 15) + 1);
      if (__gen_e_acsl_size_41 <= 0) __gen_e_acsl_if_41 = 0;
      else __gen_e_acsl_if_41 = __gen_e_acsl_size_41;
      __gen_e_acsl_valid_read_37 = __e_acsl_valid_read((void *)((char *)array_0 + 
                                                                8 * 15),
                                                       (size_t)__gen_e_acsl_if_41,
                                                       (void *)array_0,
                                                       (void *)(& array_0));
      /*@ assert E_ACSL: separated_guard: \valid_read(array_0 + (15 .. 5));
      */
      __e_acsl_assert(__gen_e_acsl_valid_read_37,"RTE","main",
                      "separated_guard: \\valid_read(array_0 + (15 .. 5))",
                      "tests/memory/separated.c",51);
      __gen_e_acsl_size_42 = 8 * ((19 - 0) + 1);
      if (__gen_e_acsl_size_42 <= 0) __gen_e_acsl_if_42 = 0;
      else __gen_e_acsl_if_42 = __gen_e_acsl_size_42;
      __gen_e_acsl_valid_read_38 = __e_acsl_valid_read((void *)((char *)array_0 + 
                                                                8 * 0),
                                                       (size_t)__gen_e_acsl_if_42,
                                                       (void *)array_0,
                                                       (void *)(& array_0));
      /*@ assert E_ACSL: separated_guard: \valid_read(array_0 + (0 .. 19));
      */
      __e_acsl_assert(__gen_e_acsl_valid_read_38,"RTE","main",
                      "separated_guard: \\valid_read(array_0 + (0 .. 19))",
                      "tests/memory/separated.c",51);
      __gen_e_acsl_size_43 = 8 * ((5 - 15) + 1);
      if (__gen_e_acsl_size_43 <= 0) __gen_e_acsl_if_43 = 0;
      else __gen_e_acsl_if_43 = __gen_e_acsl_size_43;
      __gen_e_acsl_size_44 = 8 * ((19 - 0) + 1);
      if (__gen_e_acsl_size_44 <= 0) __gen_e_acsl_if_44 = 0;
      else __gen_e_acsl_if_44 = __gen_e_acsl_size_44;
      __gen_e_acsl_separated_17 = __e_acsl_separated((size_t)2,
                                                     (char *)array_0 + 8 * 15,
                                                     __gen_e_acsl_if_43,
                                                     (char *)array_0 + 8 * 0,
                                                     __gen_e_acsl_if_44);
      __e_acsl_assert(__gen_e_acsl_separated_17,"Assertion","main",
                      "\\separated(array_0 + (15 .. 5), array_0 + (0 .. 19))",
                      "tests/memory/separated.c",51);
    }
    /*@ assert \separated(array_0 + (15 .. 5), array_0 + (0 .. 19)); */ ;
    {
      int __gen_e_acsl_size_45;
      int __gen_e_acsl_if_45;
      int __gen_e_acsl_valid_read_39;
      int __gen_e_acsl_size_46;
      int __gen_e_acsl_if_46;
      int __gen_e_acsl_valid_read_40;
      int __gen_e_acsl_size_47;
      int __gen_e_acsl_if_47;
      int __gen_e_acsl_size_48;
      int __gen_e_acsl_if_48;
      int __gen_e_acsl_separated_18;
      __gen_e_acsl_size_45 = 8 * ((-3 - 0) + 1);
      if (__gen_e_acsl_size_45 <= 0) __gen_e_acsl_if_45 = 0;
      else __gen_e_acsl_if_45 = __gen_e_acsl_size_45;
      __gen_e_acsl_valid_read_39 = __e_acsl_valid_read((void *)((char *)array_0 + 
                                                                8 * 0),
                                                       (size_t)__gen_e_acsl_if_45,
                                                       (void *)array_0,
                                                       (void *)(& array_0));
      /*@ assert E_ACSL: separated_guard: \valid_read(array_0 + (0 .. -3));
      */
      __e_acsl_assert(__gen_e_acsl_valid_read_39,"RTE","main",
                      "separated_guard: \\valid_read(array_0 + (0 .. -3))",
                      "tests/memory/separated.c",52);
      __gen_e_acsl_size_46 = 8 * ((19 - 0) + 1);
      if (__gen_e_acsl_size_46 <= 0) __gen_e_acsl_if_46 = 0;
      else __gen_e_acsl_if_46 = __gen_e_acsl_size_46;
      __gen_e_acsl_valid_read_40 = __e_acsl_valid_read((void *)((char *)array_0 + 
                                                                8 * 0),
                                                       (size_t)__gen_e_acsl_if_46,
                                                       (void *)array_0,
                                                       (void *)(& array_0));
      /*@ assert E_ACSL: separated_guard: \valid_read(array_0 + (0 .. 19));
      */
      __e_acsl_assert(__gen_e_acsl_valid_read_40,"RTE","main",
                      "separated_guard: \\valid_read(array_0 + (0 .. 19))",
                      "tests/memory/separated.c",52);
      __gen_e_acsl_size_47 = 8 * ((-3 - 0) + 1);
      if (__gen_e_acsl_size_47 <= 0) __gen_e_acsl_if_47 = 0;
      else __gen_e_acsl_if_47 = __gen_e_acsl_size_47;
      __gen_e_acsl_size_48 = 8 * ((19 - 0) + 1);
      if (__gen_e_acsl_size_48 <= 0) __gen_e_acsl_if_48 = 0;
      else __gen_e_acsl_if_48 = __gen_e_acsl_size_48;
      __gen_e_acsl_separated_18 = __e_acsl_separated((size_t)2,
                                                     (char *)array_0 + 8 * 0,
                                                     __gen_e_acsl_if_47,
                                                     (char *)array_0 + 8 * 0,
                                                     __gen_e_acsl_if_48);
      __e_acsl_assert(__gen_e_acsl_separated_18,"Assertion","main",
                      "\\separated(array_0 + (0 .. -3), array_0 + (0 .. 19))",
                      "tests/memory/separated.c",52);
    }
    /*@ assert \separated(array_0 + (0 .. -3), array_0 + (0 .. 19)); */ ;
    free((void *)array_0);
    __e_acsl_delete_block((void *)(& array_0));
  }
  {
    double array_1[10][10][10] = {{{(double)0}}};
    __e_acsl_store_block((void *)(array_1),(size_t)8000);
    __e_acsl_full_init((void *)(& array_1));
    {
      int __gen_e_acsl_forall;
      int __gen_e_acsl_range;
      int __gen_e_acsl_forall_2;
      int __gen_e_acsl_range_2;
      int __gen_e_acsl_forall_3;
      int __gen_e_acsl_range_3;
      int __gen_e_acsl_forall_4;
      int __gen_e_acsl_range_4;
      __gen_e_acsl_forall = 1;
      __gen_e_acsl_range = 0;
      while (1) {
        if (__gen_e_acsl_range <= 2) ; else break;
        {
          int __gen_e_acsl_valid_read_41;
          __gen_e_acsl_valid_read_41 = __e_acsl_valid_read((void *)(& array_1[0][__gen_e_acsl_range][0]),
                                                           sizeof(double),
                                                           (void *)(& array_1[0][__gen_e_acsl_range][0]),
                                                           (void *)0);
          if (__gen_e_acsl_valid_read_41) ;
          else {
            __gen_e_acsl_forall = 0;
            goto e_acsl_end_loop1;
          }
        }
        __gen_e_acsl_range ++;
      }
      e_acsl_end_loop1: ;
      /*@ assert
          E_ACSL: separated_guard: \valid_read(&array_1[0][0 .. 2][0]);
      */
      __e_acsl_assert(__gen_e_acsl_forall,"RTE","main",
                      "separated_guard: \\valid_read(&array_1[0][0 .. 2][0])",
                      "tests/memory/separated.c",60);
      __gen_e_acsl_forall_2 = 1;
      __gen_e_acsl_range_2 = 3;
      while (1) {
        if (__gen_e_acsl_range_2 <= 5) ; else break;
        {
          int __gen_e_acsl_valid_read_42;
          __gen_e_acsl_valid_read_42 = __e_acsl_valid_read((void *)(& array_1[0][__gen_e_acsl_range_2][0]),
                                                           sizeof(double),
                                                           (void *)(& array_1[0][__gen_e_acsl_range_2][0]),
                                                           (void *)0);
          if (__gen_e_acsl_valid_read_42) ;
          else {
            __gen_e_acsl_forall_2 = 0;
            goto e_acsl_end_loop2;
          }
        }
        __gen_e_acsl_range_2 ++;
      }
      e_acsl_end_loop2: ;
      /*@ assert
          E_ACSL: separated_guard: \valid_read(&array_1[0][3 .. 5][0]);
      */
      __e_acsl_assert(__gen_e_acsl_forall_2,"RTE","main",
                      "separated_guard: \\valid_read(&array_1[0][3 .. 5][0])",
                      "tests/memory/separated.c",60);
      __gen_e_acsl_forall_3 = 1;
      __gen_e_acsl_range_3 = 6;
      while (1) {
        if (__gen_e_acsl_range_3 <= 9) ; else break;
        {
          int __gen_e_acsl_valid_read_43;
          __gen_e_acsl_valid_read_43 = __e_acsl_valid_read((void *)(& array_1[0][__gen_e_acsl_range_3][0]),
                                                           sizeof(double),
                                                           (void *)(& array_1[0][__gen_e_acsl_range_3][0]),
                                                           (void *)0);
          if (__gen_e_acsl_valid_read_43) ;
          else {
            __gen_e_acsl_forall_3 = 0;
            goto e_acsl_end_loop3;
          }
        }
        __gen_e_acsl_range_3 ++;
      }
      e_acsl_end_loop3: ;
      /*@ assert
          E_ACSL: separated_guard: \valid_read(&array_1[0][6 .. 9][0]);
      */
      __e_acsl_assert(__gen_e_acsl_forall_3,"RTE","main",
                      "separated_guard: \\valid_read(&array_1[0][6 .. 9][0])",
                      "tests/memory/separated.c",60);
      __gen_e_acsl_forall_4 = 1;
      __gen_e_acsl_range_4 = 6;
      while (1) {
        if (__gen_e_acsl_range_4 <= 9) ; else break;
        {
          int __gen_e_acsl_forall_5;
          int __gen_e_acsl_range_5;
          __gen_e_acsl_forall_5 = 1;
          __gen_e_acsl_range_5 = 3;
          while (1) {
            if (__gen_e_acsl_range_5 <= 5) ; else break;
            {
              int __gen_e_acsl_forall_6;
              int __gen_e_acsl_range_6;
              __gen_e_acsl_forall_6 = 1;
              __gen_e_acsl_range_6 = 0;
              while (1) {
                if (__gen_e_acsl_range_6 <= 2) ; else break;
                {
                  int __gen_e_acsl_valid_read_44;
                  int __gen_e_acsl_valid_read_45;
                  int __gen_e_acsl_valid_read_46;
                  int __gen_e_acsl_separated_19;
                  __gen_e_acsl_valid_read_44 = __e_acsl_valid_read((void *)(& array_1[0][__gen_e_acsl_range_6][0]),
                                                                   sizeof(double),
                                                                   (void *)(& array_1[0][__gen_e_acsl_range_6][0]),
                                                                   (void *)0);
                  /*@ assert
                      E_ACSL: separated_guard:
                        \valid_read(&array_1[0][range_6][0]);
                  */
                  __e_acsl_assert(__gen_e_acsl_valid_read_44,"RTE","main",
                                  "separated_guard: \\valid_read(&array_1[0][range_6][0])",
                                  "tests/memory/separated.c",60);
                  __gen_e_acsl_valid_read_45 = __e_acsl_valid_read((void *)(& array_1[0][__gen_e_acsl_range_5][0]),
                                                                   sizeof(double),
                                                                   (void *)(& array_1[0][__gen_e_acsl_range_5][0]),
                                                                   (void *)0);
                  /*@ assert
                      E_ACSL: separated_guard:
                        \valid_read(&array_1[0][range_5][0]);
                  */
                  __e_acsl_assert(__gen_e_acsl_valid_read_45,"RTE","main",
                                  "separated_guard: \\valid_read(&array_1[0][range_5][0])",
                                  "tests/memory/separated.c",60);
                  __gen_e_acsl_valid_read_46 = __e_acsl_valid_read((void *)(& array_1[0][__gen_e_acsl_range_4][0]),
                                                                   sizeof(double),
                                                                   (void *)(& array_1[0][__gen_e_acsl_range_4][0]),
                                                                   (void *)0);
                  /*@ assert
                      E_ACSL: separated_guard:
                        \valid_read(&array_1[0][range_4][0]);
                  */
                  __e_acsl_assert(__gen_e_acsl_valid_read_46,"RTE","main",
                                  "separated_guard: \\valid_read(&array_1[0][range_4][0])",
                                  "tests/memory/separated.c",60);
                  __gen_e_acsl_separated_19 = __e_acsl_separated((size_t)3,
                                                                 & array_1[0][__gen_e_acsl_range_6][0],
                                                                 sizeof(double),
                                                                 & array_1[0][__gen_e_acsl_range_5][0],
                                                                 sizeof(double),
                                                                 & array_1[0][__gen_e_acsl_range_4][0],
                                                                 sizeof(double));
                  if (__gen_e_acsl_separated_19) ;
                  else {
                    __gen_e_acsl_forall_6 = 0;
                    goto e_acsl_end_loop4;
                  }
                }
                __gen_e_acsl_range_6 ++;
              }
              e_acsl_end_loop4: ;
              if (__gen_e_acsl_forall_6) ;
              else {
                __gen_e_acsl_forall_5 = 0;
                goto e_acsl_end_loop5;
              }
            }
            __gen_e_acsl_range_5 ++;
          }
          e_acsl_end_loop5: ;
          if (__gen_e_acsl_forall_5) ;
          else {
            __gen_e_acsl_forall_4 = 0;
            goto e_acsl_end_loop6;
          }
        }
        __gen_e_acsl_range_4 ++;
      }
      e_acsl_end_loop6: ;
      __e_acsl_assert(__gen_e_acsl_forall_4,"Assertion","main",
                      "\\separated(\n  &array_1[0][0 .. 2][0], &array_1[0][3 .. 5][0], &array_1[0][6 .. 9][0]\n  )",
                      "tests/memory/separated.c",60);
    }
    /*@
    assert
    \separated(
      &array_1[0][0 .. 2][0], &array_1[0][3 .. 5][0], &array_1[0][6 .. 9][0]
      );
     */
    ;
    {
      int __gen_e_acsl_forall_7;
      int __gen_e_acsl_range_7;
      int __gen_e_acsl_forall_8;
      int __gen_e_acsl_range_8;
      int __gen_e_acsl_forall_9;
      int __gen_e_acsl_range_9;
      int __gen_e_acsl_forall_10;
      int __gen_e_acsl_range_10;
      __gen_e_acsl_forall_7 = 1;
      __gen_e_acsl_range_7 = 0;
      while (1) {
        if (__gen_e_acsl_range_7 <= 2) ; else break;
        {
          int __gen_e_acsl_valid_read_47;
          __gen_e_acsl_valid_read_47 = __e_acsl_valid_read((void *)(& array_1[0][__gen_e_acsl_range_7][0]),
                                                           sizeof(double),
                                                           (void *)(& array_1[0][__gen_e_acsl_range_7][0]),
                                                           (void *)0);
          if (__gen_e_acsl_valid_read_47) ;
          else {
            __gen_e_acsl_forall_7 = 0;
            goto e_acsl_end_loop7;
          }
        }
        __gen_e_acsl_range_7 ++;
      }
      e_acsl_end_loop7: ;
      /*@ assert
          E_ACSL: separated_guard: \valid_read(&array_1[0][0 .. 2][0]);
      */
      __e_acsl_assert(__gen_e_acsl_forall_7,"RTE","main",
                      "separated_guard: \\valid_read(&array_1[0][0 .. 2][0])",
                      "tests/memory/separated.c",61);
      __gen_e_acsl_forall_8 = 1;
      __gen_e_acsl_range_8 = 0;
      while (1) {
        if (__gen_e_acsl_range_8 <= 2) ; else break;
        {
          int __gen_e_acsl_valid_read_48;
          __gen_e_acsl_valid_read_48 = __e_acsl_valid_read((void *)(& array_1[1][__gen_e_acsl_range_8][0]),
                                                           sizeof(double),
                                                           (void *)(& array_1[1][__gen_e_acsl_range_8][0]),
                                                           (void *)0);
          if (__gen_e_acsl_valid_read_48) ;
          else {
            __gen_e_acsl_forall_8 = 0;
            goto e_acsl_end_loop8;
          }
        }
        __gen_e_acsl_range_8 ++;
      }
      e_acsl_end_loop8: ;
      /*@ assert
          E_ACSL: separated_guard: \valid_read(&array_1[1][0 .. 2][0]);
      */
      __e_acsl_assert(__gen_e_acsl_forall_8,"RTE","main",
                      "separated_guard: \\valid_read(&array_1[1][0 .. 2][0])",
                      "tests/memory/separated.c",61);
      __gen_e_acsl_forall_9 = 1;
      __gen_e_acsl_range_9 = 0;
      while (1) {
        if (__gen_e_acsl_range_9 <= 2) ; else break;
        {
          int __gen_e_acsl_valid_read_49;
          __gen_e_acsl_valid_read_49 = __e_acsl_valid_read((void *)(& array_1[2][__gen_e_acsl_range_9][0]),
                                                           sizeof(double),
                                                           (void *)(& array_1[2][__gen_e_acsl_range_9][0]),
                                                           (void *)0);
          if (__gen_e_acsl_valid_read_49) ;
          else {
            __gen_e_acsl_forall_9 = 0;
            goto e_acsl_end_loop9;
          }
        }
        __gen_e_acsl_range_9 ++;
      }
      e_acsl_end_loop9: ;
      /*@ assert
          E_ACSL: separated_guard: \valid_read(&array_1[2][0 .. 2][0]);
      */
      __e_acsl_assert(__gen_e_acsl_forall_9,"RTE","main",
                      "separated_guard: \\valid_read(&array_1[2][0 .. 2][0])",
                      "tests/memory/separated.c",61);
      __gen_e_acsl_forall_10 = 1;
      __gen_e_acsl_range_10 = 0;
      while (1) {
        if (__gen_e_acsl_range_10 <= 2) ; else break;
        {
          int __gen_e_acsl_forall_11;
          int __gen_e_acsl_range_11;
          __gen_e_acsl_forall_11 = 1;
          __gen_e_acsl_range_11 = 0;
          while (1) {
            if (__gen_e_acsl_range_11 <= 2) ; else break;
            {
              int __gen_e_acsl_forall_12;
              int __gen_e_acsl_range_12;
              __gen_e_acsl_forall_12 = 1;
              __gen_e_acsl_range_12 = 0;
              while (1) {
                if (__gen_e_acsl_range_12 <= 2) ; else break;
                {
                  int __gen_e_acsl_valid_read_50;
                  int __gen_e_acsl_valid_read_51;
                  int __gen_e_acsl_valid_read_52;
                  int __gen_e_acsl_separated_20;
                  __gen_e_acsl_valid_read_50 = __e_acsl_valid_read((void *)(& array_1[0][__gen_e_acsl_range_12][0]),
                                                                   sizeof(double),
                                                                   (void *)(& array_1[0][__gen_e_acsl_range_12][0]),
                                                                   (void *)0);
                  /*@ assert
                      E_ACSL: separated_guard:
                        \valid_read(&array_1[0][range_12][0]);
                  */
                  __e_acsl_assert(__gen_e_acsl_valid_read_50,"RTE","main",
                                  "separated_guard: \\valid_read(&array_1[0][range_12][0])",
                                  "tests/memory/separated.c",61);
                  __gen_e_acsl_valid_read_51 = __e_acsl_valid_read((void *)(& array_1[1][__gen_e_acsl_range_11][0]),
                                                                   sizeof(double),
                                                                   (void *)(& array_1[1][__gen_e_acsl_range_11][0]),
                                                                   (void *)0);
                  /*@ assert
                      E_ACSL: separated_guard:
                        \valid_read(&array_1[1][range_11][0]);
                  */
                  __e_acsl_assert(__gen_e_acsl_valid_read_51,"RTE","main",
                                  "separated_guard: \\valid_read(&array_1[1][range_11][0])",
                                  "tests/memory/separated.c",61);
                  __gen_e_acsl_valid_read_52 = __e_acsl_valid_read((void *)(& array_1[2][__gen_e_acsl_range_10][0]),
                                                                   sizeof(double),
                                                                   (void *)(& array_1[2][__gen_e_acsl_range_10][0]),
                                                                   (void *)0);
                  /*@ assert
                      E_ACSL: separated_guard:
                        \valid_read(&array_1[2][range_10][0]);
                  */
                  __e_acsl_assert(__gen_e_acsl_valid_read_52,"RTE","main",
                                  "separated_guard: \\valid_read(&array_1[2][range_10][0])",
                                  "tests/memory/separated.c",61);
                  __gen_e_acsl_separated_20 = __e_acsl_separated((size_t)3,
                                                                 & array_1[0][__gen_e_acsl_range_12][0],
                                                                 sizeof(double),
                                                                 & array_1[1][__gen_e_acsl_range_11][0],
                                                                 sizeof(double),
                                                                 & array_1[2][__gen_e_acsl_range_10][0],
                                                                 sizeof(double));
                  if (__gen_e_acsl_separated_20) ;
                  else {
                    __gen_e_acsl_forall_12 = 0;
                    goto e_acsl_end_loop10;
                  }
                }
                __gen_e_acsl_range_12 ++;
              }
              e_acsl_end_loop10: ;
              if (__gen_e_acsl_forall_12) ;
              else {
                __gen_e_acsl_forall_11 = 0;
                goto e_acsl_end_loop11;
              }
            }
            __gen_e_acsl_range_11 ++;
          }
          e_acsl_end_loop11: ;
          if (__gen_e_acsl_forall_11) ;
          else {
            __gen_e_acsl_forall_10 = 0;
            goto e_acsl_end_loop12;
          }
        }
        __gen_e_acsl_range_10 ++;
      }
      e_acsl_end_loop12: ;
      __e_acsl_assert(__gen_e_acsl_forall_10,"Assertion","main",
                      "\\separated(\n  &array_1[0][0 .. 2][0], &array_1[1][0 .. 2][0], &array_1[2][0 .. 2][0]\n  )",
                      "tests/memory/separated.c",61);
    }
    /*@
    assert
    \separated(
      &array_1[0][0 .. 2][0], &array_1[1][0 .. 2][0], &array_1[2][0 .. 2][0]
      );
     */
    ;
    {
      int __gen_e_acsl_forall_13;
      int __gen_e_acsl_range_14;
      int __gen_e_acsl_forall_15;
      int __gen_e_acsl_range_16;
      int __gen_e_acsl_forall_17;
      int __gen_e_acsl_range_18;
      __gen_e_acsl_forall_13 = 1;
      __gen_e_acsl_range_14 = 0;
      while (1) {
        if (__gen_e_acsl_range_14 <= 2) ; else break;
        {
          int __gen_e_acsl_forall_14;
          int __gen_e_acsl_range_13;
          __gen_e_acsl_forall_14 = 1;
          __gen_e_acsl_range_13 = 0;
          while (1) {
            if (__gen_e_acsl_range_13 <= 2) ; else break;
            {
              int __gen_e_acsl_valid_read_53;
              __gen_e_acsl_valid_read_53 = __e_acsl_valid_read((void *)(& array_1[__gen_e_acsl_range_13][__gen_e_acsl_range_14][0]),
                                                               sizeof(double),
                                                               (void *)(& array_1[__gen_e_acsl_range_13][__gen_e_acsl_range_14][0]),
                                                               (void *)0);
              if (__gen_e_acsl_valid_read_53) ;
              else {
                __gen_e_acsl_forall_14 = 0;
                goto e_acsl_end_loop13;
              }
            }
            __gen_e_acsl_range_13 ++;
          }
          e_acsl_end_loop13: ;
          if (__gen_e_acsl_forall_14) ;
          else {
            __gen_e_acsl_forall_13 = 0;
            goto e_acsl_end_loop14;
          }
        }
        __gen_e_acsl_range_14 ++;
      }
      e_acsl_end_loop14: ;
      /*@ assert
          E_ACSL: separated_guard: \valid_read(&array_1[0 .. 2][0 .. 2][0]);
      */
      __e_acsl_assert(__gen_e_acsl_forall_13,"RTE","main",
                      "separated_guard: \\valid_read(&array_1[0 .. 2][0 .. 2][0])",
                      "tests/memory/separated.c",62);
      __gen_e_acsl_forall_15 = 1;
      __gen_e_acsl_range_16 = 3;
      while (1) {
        if (__gen_e_acsl_range_16 <= 5) ; else break;
        {
          int __gen_e_acsl_forall_16;
          int __gen_e_acsl_range_15;
          __gen_e_acsl_forall_16 = 1;
          __gen_e_acsl_range_15 = 0;
          while (1) {
            if (__gen_e_acsl_range_15 <= 2) ; else break;
            {
              int __gen_e_acsl_valid_read_54;
              __gen_e_acsl_valid_read_54 = __e_acsl_valid_read((void *)(& array_1[__gen_e_acsl_range_15][__gen_e_acsl_range_16][0]),
                                                               sizeof(double),
                                                               (void *)(& array_1[__gen_e_acsl_range_15][__gen_e_acsl_range_16][0]),
                                                               (void *)0);
              if (__gen_e_acsl_valid_read_54) ;
              else {
                __gen_e_acsl_forall_16 = 0;
                goto e_acsl_end_loop15;
              }
            }
            __gen_e_acsl_range_15 ++;
          }
          e_acsl_end_loop15: ;
          if (__gen_e_acsl_forall_16) ;
          else {
            __gen_e_acsl_forall_15 = 0;
            goto e_acsl_end_loop16;
          }
        }
        __gen_e_acsl_range_16 ++;
      }
      e_acsl_end_loop16: ;
      /*@ assert
          E_ACSL: separated_guard: \valid_read(&array_1[0 .. 2][3 .. 5][0]);
      */
      __e_acsl_assert(__gen_e_acsl_forall_15,"RTE","main",
                      "separated_guard: \\valid_read(&array_1[0 .. 2][3 .. 5][0])",
                      "tests/memory/separated.c",62);
      __gen_e_acsl_forall_17 = 1;
      __gen_e_acsl_range_18 = 3;
      while (1) {
        if (__gen_e_acsl_range_18 <= 5) ; else break;
        {
          int __gen_e_acsl_forall_18;
          int __gen_e_acsl_range_17;
          __gen_e_acsl_forall_18 = 1;
          __gen_e_acsl_range_17 = 0;
          while (1) {
            if (__gen_e_acsl_range_17 <= 2) ; else break;
            {
              int __gen_e_acsl_forall_19;
              int __gen_e_acsl_range_20;
              __gen_e_acsl_forall_19 = 1;
              __gen_e_acsl_range_20 = 0;
              while (1) {
                if (__gen_e_acsl_range_20 <= 2) ; else break;
                {
                  int __gen_e_acsl_forall_20;
                  int __gen_e_acsl_range_19;
                  __gen_e_acsl_forall_20 = 1;
                  __gen_e_acsl_range_19 = 0;
                  while (1) {
                    if (__gen_e_acsl_range_19 <= 2) ; else break;
                    {
                      int __gen_e_acsl_valid_read_55;
                      int __gen_e_acsl_valid_read_56;
                      int __gen_e_acsl_separated_21;
                      __gen_e_acsl_valid_read_55 = __e_acsl_valid_read
                      ((void *)(& array_1[__gen_e_acsl_range_19][__gen_e_acsl_range_20][0]),
                       sizeof(double),
                       (void *)(& array_1[__gen_e_acsl_range_19][__gen_e_acsl_range_20][0]),
                       (void *)0);
                      /*@ assert
                          E_ACSL: separated_guard:
                            \valid_read(&array_1[range_19][range_20][0]);
                      */
                      __e_acsl_assert(__gen_e_acsl_valid_read_55,"RTE",
                                      "main",
                                      "separated_guard: \\valid_read(&array_1[range_19][range_20][0])",
                                      "tests/memory/separated.c",62);
                      __gen_e_acsl_valid_read_56 = __e_acsl_valid_read
                      ((void *)(& array_1[__gen_e_acsl_range_17][__gen_e_acsl_range_18][0]),
                       sizeof(double),
                       (void *)(& array_1[__gen_e_acsl_range_17][__gen_e_acsl_range_18][0]),
                       (void *)0);
                      /*@ assert
                          E_ACSL: separated_guard:
                            \valid_read(&array_1[range_17][range_18][0]);
                      */
                      __e_acsl_assert(__gen_e_acsl_valid_read_56,"RTE",
                                      "main",
                                      "separated_guard: \\valid_read(&array_1[range_17][range_18][0])",
                                      "tests/memory/separated.c",62);
                      __gen_e_acsl_separated_21 = __e_acsl_separated((size_t)2,
                                                                    & array_1[__gen_e_acsl_range_19][__gen_e_acsl_range_20][0],
                                                                    sizeof(double),
                                                                    & array_1[__gen_e_acsl_range_17][__gen_e_acsl_range_18][0],
                                                                    sizeof(double));
                      if (__gen_e_acsl_separated_21) ;
                      else {
                        __gen_e_acsl_forall_20 = 0;
                        goto e_acsl_end_loop17;
                      }
                    }
                    __gen_e_acsl_range_19 ++;
                  }
                  e_acsl_end_loop17: ;
                  if (__gen_e_acsl_forall_20) ;
                  else {
                    __gen_e_acsl_forall_19 = 0;
                    goto e_acsl_end_loop18;
                  }
                }
                __gen_e_acsl_range_20 ++;
              }
              e_acsl_end_loop18: ;
              if (__gen_e_acsl_forall_19) ;
              else {
                __gen_e_acsl_forall_18 = 0;
                goto e_acsl_end_loop19;
              }
            }
            __gen_e_acsl_range_17 ++;
          }
          e_acsl_end_loop19: ;
          if (__gen_e_acsl_forall_18) ;
          else {
            __gen_e_acsl_forall_17 = 0;
            goto e_acsl_end_loop20;
          }
        }
        __gen_e_acsl_range_18 ++;
      }
      e_acsl_end_loop20: ;
      __e_acsl_assert(__gen_e_acsl_forall_17,"Assertion","main",
                      "\\separated(&array_1[0 .. 2][0 .. 2][0], &array_1[0 .. 2][3 .. 5][0])",
                      "tests/memory/separated.c",62);
    }
    /*@
    assert
    \separated(&array_1[0 .. 2][0 .. 2][0], &array_1[0 .. 2][3 .. 5][0]); */
    ;
    {
      int __gen_e_acsl_forall_21;
      int __gen_e_acsl_range_22;
      int __gen_e_acsl_forall_23;
      int __gen_e_acsl_range_24;
      int __gen_e_acsl_forall_25;
      int __gen_e_acsl_range_26;
      __gen_e_acsl_forall_21 = 1;
      __gen_e_acsl_range_22 = 0;
      while (1) {
        if (__gen_e_acsl_range_22 <= 2) ; else break;
        {
          int __gen_e_acsl_forall_22;
          int __gen_e_acsl_range_21;
          __gen_e_acsl_forall_22 = 1;
          __gen_e_acsl_range_21 = 0;
          while (1) {
            if (__gen_e_acsl_range_21 <= 3) ; else break;
            {
              int __gen_e_acsl_valid_read_57;
              __gen_e_acsl_valid_read_57 = __e_acsl_valid_read((void *)(& array_1[__gen_e_acsl_range_21][__gen_e_acsl_range_22][0]),
                                                               sizeof(double),
                                                               (void *)(& array_1[__gen_e_acsl_range_21][__gen_e_acsl_range_22][0]),
                                                               (void *)0);
              if (__gen_e_acsl_valid_read_57) ;
              else {
                __gen_e_acsl_forall_22 = 0;
                goto e_acsl_end_loop21;
              }
            }
            __gen_e_acsl_range_21 ++;
          }
          e_acsl_end_loop21: ;
          if (__gen_e_acsl_forall_22) ;
          else {
            __gen_e_acsl_forall_21 = 0;
            goto e_acsl_end_loop22;
          }
        }
        __gen_e_acsl_range_22 ++;
      }
      e_acsl_end_loop22: ;
      /*@ assert
          E_ACSL: separated_guard: \valid_read(&array_1[0 .. 3][0 .. 2][0]);
      */
      __e_acsl_assert(__gen_e_acsl_forall_21,"RTE","main",
                      "separated_guard: \\valid_read(&array_1[0 .. 3][0 .. 2][0])",
                      "tests/memory/separated.c",63);
      __gen_e_acsl_forall_23 = 1;
      __gen_e_acsl_range_24 = 0;
      while (1) {
        if (__gen_e_acsl_range_24 <= 2) ; else break;
        {
          int __gen_e_acsl_forall_24;
          int __gen_e_acsl_range_23;
          __gen_e_acsl_forall_24 = 1;
          __gen_e_acsl_range_23 = 3;
          while (1) {
            if (__gen_e_acsl_range_23 <= 5) ; else break;
            {
              int __gen_e_acsl_valid_read_58;
              __gen_e_acsl_valid_read_58 = __e_acsl_valid_read((void *)(& array_1[__gen_e_acsl_range_23][__gen_e_acsl_range_24][0]),
                                                               sizeof(double),
                                                               (void *)(& array_1[__gen_e_acsl_range_23][__gen_e_acsl_range_24][0]),
                                                               (void *)0);
              if (__gen_e_acsl_valid_read_58) ;
              else {
                __gen_e_acsl_forall_24 = 0;
                goto e_acsl_end_loop23;
              }
            }
            __gen_e_acsl_range_23 ++;
          }
          e_acsl_end_loop23: ;
          if (__gen_e_acsl_forall_24) ;
          else {
            __gen_e_acsl_forall_23 = 0;
            goto e_acsl_end_loop24;
          }
        }
        __gen_e_acsl_range_24 ++;
      }
      e_acsl_end_loop24: ;
      /*@ assert
          E_ACSL: separated_guard: \valid_read(&array_1[3 .. 5][0 .. 2][0]);
      */
      __e_acsl_assert(__gen_e_acsl_forall_23,"RTE","main",
                      "separated_guard: \\valid_read(&array_1[3 .. 5][0 .. 2][0])",
                      "tests/memory/separated.c",63);
      __gen_e_acsl_forall_25 = 1;
      __gen_e_acsl_range_26 = 0;
      while (1) {
        if (__gen_e_acsl_range_26 <= 2) ; else break;
        {
          int __gen_e_acsl_forall_26;
          int __gen_e_acsl_range_25;
          __gen_e_acsl_forall_26 = 1;
          __gen_e_acsl_range_25 = 3;
          while (1) {
            if (__gen_e_acsl_range_25 <= 5) ; else break;
            {
              int __gen_e_acsl_forall_27;
              int __gen_e_acsl_range_28;
              __gen_e_acsl_forall_27 = 1;
              __gen_e_acsl_range_28 = 0;
              while (1) {
                if (__gen_e_acsl_range_28 <= 2) ; else break;
                {
                  int __gen_e_acsl_forall_28;
                  int __gen_e_acsl_range_27;
                  __gen_e_acsl_forall_28 = 1;
                  __gen_e_acsl_range_27 = 0;
                  while (1) {
                    if (__gen_e_acsl_range_27 <= 3) ; else break;
                    {
                      int __gen_e_acsl_valid_read_59;
                      int __gen_e_acsl_valid_read_60;
                      int __gen_e_acsl_separated_22;
                      __gen_e_acsl_valid_read_59 = __e_acsl_valid_read
                      ((void *)(& array_1[__gen_e_acsl_range_27][__gen_e_acsl_range_28][0]),
                       sizeof(double),
                       (void *)(& array_1[__gen_e_acsl_range_27][__gen_e_acsl_range_28][0]),
                       (void *)0);
                      /*@ assert
                          E_ACSL: separated_guard:
                            \valid_read(&array_1[range_27][range_28][0]);
                      */
                      __e_acsl_assert(__gen_e_acsl_valid_read_59,"RTE",
                                      "main",
                                      "separated_guard: \\valid_read(&array_1[range_27][range_28][0])",
                                      "tests/memory/separated.c",63);
                      __gen_e_acsl_valid_read_60 = __e_acsl_valid_read
                      ((void *)(& array_1[__gen_e_acsl_range_25][__gen_e_acsl_range_26][0]),
                       sizeof(double),
                       (void *)(& array_1[__gen_e_acsl_range_25][__gen_e_acsl_range_26][0]),
                       (void *)0);
                      /*@ assert
                          E_ACSL: separated_guard:
                            \valid_read(&array_1[range_25][range_26][0]);
                      */
                      __e_acsl_assert(__gen_e_acsl_valid_read_60,"RTE",
                                      "main",
                                      "separated_guard: \\valid_read(&array_1[range_25][range_26][0])",
                                      "tests/memory/separated.c",63);
                      __gen_e_acsl_separated_22 = __e_acsl_separated((size_t)2,
                                                                    & array_1[__gen_e_acsl_range_27][__gen_e_acsl_range_28][0],
                                                                    sizeof(double),
                                                                    & array_1[__gen_e_acsl_range_25][__gen_e_acsl_range_26][0],
                                                                    sizeof(double));
                      if (__gen_e_acsl_separated_22) ;
                      else {
                        __gen_e_acsl_forall_28 = 0;
                        goto e_acsl_end_loop25;
                      }
                    }
                    __gen_e_acsl_range_27 ++;
                  }
                  e_acsl_end_loop25: ;
                  if (__gen_e_acsl_forall_28) ;
                  else {
                    __gen_e_acsl_forall_27 = 0;
                    goto e_acsl_end_loop26;
                  }
                }
                __gen_e_acsl_range_28 ++;
              }
              e_acsl_end_loop26: ;
              if (__gen_e_acsl_forall_27) ;
              else {
                __gen_e_acsl_forall_26 = 0;
                goto e_acsl_end_loop27;
              }
            }
            __gen_e_acsl_range_25 ++;
          }
          e_acsl_end_loop27: ;
          if (__gen_e_acsl_forall_26) ;
          else {
            __gen_e_acsl_forall_25 = 0;
            goto e_acsl_end_loop28;
          }
        }
        __gen_e_acsl_range_26 ++;
      }
      e_acsl_end_loop28: ;
      __e_acsl_assert(! __gen_e_acsl_forall_25,"Assertion","main",
                      "!\\separated(&array_1[0 .. 3][0 .. 2][0], &array_1[3 .. 5][0 .. 2][0])",
                      "tests/memory/separated.c",63);
    }
    /*@
    assert
    ¬\separated(&array_1[0 .. 3][0 .. 2][0], &array_1[3 .. 5][0 .. 2][0]);
     */
    ;
    {
      int __gen_e_acsl_forall_29;
      int __gen_e_acsl_range_32;
      int __gen_e_acsl_forall_31;
      int __gen_e_acsl_range_34;
      /*@ assert
          E_ACSL: separated_guard: \valid_read(&array_1[0 .. 3][2 .. 0][0]);
      */
      __e_acsl_assert(1,"RTE","main",
                      "separated_guard: \\valid_read(&array_1[0 .. 3][2 .. 0][0])",
                      "tests/memory/separated.c",64);
      __gen_e_acsl_forall_29 = 1;
      __gen_e_acsl_range_32 = 0;
      while (1) {
        if (__gen_e_acsl_range_32 <= 2) ; else break;
        {
          int __gen_e_acsl_forall_30;
          int __gen_e_acsl_range_31;
          __gen_e_acsl_forall_30 = 1;
          __gen_e_acsl_range_31 = 3;
          while (1) {
            if (__gen_e_acsl_range_31 <= 5) ; else break;
            {
              int __gen_e_acsl_valid_read_61;
              __gen_e_acsl_valid_read_61 = __e_acsl_valid_read((void *)(& array_1[__gen_e_acsl_range_31][__gen_e_acsl_range_32][0]),
                                                               sizeof(double),
                                                               (void *)(& array_1[__gen_e_acsl_range_31][__gen_e_acsl_range_32][0]),
                                                               (void *)0);
              if (__gen_e_acsl_valid_read_61) ;
              else {
                __gen_e_acsl_forall_30 = 0;
                goto e_acsl_end_loop29;
              }
            }
            __gen_e_acsl_range_31 ++;
          }
          e_acsl_end_loop29: ;
          if (__gen_e_acsl_forall_30) ;
          else {
            __gen_e_acsl_forall_29 = 0;
            goto e_acsl_end_loop30;
          }
        }
        __gen_e_acsl_range_32 ++;
      }
      e_acsl_end_loop30: ;
      /*@ assert
          E_ACSL: separated_guard: \valid_read(&array_1[3 .. 5][0 .. 2][0]);
      */
      __e_acsl_assert(__gen_e_acsl_forall_29,"RTE","main",
                      "separated_guard: \\valid_read(&array_1[3 .. 5][0 .. 2][0])",
                      "tests/memory/separated.c",64);
      __gen_e_acsl_forall_31 = 1;
      __gen_e_acsl_range_34 = 0;
      while (1) {
        if (__gen_e_acsl_range_34 <= 2) ; else break;
        {
          int __gen_e_acsl_forall_32;
          int __gen_e_acsl_range_33;
          __gen_e_acsl_forall_32 = 1;
          __gen_e_acsl_range_33 = 3;
          while (1) {
            if (__gen_e_acsl_range_33 <= 5) ; else break;
            if (1) ;
            else {
              __gen_e_acsl_forall_32 = 0;
              goto e_acsl_end_loop31;
            }
            __gen_e_acsl_range_33 ++;
          }
          e_acsl_end_loop31: ;
          if (__gen_e_acsl_forall_32) ;
          else {
            __gen_e_acsl_forall_31 = 0;
            goto e_acsl_end_loop32;
          }
        }
        __gen_e_acsl_range_34 ++;
      }
      e_acsl_end_loop32: ;
      __e_acsl_assert(__gen_e_acsl_forall_31,"Assertion","main",
                      "\\separated(&array_1[0 .. 3][2 .. 0][0], &array_1[3 .. 5][0 .. 2][0])",
                      "tests/memory/separated.c",64);
    }
    /*@
    assert
    \separated(&array_1[0 .. 3][2 .. 0][0], &array_1[3 .. 5][0 .. 2][0]); */
    ;
    __e_acsl_delete_block((void *)(array_1));
  }
  __retres = 0;
  __e_acsl_memory_clean();
  return __retres;
}


