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

/*@ requires valid_dest: valid_or_empty(dest, n);
    requires valid_src: valid_read_or_empty(src, n);
    requires
      separation:
        \separated((char *)dest + (0 .. n - 1), (char *)src + (0 .. n - 1));
    ensures
      copied_contents:
        memcmp{Post, Pre}((char *)\old(dest), (char *)\old(src), \old(n)) ≡
        0;
    ensures result_ptr: \result ≡ \old(dest);
    assigns *((char *)dest + (0 .. n - 1)), \result;
    assigns *((char *)dest + (0 .. n - 1))
      \from *((char *)src + (0 .. n - 1));
    assigns \result \from dest;
 */
void *__gen_e_acsl_memcpy(void * __restrict dest,
                          void const * __restrict src, size_t n);

/*@ requires valid_s: valid_or_empty(s, n);
    ensures
      acsl_c_equiv: memset((char *)\old(s), \old(c), \old(n)) ≡ \true;
    ensures result_ptr: \result ≡ \old(s);
    assigns *((char *)s + (0 .. n - 1)), \result;
    assigns *((char *)s + (0 .. n - 1)) \from c;
    assigns \result \from s;
 */
void *__gen_e_acsl_memset(void *s, int c, size_t n);

int main(void)
{
  int __retres;
  int *src[2];
  int *dest[2];
  int *tmp_1;
  __e_acsl_memory_init((int *)0,(char ***)0,(size_t)8);
  __e_acsl_store_block((void *)(& tmp_1),(size_t)8);
  __e_acsl_store_block((void *)(dest),(size_t)16);
  __e_acsl_store_block((void *)(src),(size_t)16);
  int a = 111;
  __e_acsl_store_block((void *)(& a),(size_t)4);
  __e_acsl_full_init((void *)(& a));
  int b = 222;
  __e_acsl_store_block((void *)(& b),(size_t)4);
  __e_acsl_full_init((void *)(& b));
  int size = (int)(sizeof(int *) * (unsigned long)2);
  __e_acsl_initialize((void *)(src),sizeof(int *));
  __e_acsl_temporal_store_nblock((void *)(src),(void *)(& a));
  src[0] = & a;
  __e_acsl_initialize((void *)(& src[1]),sizeof(int *));
  __e_acsl_temporal_store_nblock((void *)(& src[1]),(void *)(& b));
  src[1] = & b;
  __e_acsl_initialize((void *)(dest),sizeof(int *));
  __e_acsl_temporal_store_nblock((void *)(dest),(void *)0);
  dest[0] = (int *)0;
  __e_acsl_initialize((void *)(& dest[1]),sizeof(int *));
  __e_acsl_temporal_store_nblock((void *)(& dest[1]),(void *)0);
  dest[1] = (int *)0;
  {
    int __gen_e_acsl_initialized;
    int __gen_e_acsl_and;
    __gen_e_acsl_initialized = __e_acsl_initialized((void *)(src),
                                                    sizeof(int *));
    if (__gen_e_acsl_initialized) {
      int __gen_e_acsl_valid;
      __gen_e_acsl_valid = __e_acsl_valid((void *)src[0],sizeof(int),
                                          (void *)src[0],(void *)(src));
      __gen_e_acsl_and = __gen_e_acsl_valid;
    }
    else __gen_e_acsl_and = 0;
    __e_acsl_assert(__gen_e_acsl_and,"Assertion","main","\\valid(src[0])",
                    "tests/temporal/t_memcpy.c",22);
  }
  /*@ assert \valid(src[0]); */ ;
  {
    int __gen_e_acsl_initialized_2;
    int __gen_e_acsl_and_2;
    __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& src[1]),
                                                      sizeof(int *));
    if (__gen_e_acsl_initialized_2) {
      int __gen_e_acsl_valid_2;
      __gen_e_acsl_valid_2 = __e_acsl_valid((void *)src[1],sizeof(int),
                                            (void *)src[1],
                                            (void *)(& src[1]));
      __gen_e_acsl_and_2 = __gen_e_acsl_valid_2;
    }
    else __gen_e_acsl_and_2 = 0;
    __e_acsl_assert(__gen_e_acsl_and_2,"Assertion","main","\\valid(src[1])",
                    "tests/temporal/t_memcpy.c",23);
  }
  /*@ assert \valid(src[1]); */ ;
  __e_acsl_temporal_reset_parameters();
  __e_acsl_temporal_reset_return();
  __e_acsl_temporal_save_nblock_parameter((void *)(& dest),0U);
  __e_acsl_temporal_save_nblock_parameter((void *)(& src),1U);
  __gen_e_acsl_memcpy((void *)(& dest),(void const *)(& src),
                      (unsigned long)size);
  {
    int __gen_e_acsl_initialized_3;
    int __gen_e_acsl_and_3;
    __gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(dest),
                                                      sizeof(int *));
    if (__gen_e_acsl_initialized_3) {
      int __gen_e_acsl_valid_3;
      __gen_e_acsl_valid_3 = __e_acsl_valid((void *)dest[0],sizeof(int),
                                            (void *)dest[0],(void *)(dest));
      __gen_e_acsl_and_3 = __gen_e_acsl_valid_3;
    }
    else __gen_e_acsl_and_3 = 0;
    __e_acsl_assert(__gen_e_acsl_and_3,"Assertion","main","\\valid(dest[0])",
                    "tests/temporal/t_memcpy.c",27);
  }
  /*@ assert \valid(dest[0]); */ ;
  {
    int __gen_e_acsl_initialized_4;
    int __gen_e_acsl_and_4;
    __gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& dest[1]),
                                                      sizeof(int *));
    if (__gen_e_acsl_initialized_4) {
      int __gen_e_acsl_valid_4;
      __gen_e_acsl_valid_4 = __e_acsl_valid((void *)dest[1],sizeof(int),
                                            (void *)dest[1],
                                            (void *)(& dest[1]));
      __gen_e_acsl_and_4 = __gen_e_acsl_valid_4;
    }
    else __gen_e_acsl_and_4 = 0;
    __e_acsl_assert(__gen_e_acsl_and_4,"Assertion","main","\\valid(dest[1])",
                    "tests/temporal/t_memcpy.c",28);
  }
  /*@ assert \valid(dest[1]); */ ;
  __e_acsl_temporal_reset_parameters();
  __e_acsl_temporal_reset_return();
  __e_acsl_temporal_save_nblock_parameter((void *)(& dest),0U);
  __gen_e_acsl_memset((void *)(& dest),0,(unsigned long)size);
  {
    int __gen_e_acsl_initialized_5;
    int __gen_e_acsl_and_5;
    __gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)(dest),
                                                      sizeof(int *));
    if (__gen_e_acsl_initialized_5) {
      int __gen_e_acsl_valid_5;
      __gen_e_acsl_valid_5 = __e_acsl_valid((void *)dest[0],sizeof(int),
                                            (void *)dest[0],(void *)(dest));
      __gen_e_acsl_and_5 = __gen_e_acsl_valid_5;
    }
    else __gen_e_acsl_and_5 = 0;
    __e_acsl_assert(! __gen_e_acsl_and_5,"Assertion","main",
                    "!\\valid(dest[0])","tests/temporal/t_memcpy.c",32);
  }
  /*@ assert ¬\valid(dest[0]); */ ;
  {
    int __gen_e_acsl_initialized_6;
    int __gen_e_acsl_and_6;
    __gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(& dest[1]),
                                                      sizeof(int *));
    if (__gen_e_acsl_initialized_6) {
      int __gen_e_acsl_valid_6;
      __gen_e_acsl_valid_6 = __e_acsl_valid((void *)dest[1],sizeof(int),
                                            (void *)dest[1],
                                            (void *)(& dest[1]));
      __gen_e_acsl_and_6 = __gen_e_acsl_valid_6;
    }
    else __gen_e_acsl_and_6 = 0;
    __e_acsl_assert(! __gen_e_acsl_and_6,"Assertion","main",
                    "!\\valid(dest[1])","tests/temporal/t_memcpy.c",33);
  }
  /*@ assert ¬\valid(dest[1]); */ ;
  __e_acsl_temporal_reset_parameters();
  __e_acsl_temporal_reset_return();
  int **p = malloc((unsigned long)size);
  __e_acsl_temporal_store_nblock((void *)(& p),(void *)*(& p));
  __e_acsl_store_block((void *)(& p),(size_t)8);
  __e_acsl_full_init((void *)(& p));
  __e_acsl_temporal_reset_parameters();
  __e_acsl_temporal_reset_return();
  int **q = malloc((unsigned long)size);
  __e_acsl_temporal_store_nblock((void *)(& q),(void *)*(& q));
  __e_acsl_store_block((void *)(& q),(size_t)8);
  __e_acsl_full_init((void *)(& q));
  __e_acsl_initialize((void *)p,sizeof(int *));
  __e_acsl_temporal_store_nblock((void *)p,(void *)(& a));
  *p = & a;
  __e_acsl_initialize((void *)(p + 1),sizeof(int *));
  __e_acsl_temporal_store_nblock((void *)(p + 1),(void *)(& a));
  *(p + 1) = & a;
  {
    int __gen_e_acsl_initialized_7;
    int __gen_e_acsl_and_8;
    __gen_e_acsl_initialized_7 = __e_acsl_initialized((void *)p,
                                                      sizeof(int *));
    if (__gen_e_acsl_initialized_7) {
      int __gen_e_acsl_initialized_8;
      int __gen_e_acsl_and_7;
      int __gen_e_acsl_valid_7;
      __gen_e_acsl_initialized_8 = __e_acsl_initialized((void *)(& p),
                                                        sizeof(int **));
      if (__gen_e_acsl_initialized_8) {
        int __gen_e_acsl_valid_read;
        __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)p,
                                                      sizeof(int *),
                                                      (void *)p,
                                                      (void *)(& p));
        __gen_e_acsl_and_7 = __gen_e_acsl_valid_read;
      }
      else __gen_e_acsl_and_7 = 0;
      __e_acsl_assert(__gen_e_acsl_and_7,"RTE","main",
                      "mem_access: \\valid_read(p)",
                      "tests/temporal/t_memcpy.c",42);
      __gen_e_acsl_valid_7 = __e_acsl_valid((void *)*p,sizeof(int),
                                            (void *)*p,(void *)p);
      __gen_e_acsl_and_8 = __gen_e_acsl_valid_7;
    }
    else __gen_e_acsl_and_8 = 0;
    __e_acsl_assert(__gen_e_acsl_and_8,"Assertion","main","\\valid(*p)",
                    "tests/temporal/t_memcpy.c",42);
  }
  /*@ assert \valid(*p); */ ;
  {
    int __gen_e_acsl_initialized_9;
    int __gen_e_acsl_and_9;
    __gen_e_acsl_initialized_9 = __e_acsl_initialized((void *)(p + 1),
                                                      sizeof(int *));
    if (__gen_e_acsl_initialized_9) {
      int __gen_e_acsl_valid_read_2;
      int __gen_e_acsl_valid_8;
      __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(p + 1),
                                                      sizeof(int *),
                                                      (void *)p,
                                                      (void *)(& p));
      __e_acsl_assert(__gen_e_acsl_valid_read_2,"RTE","main",
                      "mem_access: \\valid_read(p + 1)",
                      "tests/temporal/t_memcpy.c",43);
      __gen_e_acsl_valid_8 = __e_acsl_valid((void *)*(p + 1),sizeof(int),
                                            (void *)*(p + 1),(void *)(
                                            p + 1));
      __gen_e_acsl_and_9 = __gen_e_acsl_valid_8;
    }
    else __gen_e_acsl_and_9 = 0;
    __e_acsl_assert(__gen_e_acsl_and_9,"Assertion","main",
                    "\\valid(*(p + 1))","tests/temporal/t_memcpy.c",43);
  }
  /*@ assert \valid(*(p + 1)); */ ;
  {
    int __gen_e_acsl_initialized_10;
    int __gen_e_acsl_and_11;
    __gen_e_acsl_initialized_10 = __e_acsl_initialized((void *)q,
                                                       sizeof(int *));
    if (__gen_e_acsl_initialized_10) {
      int __gen_e_acsl_initialized_11;
      int __gen_e_acsl_and_10;
      int __gen_e_acsl_valid_9;
      __gen_e_acsl_initialized_11 = __e_acsl_initialized((void *)(& q),
                                                         sizeof(int **));
      if (__gen_e_acsl_initialized_11) {
        int __gen_e_acsl_valid_read_3;
        __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)q,
                                                        sizeof(int *),
                                                        (void *)q,
                                                        (void *)(& q));
        __gen_e_acsl_and_10 = __gen_e_acsl_valid_read_3;
      }
      else __gen_e_acsl_and_10 = 0;
      __e_acsl_assert(__gen_e_acsl_and_10,"RTE","main",
                      "mem_access: \\valid_read(q)",
                      "tests/temporal/t_memcpy.c",44);
      __gen_e_acsl_valid_9 = __e_acsl_valid((void *)*q,sizeof(int),
                                            (void *)*q,(void *)q);
      __gen_e_acsl_and_11 = __gen_e_acsl_valid_9;
    }
    else __gen_e_acsl_and_11 = 0;
    __e_acsl_assert(! __gen_e_acsl_and_11,"Assertion","main","!\\valid(*q)",
                    "tests/temporal/t_memcpy.c",44);
  }
  /*@ assert ¬\valid(*q); */ ;
  {
    int __gen_e_acsl_initialized_12;
    int __gen_e_acsl_and_12;
    __gen_e_acsl_initialized_12 = __e_acsl_initialized((void *)(q + 1),
                                                       sizeof(int *));
    if (__gen_e_acsl_initialized_12) {
      int __gen_e_acsl_valid_read_4;
      int __gen_e_acsl_valid_10;
      __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(q + 1),
                                                      sizeof(int *),
                                                      (void *)q,
                                                      (void *)(& q));
      __e_acsl_assert(__gen_e_acsl_valid_read_4,"RTE","main",
                      "mem_access: \\valid_read(q + 1)",
                      "tests/temporal/t_memcpy.c",45);
      __gen_e_acsl_valid_10 = __e_acsl_valid((void *)*(q + 1),sizeof(int),
                                             (void *)*(q + 1),
                                             (void *)(q + 1));
      __gen_e_acsl_and_12 = __gen_e_acsl_valid_10;
    }
    else __gen_e_acsl_and_12 = 0;
    __e_acsl_assert(! __gen_e_acsl_and_12,"Assertion","main",
                    "!\\valid(*(q + 1))","tests/temporal/t_memcpy.c",45);
  }
  /*@ assert ¬\valid(*(q + 1)); */ ;
  __e_acsl_full_init((void *)(& tmp_1));
  __e_acsl_temporal_store_nblock((void *)(& tmp_1),(void *)0);
  tmp_1 = (int *)0;
  __e_acsl_initialize((void *)(q + 1),sizeof(int *));
  __e_acsl_temporal_store_nreferent((void *)(q + 1),(void *)(& tmp_1));
  *(q + 1) = tmp_1;
  __e_acsl_initialize((void *)q,sizeof(int *));
  __e_acsl_temporal_store_nreferent((void *)q,(void *)(& tmp_1));
  *q = tmp_1;
  __e_acsl_temporal_reset_parameters();
  __e_acsl_temporal_reset_return();
  __e_acsl_temporal_save_nreferent_parameter((void *)(& q),0U);
  __e_acsl_temporal_save_nreferent_parameter((void *)(& p),1U);
  __gen_e_acsl_memcpy((void *)q,(void const *)p,(unsigned long)size);
  {
    int __gen_e_acsl_initialized_13;
    int __gen_e_acsl_and_14;
    __gen_e_acsl_initialized_13 = __e_acsl_initialized((void *)q,
                                                       sizeof(int *));
    if (__gen_e_acsl_initialized_13) {
      int __gen_e_acsl_initialized_14;
      int __gen_e_acsl_and_13;
      int __gen_e_acsl_valid_11;
      __gen_e_acsl_initialized_14 = __e_acsl_initialized((void *)(& q),
                                                         sizeof(int **));
      if (__gen_e_acsl_initialized_14) {
        int __gen_e_acsl_valid_read_5;
        __gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)q,
                                                        sizeof(int *),
                                                        (void *)q,
                                                        (void *)(& q));
        __gen_e_acsl_and_13 = __gen_e_acsl_valid_read_5;
      }
      else __gen_e_acsl_and_13 = 0;
      __e_acsl_assert(__gen_e_acsl_and_13,"RTE","main",
                      "mem_access: \\valid_read(q)",
                      "tests/temporal/t_memcpy.c",50);
      __gen_e_acsl_valid_11 = __e_acsl_valid((void *)*q,sizeof(int),
                                             (void *)*q,(void *)q);
      __gen_e_acsl_and_14 = __gen_e_acsl_valid_11;
    }
    else __gen_e_acsl_and_14 = 0;
    __e_acsl_assert(__gen_e_acsl_and_14,"Assertion","main","\\valid(*q)",
                    "tests/temporal/t_memcpy.c",50);
  }
  /*@ assert \valid(*q); */ ;
  {
    int __gen_e_acsl_initialized_15;
    int __gen_e_acsl_and_15;
    __gen_e_acsl_initialized_15 = __e_acsl_initialized((void *)(q + 1),
                                                       sizeof(int *));
    if (__gen_e_acsl_initialized_15) {
      int __gen_e_acsl_valid_read_6;
      int __gen_e_acsl_valid_12;
      __gen_e_acsl_valid_read_6 = __e_acsl_valid_read((void *)(q + 1),
                                                      sizeof(int *),
                                                      (void *)q,
                                                      (void *)(& q));
      __e_acsl_assert(__gen_e_acsl_valid_read_6,"RTE","main",
                      "mem_access: \\valid_read(q + 1)",
                      "tests/temporal/t_memcpy.c",51);
      __gen_e_acsl_valid_12 = __e_acsl_valid((void *)*(q + 1),sizeof(int),
                                             (void *)*(q + 1),
                                             (void *)(q + 1));
      __gen_e_acsl_and_15 = __gen_e_acsl_valid_12;
    }
    else __gen_e_acsl_and_15 = 0;
    __e_acsl_assert(__gen_e_acsl_and_15,"Assertion","main",
                    "\\valid(*(q + 1))","tests/temporal/t_memcpy.c",51);
  }
  /*@ assert \valid(*(q + 1)); */ ;
  __retres = 0;
  __e_acsl_delete_block((void *)(& tmp_1));
  __e_acsl_delete_block((void *)(& q));
  __e_acsl_delete_block((void *)(& p));
  __e_acsl_delete_block((void *)(dest));
  __e_acsl_delete_block((void *)(src));
  __e_acsl_delete_block((void *)(& b));
  __e_acsl_delete_block((void *)(& a));
  __e_acsl_memory_clean();
  return __retres;
}

/*@ requires valid_s: valid_or_empty(s, n);
    ensures
      acsl_c_equiv: memset((char *)\old(s), \old(c), \old(n)) ≡ \true;
    ensures result_ptr: \result ≡ \old(s);
    assigns *((char *)s + (0 .. n - 1)), \result;
    assigns *((char *)s + (0 .. n - 1)) \from c;
    assigns \result \from s;
 */
void *__gen_e_acsl_memset(void *s, int c, size_t n)
{
  void *__gen_e_acsl_at;
  void *__retres;
  __e_acsl_store_block((void *)(& s),(size_t)8);
  __e_acsl_temporal_pull_parameter((void *)(& s),0U,8UL);
  __e_acsl_temporal_reset_parameters();
  __e_acsl_temporal_reset_return();
  __e_acsl_temporal_save_nreferent_parameter((void *)(& s),0U);
  __e_acsl_temporal_memset(s,c,n);
  __gen_e_acsl_at = s;
  __retres = memset(s,c,n);
  __e_acsl_assert(__retres == __gen_e_acsl_at,"Postcondition","memset",
                  "\\result == \\old(s)","FRAMAC_SHARE/libc/string.h",119);
  __e_acsl_delete_block((void *)(& s));
  return __retres;
}

/*@ requires valid_dest: valid_or_empty(dest, n);
    requires valid_src: valid_read_or_empty(src, n);
    requires
      separation:
        \separated((char *)dest + (0 .. n - 1), (char *)src + (0 .. n - 1));
    ensures
      copied_contents:
        memcmp{Post, Pre}((char *)\old(dest), (char *)\old(src), \old(n)) ≡
        0;
    ensures result_ptr: \result ≡ \old(dest);
    assigns *((char *)dest + (0 .. n - 1)), \result;
    assigns *((char *)dest + (0 .. n - 1))
      \from *((char *)src + (0 .. n - 1));
    assigns \result \from dest;
 */
void *__gen_e_acsl_memcpy(void * __restrict dest,
                          void const * __restrict src, size_t n)
{
  void *__gen_e_acsl_at;
  void *__retres;
  {
    unsigned long __gen_e_acsl_size;
    __e_acsl_mpz_t __gen_e_acsl_n;
    __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;
    unsigned long __gen_e_acsl__3;
    unsigned long __gen_e_acsl_if;
    int __gen_e_acsl_valid_read;
    unsigned long __gen_e_acsl_size_2;
    unsigned long __gen_e_acsl__4;
    unsigned long __gen_e_acsl_if_2;
    int __gen_e_acsl_valid_read_2;
    unsigned long __gen_e_acsl_size_3;
    unsigned long __gen_e_acsl__5;
    unsigned long __gen_e_acsl_if_3;
    unsigned long __gen_e_acsl_size_4;
    unsigned long __gen_e_acsl__6;
    unsigned long __gen_e_acsl_if_4;
    int __gen_e_acsl_separated;
    __e_acsl_store_block((void *)(& src),(size_t)8);
    __e_acsl_store_block((void *)(& dest),(size_t)8);
    __e_acsl_temporal_pull_parameter((void *)(& dest),0U,8UL);
    __e_acsl_temporal_pull_parameter((void *)(& src),1U,8UL);
    __gmpz_init_set_ui(__gen_e_acsl_n,n);
    __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_n),
               (__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_));
    __gen_e_acsl__3 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_add));
    __gen_e_acsl_size = 1UL * __gen_e_acsl__3;
    if (__gen_e_acsl_size <= 0UL) __gen_e_acsl_if = 0UL;
    else __gen_e_acsl_if = __gen_e_acsl_size;
    __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)((char *)dest + 
                                                           1 * 0),
                                                  __gen_e_acsl_if,dest,
                                                  (void *)(& dest));
    /*@ assert
        E_ACSL: separated_guard: \valid_read((char *)dest + (0 .. n - 1));
    */
    __e_acsl_assert(__gen_e_acsl_valid_read,"RTE","memcpy",
                    "separated_guard: \\valid_read((char *)dest + (0 .. n - 1))",
                    "FRAMAC_SHARE/libc/string.h",95);
    __gen_e_acsl__4 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_add));
    __gen_e_acsl_size_2 = 1UL * __gen_e_acsl__4;
    if (__gen_e_acsl_size_2 <= 0UL) __gen_e_acsl_if_2 = 0UL;
    else __gen_e_acsl_if_2 = __gen_e_acsl_size_2;
    __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)((char *)src + 
                                                             1 * 0),
                                                    __gen_e_acsl_if_2,
                                                    (void *)src,
                                                    (void *)(& src));
    /*@ assert
        E_ACSL: separated_guard: \valid_read((char *)src + (0 .. n - 1));
    */
    __e_acsl_assert(__gen_e_acsl_valid_read_2,"RTE","memcpy",
                    "separated_guard: \\valid_read((char *)src + (0 .. n - 1))",
                    "FRAMAC_SHARE/libc/string.h",95);
    __gen_e_acsl__5 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_add));
    __gen_e_acsl_size_3 = 1UL * __gen_e_acsl__5;
    if (__gen_e_acsl_size_3 <= 0UL) __gen_e_acsl_if_3 = 0UL;
    else __gen_e_acsl_if_3 = __gen_e_acsl_size_3;
    __gen_e_acsl__6 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_add));
    __gen_e_acsl_size_4 = 1UL * __gen_e_acsl__6;
    if (__gen_e_acsl_size_4 <= 0UL) __gen_e_acsl_if_4 = 0UL;
    else __gen_e_acsl_if_4 = __gen_e_acsl_size_4;
    __gen_e_acsl_separated = __e_acsl_separated((size_t)2,
                                                (char *)dest + 1 * 0,
                                                __gen_e_acsl_if_3,
                                                (char *)src + 1 * 0,
                                                __gen_e_acsl_if_4);
    __e_acsl_assert(__gen_e_acsl_separated,"Precondition","memcpy",
                    "\\separated((char *)dest + (0 .. n - 1), (char *)src + (0 .. n - 1))",
                    "FRAMAC_SHARE/libc/string.h",95);
    __e_acsl_temporal_reset_parameters();
    __e_acsl_temporal_reset_return();
    __e_acsl_temporal_save_nreferent_parameter((void *)(& dest),0U);
    __e_acsl_temporal_save_nreferent_parameter((void *)(& src),1U);
    __e_acsl_temporal_memcpy(dest,(void *)src,n);
    __gmpz_clear(__gen_e_acsl_n);
    __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);
  }
  __gen_e_acsl_at = dest;
  __retres = memcpy(dest,src,n);
  __e_acsl_assert(__retres == __gen_e_acsl_at,"Postcondition","memcpy",
                  "\\result == \\old(dest)","FRAMAC_SHARE/libc/string.h",99);
  __e_acsl_delete_block((void *)(& src));
  __e_acsl_delete_block((void *)(& dest));
  return __retres;
}


