/* Generated by Frama-C */
#include "pthread.h"
#include "sched.h"
#include "signal.h"
#include "stddef.h"
#include "stdint.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "sys/select.h"
#include "sys/time.h"
#include "sys/types.h"
#include "sys/wait.h"
#include "time.h"
#include "unistd.h"
char *__gen_e_acsl_literal_string_24;
char *__gen_e_acsl_literal_string_23;
char *__gen_e_acsl_literal_string_22;
char *__gen_e_acsl_literal_string_21;
char *__gen_e_acsl_literal_string_20;
char *__gen_e_acsl_literal_string_19;
char *__gen_e_acsl_literal_string_18;
char *__gen_e_acsl_literal_string_17;
char *__gen_e_acsl_literal_string_16;
char *__gen_e_acsl_literal_string_15;
char *__gen_e_acsl_literal_string_14;
char *__gen_e_acsl_literal_string_13;
char *__gen_e_acsl_literal_string_12;
char *__gen_e_acsl_literal_string_11;
char *__gen_e_acsl_literal_string_10;
char *__gen_e_acsl_literal_string_9;
char *__gen_e_acsl_literal_string_7;
char *__gen_e_acsl_literal_string_6;
char *__gen_e_acsl_literal_string;
char *__gen_e_acsl_literal_string_2;
char *__gen_e_acsl_literal_string_3;
char *__gen_e_acsl_literal_string_5;
char *__gen_e_acsl_literal_string_4;
char *__gen_e_acsl_literal_string_8;
extern  __attribute__((__FC_BUILTIN__)) int __e_acsl_sound_verdict;

/*@ exits status: \exit_status == \old(status);
    ensures never_terminates: \false;
    
    assigns \exit_status \from status;
 */
void __gen_e_acsl_exit(int status);

/*@ ensures result_ok_or_error: \result == -1 || \result >= 0;
    ensures
      initialization: stat_loc_init_on_success:
        \result >= 0 && \old(stat_loc) != \null ==>
        \initialized(\old(stat_loc));
    assigns \result, *stat_loc;
    assigns \result \from (indirect: options);
    assigns *stat_loc \from (indirect: options);
    
    behavior stat_loc_null:
      assumes stat_loc_null: stat_loc == \null;
      assigns \result;
      assigns \result \from \nothing;
    
    behavior stat_loc_non_null:
      assumes stat_loc_non_null: stat_loc != \null;
      requires valid_stat_loc: \valid(stat_loc);
 */
pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options);

/*@ ensures
      result_ok_child_or_error: \result == 0 || \result > 0 || \result == -1;
    assigns \result;
    assigns \result \from \nothing;
 */
pid_t __gen_e_acsl_fork(void);

/*@ requires valid_string_s: valid_read_string(s);
    assigns \result;
    assigns \result
      \from (indirect: *(s + (0 .. strlen{Old}(s)))),
            (indirect: __fc_heap_status);
    allocates \result;
    
    behavior allocation:
      assumes can_allocate: is_allocable(strlen(s));
      ensures allocation: \fresh{Old, Here}(\result,strlen(\old(s)));
      ensures
        result_valid_string_and_same_contents:
          valid_string(\result) && strcmp(\result, \old(s)) == 0;
      assigns __fc_heap_status, \result;
      assigns __fc_heap_status \from (indirect: s), __fc_heap_status;
      assigns \result
        \from (indirect: *(s + (0 .. strlen{Old}(s)))),
              (indirect: __fc_heap_status);
    
    behavior no_allocation:
      assumes cannot_allocate: !is_allocable(strlen(s));
      ensures result_null: \result == \null;
      assigns \result;
      assigns \result \from \nothing;
      allocates \nothing;
 */
char *__gen_e_acsl_strdup(char const *s);

void test_memory_tracking(void)
{
  {
    char dest[4];
    __e_acsl_store_block((void *)(dest),4UL);
    char src[2] = {(char)'b', (char)'\000'};
    __e_acsl_store_block((void *)(src),2UL);
    __e_acsl_full_init((void *)(& src));
    {
      int __gen_e_acsl_size;
      int __gen_e_acsl_if;
      int __gen_e_acsl_initialized;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"(char *)dest",
                                   (void *)(dest));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"sizeof(char)",
                                   0,1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"sizeof(char)",
                                   0,1);
      __gen_e_acsl_size = 1 * ((3 - 0) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"size",0,
                                   __gen_e_acsl_size);
      if (__gen_e_acsl_size <= 0) __gen_e_acsl_if = 0;
      else {
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"size",0,
                                     __gen_e_acsl_size);
        __gen_e_acsl_if = __gen_e_acsl_size;
      }
      __gen_e_acsl_initialized = __e_acsl_initialized((void *)(dest + 1 * 0),
                                                      (size_t)__gen_e_acsl_if);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
                                   "\\initialized(&dest[0 .. 3])",0,
                                   __gen_e_acsl_initialized);
      __gen_e_acsl_assert_data.blocking = 1;
      __gen_e_acsl_assert_data.kind = "Assertion";
      __gen_e_acsl_assert_data.pred_txt = "!\\initialized(&dest[0 .. 3])";
      __gen_e_acsl_assert_data.file = "strcpy.c";
      __gen_e_acsl_assert_data.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data.line = 20;
      __e_acsl_assert(! __gen_e_acsl_initialized,& __gen_e_acsl_assert_data);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
    }
    /*@ assert !\initialized(&dest[0 .. 3]); */ ;
    {
      int __gen_e_acsl_size_2;
      int __gen_e_acsl_if_2;
      int __gen_e_acsl_initialized_2;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_2,
                                   "(char *)src",(void *)(src));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,
                                   "sizeof(char)",0,1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,
                                   "sizeof(char)",0,1);
      __gen_e_acsl_size_2 = 1 * ((1 - 0) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,"size",0,
                                   __gen_e_acsl_size_2);
      if (__gen_e_acsl_size_2 <= 0) __gen_e_acsl_if_2 = 0;
      else {
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,"size",0,
                                     __gen_e_acsl_size_2);
        __gen_e_acsl_if_2 = __gen_e_acsl_size_2;
      }
      __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(src + 1 * 0),
                                                        (size_t)__gen_e_acsl_if_2);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,
                                   "\\initialized(&src[0 .. 1])",0,
                                   __gen_e_acsl_initialized_2);
      __gen_e_acsl_assert_data_2.blocking = 1;
      __gen_e_acsl_assert_data_2.kind = "Assertion";
      __gen_e_acsl_assert_data_2.pred_txt = "\\initialized(&src[0 .. 1])";
      __gen_e_acsl_assert_data_2.file = "strcpy.c";
      __gen_e_acsl_assert_data_2.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_2.line = 21;
      __e_acsl_assert(__gen_e_acsl_initialized_2,
                      & __gen_e_acsl_assert_data_2);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
    }
    /*@ assert \initialized(&src[0 .. 1]); */ ;
    __e_acsl_builtin_strcpy(dest,(char const *)(src));
    {
      int __gen_e_acsl_size_3;
      int __gen_e_acsl_if_3;
      int __gen_e_acsl_initialized_3;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,
                                   "(char *)dest",(void *)(dest));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
                                   "sizeof(char)",0,1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
                                   "sizeof(char)",0,1);
      __gen_e_acsl_size_3 = 1 * ((1 - 0) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,"size",0,
                                   __gen_e_acsl_size_3);
      if (__gen_e_acsl_size_3 <= 0) __gen_e_acsl_if_3 = 0;
      else {
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,"size",0,
                                     __gen_e_acsl_size_3);
        __gen_e_acsl_if_3 = __gen_e_acsl_size_3;
      }
      __gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(dest + 1 * 0),
                                                        (size_t)__gen_e_acsl_if_3);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
                                   "\\initialized(&dest[0 .. 1])",0,
                                   __gen_e_acsl_initialized_3);
      __gen_e_acsl_assert_data_3.blocking = 1;
      __gen_e_acsl_assert_data_3.kind = "Assertion";
      __gen_e_acsl_assert_data_3.pred_txt = "\\initialized(&dest[0 .. 1])";
      __gen_e_acsl_assert_data_3.file = "strcpy.c";
      __gen_e_acsl_assert_data_3.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_3.line = 24;
      __e_acsl_assert(__gen_e_acsl_initialized_3,
                      & __gen_e_acsl_assert_data_3);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
    }
    /*@ assert \initialized(&dest[0 .. 1]); */ ;
    {
      int __gen_e_acsl_size_4;
      int __gen_e_acsl_if_4;
      int __gen_e_acsl_initialized_4;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_4,
                                   "(char *)dest",(void *)(dest));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,
                                   "sizeof(char)",0,1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,
                                   "sizeof(char)",0,1);
      __gen_e_acsl_size_4 = 1 * ((3 - 2) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,"size",0,
                                   __gen_e_acsl_size_4);
      if (__gen_e_acsl_size_4 <= 0) __gen_e_acsl_if_4 = 0;
      else {
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,"size",0,
                                     __gen_e_acsl_size_4);
        __gen_e_acsl_if_4 = __gen_e_acsl_size_4;
      }
      __gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(dest + 1 * 2),
                                                        (size_t)__gen_e_acsl_if_4);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,
                                   "\\initialized(&dest[2 .. 3])",0,
                                   __gen_e_acsl_initialized_4);
      __gen_e_acsl_assert_data_4.blocking = 1;
      __gen_e_acsl_assert_data_4.kind = "Assertion";
      __gen_e_acsl_assert_data_4.pred_txt = "!\\initialized(&dest[2 .. 3])";
      __gen_e_acsl_assert_data_4.file = "strcpy.c";
      __gen_e_acsl_assert_data_4.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_4.line = 25;
      __e_acsl_assert(! __gen_e_acsl_initialized_4,
                      & __gen_e_acsl_assert_data_4);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
    }
    /*@ assert !\initialized(&dest[2 .. 3]); */ ;
    __e_acsl_delete_block((void *)(src));
    __e_acsl_delete_block((void *)(dest));
  }
  {
    char dest_0[4];
    __e_acsl_store_block((void *)(dest_0),4UL);
    char src_0[4] = {(char)'a', (char)'b', (char)'\000'};
    __e_acsl_store_block((void *)(src_0),4UL);
    __e_acsl_full_init((void *)(& src_0));
    {
      int __gen_e_acsl_size_5;
      int __gen_e_acsl_if_5;
      int __gen_e_acsl_initialized_5;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_5 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_5,
                                   "(char *)dest_0",(void *)(dest_0));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,
                                   "sizeof(char)",0,1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,
                                   "sizeof(char)",0,1);
      __gen_e_acsl_size_5 = 1 * ((3 - 0) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,"size",0,
                                   __gen_e_acsl_size_5);
      if (__gen_e_acsl_size_5 <= 0) __gen_e_acsl_if_5 = 0;
      else {
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,"size",0,
                                     __gen_e_acsl_size_5);
        __gen_e_acsl_if_5 = __gen_e_acsl_size_5;
      }
      __gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)(dest_0 + 
                                                                 1 * 0),
                                                        (size_t)__gen_e_acsl_if_5);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,
                                   "\\initialized(&dest_0[0 .. 3])",0,
                                   __gen_e_acsl_initialized_5);
      __gen_e_acsl_assert_data_5.blocking = 1;
      __gen_e_acsl_assert_data_5.kind = "Assertion";
      __gen_e_acsl_assert_data_5.pred_txt = "!\\initialized(&dest_0[0 .. 3])";
      __gen_e_acsl_assert_data_5.file = "strcpy.c";
      __gen_e_acsl_assert_data_5.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_5.line = 30;
      __e_acsl_assert(! __gen_e_acsl_initialized_5,
                      & __gen_e_acsl_assert_data_5);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_5);
    }
    /*@ assert !\initialized(&dest_0[0 .. 3]); */ ;
    {
      int __gen_e_acsl_size_6;
      int __gen_e_acsl_if_6;
      int __gen_e_acsl_initialized_6;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_6 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_6,
                                   "(char *)src_0",(void *)(src_0));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
                                   "sizeof(char)",0,1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
                                   "sizeof(char)",0,1);
      __gen_e_acsl_size_6 = 1 * ((3 - 0) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,"size",0,
                                   __gen_e_acsl_size_6);
      if (__gen_e_acsl_size_6 <= 0) __gen_e_acsl_if_6 = 0;
      else {
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,"size",0,
                                     __gen_e_acsl_size_6);
        __gen_e_acsl_if_6 = __gen_e_acsl_size_6;
      }
      __gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(src_0 + 
                                                                 1 * 0),
                                                        (size_t)__gen_e_acsl_if_6);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
                                   "\\initialized(&src_0[0 .. 3])",0,
                                   __gen_e_acsl_initialized_6);
      __gen_e_acsl_assert_data_6.blocking = 1;
      __gen_e_acsl_assert_data_6.kind = "Assertion";
      __gen_e_acsl_assert_data_6.pred_txt = "\\initialized(&src_0[0 .. 3])";
      __gen_e_acsl_assert_data_6.file = "strcpy.c";
      __gen_e_acsl_assert_data_6.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_6.line = 31;
      __e_acsl_assert(__gen_e_acsl_initialized_6,
                      & __gen_e_acsl_assert_data_6);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_6);
    }
    /*@ assert \initialized(&src_0[0 .. 3]); */ ;
    __e_acsl_builtin_strncpy(dest_0,(char const *)(src_0),(size_t)1);
    {
      int __gen_e_acsl_initialized_7;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_7 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_7,
                                   "(char *)dest_0",(void *)(dest_0));
      __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_7,
                                     "sizeof(char)",0,sizeof(char));
      __gen_e_acsl_initialized_7 = __e_acsl_initialized((void *)(dest_0),
                                                        sizeof(char));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,
                                   "\\initialized((char *)dest_0)",0,
                                   __gen_e_acsl_initialized_7);
      __gen_e_acsl_assert_data_7.blocking = 1;
      __gen_e_acsl_assert_data_7.kind = "Assertion";
      __gen_e_acsl_assert_data_7.pred_txt = "\\initialized((char *)dest_0)";
      __gen_e_acsl_assert_data_7.file = "strcpy.c";
      __gen_e_acsl_assert_data_7.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_7.line = 34;
      __e_acsl_assert(__gen_e_acsl_initialized_7,
                      & __gen_e_acsl_assert_data_7);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_7);
    }
    /*@ assert \initialized((char *)dest_0); */ ;
    {
      int __gen_e_acsl_size_7;
      int __gen_e_acsl_if_7;
      int __gen_e_acsl_initialized_8;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_8 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_8,
                                   "(char *)dest_0",(void *)(dest_0));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,
                                   "sizeof(char)",0,1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,
                                   "sizeof(char)",0,1);
      __gen_e_acsl_size_7 = 1 * ((3 - 1) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,"size",0,
                                   __gen_e_acsl_size_7);
      if (__gen_e_acsl_size_7 <= 0) __gen_e_acsl_if_7 = 0;
      else {
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,"size",0,
                                     __gen_e_acsl_size_7);
        __gen_e_acsl_if_7 = __gen_e_acsl_size_7;
      }
      __gen_e_acsl_initialized_8 = __e_acsl_initialized((void *)(dest_0 + 
                                                                 1 * 1),
                                                        (size_t)__gen_e_acsl_if_7);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,
                                   "\\initialized(&dest_0[1 .. 3])",0,
                                   __gen_e_acsl_initialized_8);
      __gen_e_acsl_assert_data_8.blocking = 1;
      __gen_e_acsl_assert_data_8.kind = "Assertion";
      __gen_e_acsl_assert_data_8.pred_txt = "!\\initialized(&dest_0[1 .. 3])";
      __gen_e_acsl_assert_data_8.file = "strcpy.c";
      __gen_e_acsl_assert_data_8.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_8.line = 35;
      __e_acsl_assert(! __gen_e_acsl_initialized_8,
                      & __gen_e_acsl_assert_data_8);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_8);
    }
    /*@ assert !\initialized(&dest_0[1 .. 3]); */ ;
    __e_acsl_delete_block((void *)(src_0));
    __e_acsl_delete_block((void *)(dest_0));
  }
  {
    char dest_1[4];
    __e_acsl_store_block((void *)(dest_1),4UL);
    char src_1[4] = {(char)'b', (char)'\000'};
    __e_acsl_store_block((void *)(src_1),4UL);
    __e_acsl_full_init((void *)(& src_1));
    {
      int __gen_e_acsl_size_8;
      int __gen_e_acsl_if_8;
      int __gen_e_acsl_initialized_9;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_9 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_9,
                                   "(char *)dest_1",(void *)(dest_1));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_9,
                                   "sizeof(char)",0,1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_9,
                                   "sizeof(char)",0,1);
      __gen_e_acsl_size_8 = 1 * ((3 - 0) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_9,"size",0,
                                   __gen_e_acsl_size_8);
      if (__gen_e_acsl_size_8 <= 0) __gen_e_acsl_if_8 = 0;
      else {
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_9,"size",0,
                                     __gen_e_acsl_size_8);
        __gen_e_acsl_if_8 = __gen_e_acsl_size_8;
      }
      __gen_e_acsl_initialized_9 = __e_acsl_initialized((void *)(dest_1 + 
                                                                 1 * 0),
                                                        (size_t)__gen_e_acsl_if_8);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_9,
                                   "\\initialized(&dest_1[0 .. 3])",0,
                                   __gen_e_acsl_initialized_9);
      __gen_e_acsl_assert_data_9.blocking = 1;
      __gen_e_acsl_assert_data_9.kind = "Assertion";
      __gen_e_acsl_assert_data_9.pred_txt = "!\\initialized(&dest_1[0 .. 3])";
      __gen_e_acsl_assert_data_9.file = "strcpy.c";
      __gen_e_acsl_assert_data_9.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_9.line = 40;
      __e_acsl_assert(! __gen_e_acsl_initialized_9,
                      & __gen_e_acsl_assert_data_9);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_9);
    }
    /*@ assert !\initialized(&dest_1[0 .. 3]); */ ;
    {
      int __gen_e_acsl_size_9;
      int __gen_e_acsl_if_9;
      int __gen_e_acsl_initialized_10;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_10 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_10,
                                   "(char *)src_1",(void *)(src_1));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_10,
                                   "sizeof(char)",0,1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_10,
                                   "sizeof(char)",0,1);
      __gen_e_acsl_size_9 = 1 * ((3 - 0) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_10,"size",0,
                                   __gen_e_acsl_size_9);
      if (__gen_e_acsl_size_9 <= 0) __gen_e_acsl_if_9 = 0;
      else {
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_10,"size",0,
                                     __gen_e_acsl_size_9);
        __gen_e_acsl_if_9 = __gen_e_acsl_size_9;
      }
      __gen_e_acsl_initialized_10 = __e_acsl_initialized((void *)(src_1 + 
                                                                  1 * 0),
                                                         (size_t)__gen_e_acsl_if_9);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_10,
                                   "\\initialized(&src_1[0 .. 3])",0,
                                   __gen_e_acsl_initialized_10);
      __gen_e_acsl_assert_data_10.blocking = 1;
      __gen_e_acsl_assert_data_10.kind = "Assertion";
      __gen_e_acsl_assert_data_10.pred_txt = "\\initialized(&src_1[0 .. 3])";
      __gen_e_acsl_assert_data_10.file = "strcpy.c";
      __gen_e_acsl_assert_data_10.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_10.line = 41;
      __e_acsl_assert(__gen_e_acsl_initialized_10,
                      & __gen_e_acsl_assert_data_10);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_10);
    }
    /*@ assert \initialized(&src_1[0 .. 3]); */ ;
    __e_acsl_builtin_strncpy(dest_1,(char const *)(src_1),(size_t)3);
    {
      int __gen_e_acsl_size_10;
      int __gen_e_acsl_if_10;
      int __gen_e_acsl_initialized_11;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_11 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_11,
                                   "(char *)dest_1",(void *)(dest_1));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_11,
                                   "sizeof(char)",0,1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_11,
                                   "sizeof(char)",0,1);
      __gen_e_acsl_size_10 = 1 * ((2 - 0) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_11,"size",0,
                                   __gen_e_acsl_size_10);
      if (__gen_e_acsl_size_10 <= 0) __gen_e_acsl_if_10 = 0;
      else {
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_11,"size",0,
                                     __gen_e_acsl_size_10);
        __gen_e_acsl_if_10 = __gen_e_acsl_size_10;
      }
      __gen_e_acsl_initialized_11 = __e_acsl_initialized((void *)(dest_1 + 
                                                                  1 * 0),
                                                         (size_t)__gen_e_acsl_if_10);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_11,
                                   "\\initialized(&dest_1[0 .. 2])",0,
                                   __gen_e_acsl_initialized_11);
      __gen_e_acsl_assert_data_11.blocking = 1;
      __gen_e_acsl_assert_data_11.kind = "Assertion";
      __gen_e_acsl_assert_data_11.pred_txt = "\\initialized(&dest_1[0 .. 2])";
      __gen_e_acsl_assert_data_11.file = "strcpy.c";
      __gen_e_acsl_assert_data_11.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_11.line = 44;
      __e_acsl_assert(__gen_e_acsl_initialized_11,
                      & __gen_e_acsl_assert_data_11);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_11);
    }
    /*@ assert \initialized(&dest_1[0 .. 2]); */ ;
    {
      int __gen_e_acsl_initialized_12;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_12 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_12,
                                   "&dest_1[3]",(void *)(& dest_1[3]));
      __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_12,
                                     "sizeof(char)",0,sizeof(char));
      __gen_e_acsl_initialized_12 = __e_acsl_initialized((void *)(& dest_1[3]),
                                                         sizeof(char));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_12,
                                   "\\initialized(&dest_1[3])",0,
                                   __gen_e_acsl_initialized_12);
      __gen_e_acsl_assert_data_12.blocking = 1;
      __gen_e_acsl_assert_data_12.kind = "Assertion";
      __gen_e_acsl_assert_data_12.pred_txt = "!\\initialized(&dest_1[3])";
      __gen_e_acsl_assert_data_12.file = "strcpy.c";
      __gen_e_acsl_assert_data_12.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_12.line = 45;
      __e_acsl_assert(! __gen_e_acsl_initialized_12,
                      & __gen_e_acsl_assert_data_12);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_12);
    }
    /*@ assert !\initialized(&dest_1[3]); */ ;
    __e_acsl_delete_block((void *)(src_1));
    __e_acsl_delete_block((void *)(dest_1));
  }
  return;
}

/*@ requires valid_string_s: valid_read_string(s);
    assigns \result;
    assigns \result
      \from (indirect: *(s + (0 .. strlen{Old}(s)))),
            (indirect: __fc_heap_status);
    allocates \result;
    
    behavior allocation:
      assumes can_allocate: is_allocable(strlen(s));
      ensures allocation: \fresh{Old, Here}(\result,strlen(\old(s)));
      ensures
        result_valid_string_and_same_contents:
          valid_string(\result) && strcmp(\result, \old(s)) == 0;
      assigns __fc_heap_status, \result;
      assigns __fc_heap_status \from (indirect: s), __fc_heap_status;
      assigns \result
        \from (indirect: *(s + (0 .. strlen{Old}(s)))),
              (indirect: __fc_heap_status);
    
    behavior no_allocation:
      assumes cannot_allocate: !is_allocable(strlen(s));
      ensures result_null: \result == \null;
      assigns \result;
      assigns \result \from \nothing;
      allocates \nothing;
 */
char *__gen_e_acsl_strdup(char const *s)
{
  __e_acsl_contract_t *__gen_e_acsl_contract;
  char *__retres;
  __gen_e_acsl_contract = __e_acsl_contract_init(2UL);
  __retres = strdup(s);
  {
    int __gen_e_acsl_assumes_value;
    __gen_e_acsl_assumes_value = __e_acsl_contract_get_behavior_assumes
    ((__e_acsl_contract_t const *)__gen_e_acsl_contract,1UL);
    if (__gen_e_acsl_assumes_value) {
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_4,"\\result",
                                   (void *)__retres);
      __gen_e_acsl_assert_data_4.blocking = 1;
      __gen_e_acsl_assert_data_4.kind = "Postcondition";
      __gen_e_acsl_assert_data_4.pred_txt = "\\result == \\null";
      __gen_e_acsl_assert_data_4.file = "FRAMAC_SHARE/libc/string.h";
      __gen_e_acsl_assert_data_4.fct = "strdup";
      __gen_e_acsl_assert_data_4.line = 498;
      __gen_e_acsl_assert_data_4.name = "no_allocation/result_null";
      __e_acsl_assert(__retres == (char *)0,& __gen_e_acsl_assert_data_4);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
    }
    __e_acsl_contract_clean(__gen_e_acsl_contract);
    return __retres;
  }
}

/*@ ensures
      result_ok_child_or_error: \result == 0 || \result > 0 || \result == -1;
    assigns \result;
    assigns \result \from \nothing;
 */
pid_t __gen_e_acsl_fork(void)
{
  pid_t __retres;
  __retres = fork();
  {
    int __gen_e_acsl_or;
    int __gen_e_acsl_or_2;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"\\result",0,
                                 __retres);
    if (__retres == 0) __gen_e_acsl_or = 1;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"\\result",0,
                                   __retres);
      __gen_e_acsl_or = __retres > 0;
    }
    if (__gen_e_acsl_or) __gen_e_acsl_or_2 = 1;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"\\result",0,
                                   __retres);
      __gen_e_acsl_or_2 = __retres == -1;
    }
    __gen_e_acsl_assert_data.blocking = 1;
    __gen_e_acsl_assert_data.kind = "Postcondition";
    __gen_e_acsl_assert_data.pred_txt = "\\result == 0 || \\result > 0 || \\result == -1";
    __gen_e_acsl_assert_data.file = "FRAMAC_SHARE/libc/unistd.h";
    __gen_e_acsl_assert_data.fct = "fork";
    __gen_e_acsl_assert_data.line = 846;
    __gen_e_acsl_assert_data.name = "result_ok_child_or_error";
    __e_acsl_assert(__gen_e_acsl_or_2,& __gen_e_acsl_assert_data);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
    return __retres;
  }
}

/*@ ensures result_ok_or_error: \result == -1 || \result >= 0;
    ensures
      initialization: stat_loc_init_on_success:
        \result >= 0 && \old(stat_loc) != \null ==>
        \initialized(\old(stat_loc));
    assigns \result, *stat_loc;
    assigns \result \from (indirect: options);
    assigns *stat_loc \from (indirect: options);
    
    behavior stat_loc_null:
      assumes stat_loc_null: stat_loc == \null;
      assigns \result;
      assigns \result \from \nothing;
    
    behavior stat_loc_non_null:
      assumes stat_loc_non_null: stat_loc != \null;
      requires valid_stat_loc: \valid(stat_loc);
 */
pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
{
  __e_acsl_contract_t *__gen_e_acsl_contract;
  int *__gen_e_acsl_at;
  pid_t __retres;
  {
    int __gen_e_acsl_assumes_value;
    __e_acsl_store_block((void *)(& stat_loc),8UL);
    __gen_e_acsl_at = stat_loc;
    __gen_e_acsl_contract = __e_acsl_contract_init(2UL);
    __e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,0UL,
                                           stat_loc == (int *)0);
    __e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,1UL,
                                           stat_loc != (int *)0);
    __gen_e_acsl_assumes_value = __e_acsl_contract_get_behavior_assumes
    ((__e_acsl_contract_t const *)__gen_e_acsl_contract,1UL);
    if (__gen_e_acsl_assumes_value) {
      int __gen_e_acsl_valid;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"stat_loc",
                                   (void *)stat_loc);
      __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data,
                                     "sizeof(int)",0,sizeof(int));
      __gen_e_acsl_valid = __e_acsl_valid((void *)stat_loc,sizeof(int),
                                          (void *)stat_loc,
                                          (void *)(& stat_loc));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
                                   "\\valid(stat_loc)",0,__gen_e_acsl_valid);
      __gen_e_acsl_assert_data.blocking = 1;
      __gen_e_acsl_assert_data.kind = "Precondition";
      __gen_e_acsl_assert_data.pred_txt = "\\valid(stat_loc)";
      __gen_e_acsl_assert_data.file = "FRAMAC_SHARE/libc/sys/wait.h";
      __gen_e_acsl_assert_data.fct = "waitpid";
      __gen_e_acsl_assert_data.line = 95;
      __gen_e_acsl_assert_data.name = "stat_loc_non_null/valid_stat_loc";
      __e_acsl_assert(__gen_e_acsl_valid,& __gen_e_acsl_assert_data);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
    }
  }
  __retres = waitpid(pid,stat_loc,options);
  {
    int __gen_e_acsl_or;
    int __gen_e_acsl_and;
    int __gen_e_acsl_implies;
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
      {.values = (void *)0};
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,"\\result",0,
                                 __retres);
    if (__retres == -1) __gen_e_acsl_or = 1;
    else {
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,"\\result",0,
                                   __retres);
      __gen_e_acsl_or = __retres >= 0;
    }
    __gen_e_acsl_assert_data_2.blocking = 1;
    __gen_e_acsl_assert_data_2.kind = "Postcondition";
    __gen_e_acsl_assert_data_2.pred_txt = "\\result == -1 || \\result >= 0";
    __gen_e_acsl_assert_data_2.file = "FRAMAC_SHARE/libc/sys/wait.h";
    __gen_e_acsl_assert_data_2.fct = "waitpid";
    __gen_e_acsl_assert_data_2.line = 87;
    __gen_e_acsl_assert_data_2.name = "result_ok_or_error";
    __e_acsl_assert(__gen_e_acsl_or,& __gen_e_acsl_assert_data_2);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
    __e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
      {.values = (void *)0};
    __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,"\\result",0,
                                 __retres);
    if (__retres >= 0) {
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,
                                   "\\old(stat_loc)",(void *)__gen_e_acsl_at);
      __gen_e_acsl_and = __gen_e_acsl_at != (int *)0;
    }
    else __gen_e_acsl_and = 0;
    if (! __gen_e_acsl_and) __gen_e_acsl_implies = 1;
    else {
      int __gen_e_acsl_initialized;
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,
                                   "\\old(stat_loc)",(void *)__gen_e_acsl_at);
      __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_3,
                                     "sizeof(int)",0,sizeof(int));
      __gen_e_acsl_initialized = __e_acsl_initialized((void *)__gen_e_acsl_at,
                                                      sizeof(int));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
                                   "\\initialized(\\old(stat_loc))",0,
                                   __gen_e_acsl_initialized);
      __gen_e_acsl_implies = __gen_e_acsl_initialized;
    }
    __gen_e_acsl_assert_data_3.blocking = 1;
    __gen_e_acsl_assert_data_3.kind = "Postcondition";
    __gen_e_acsl_assert_data_3.pred_txt = "\\result >= 0 && \\old(stat_loc) != \\null ==> \\initialized(\\old(stat_loc))";
    __gen_e_acsl_assert_data_3.file = "FRAMAC_SHARE/libc/sys/wait.h";
    __gen_e_acsl_assert_data_3.fct = "waitpid";
    __gen_e_acsl_assert_data_3.line = 89;
    __gen_e_acsl_assert_data_3.name = "initialization/stat_loc_init_on_success";
    __e_acsl_assert(__gen_e_acsl_implies,& __gen_e_acsl_assert_data_3);
    __e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
    __e_acsl_contract_clean(__gen_e_acsl_contract);
    __e_acsl_delete_block((void *)(& stat_loc));
    return __retres;
  }
}

/*@ exits status: \exit_status == \old(status);
    ensures never_terminates: \false;
    
    assigns \exit_status \from status;
 */
void __gen_e_acsl_exit(int status)
{
  exit(status);
  {
    __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
    __gen_e_acsl_assert_data.blocking = 1;
    __gen_e_acsl_assert_data.kind = "Postcondition";
    __gen_e_acsl_assert_data.pred_txt = "\\false";
    __gen_e_acsl_assert_data.file = "FRAMAC_SHARE/libc/stdlib.h";
    __gen_e_acsl_assert_data.fct = "exit";
    __gen_e_acsl_assert_data.line = 508;
    __gen_e_acsl_assert_data.name = "never_terminates";
    __e_acsl_assert(0,& __gen_e_acsl_assert_data);
    return;
  }
}

void __e_acsl_globals_init(void)
{
  static char __e_acsl_already_run = 0;
  if (! __e_acsl_already_run) {
    __e_acsl_already_run = 1;
    __gen_e_acsl_literal_string_24 = "strcpy.c:81";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_24,
                         sizeof("strcpy.c:81"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_24);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_24);
    __gen_e_acsl_literal_string_23 = "strcpy.c:80";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_23,
                         sizeof("strcpy.c:80"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_23);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_23);
    __gen_e_acsl_literal_string_22 = "strcpy.c:79";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_22,
                         sizeof("strcpy.c:79"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_22);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_22);
    __gen_e_acsl_literal_string_21 = "strcpy.c:78";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_21,
                         sizeof("strcpy.c:78"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_21);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_21);
    __gen_e_acsl_literal_string_20 = "strcpy.c:77";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_20,
                         sizeof("strcpy.c:77"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_20);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_20);
    __gen_e_acsl_literal_string_19 = "strcpy.c:76";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_19,
                         sizeof("strcpy.c:76"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_19);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_19);
    __gen_e_acsl_literal_string_18 = "strcpy.c:75";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_18,
                         sizeof("strcpy.c:75"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_18);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_18);
    __gen_e_acsl_literal_string_17 = "strcpy.c:74";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_17,
                         sizeof("strcpy.c:74"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_17);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_17);
    __gen_e_acsl_literal_string_16 = "strcpy.c:71";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_16,
                         sizeof("strcpy.c:71"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_16);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_16);
    __gen_e_acsl_literal_string_15 = "strcpy.c:70";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_15,
                         sizeof("strcpy.c:70"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_15);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_15);
    __gen_e_acsl_literal_string_14 = "strcpy.c:69";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_14,
                         sizeof("strcpy.c:69"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_14);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_14);
    __gen_e_acsl_literal_string_13 = "strcpy.c:68";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_13,
                         sizeof("strcpy.c:68"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_13);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_13);
    __gen_e_acsl_literal_string_12 = "strcpy.c:67";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_12,
                         sizeof("strcpy.c:67"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_12);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_12);
    __gen_e_acsl_literal_string_11 = "strcpy.c:66";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_11,
                         sizeof("strcpy.c:66"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_11);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_11);
    __gen_e_acsl_literal_string_10 = "strcpy.c:65";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_10,
                         sizeof("strcpy.c:65"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_10);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_10);
    __gen_e_acsl_literal_string_9 = "strcpy.c:64";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_9,
                         sizeof("strcpy.c:64"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_9);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_9);
    __gen_e_acsl_literal_string_7 = "strcpy.c:63";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_7,
                         sizeof("strcpy.c:63"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_7);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_7);
    __gen_e_acsl_literal_string_6 = "abcd";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_6,
                         sizeof("abcd"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_6);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_6);
    __gen_e_acsl_literal_string = "TEST %d: ";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string,
                         sizeof("TEST %d: "));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string);
    __gen_e_acsl_literal_string_2 = "OK: Expected signal at %s\n";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_2,
                         sizeof("OK: Expected signal at %s\n"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_2);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_2);
    __gen_e_acsl_literal_string_3 = "OK: Expected execution at %s\n";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_3,
                         sizeof("OK: Expected execution at %s\n"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_3);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_3);
    __gen_e_acsl_literal_string_5 = "FAIL: Unexpected signal at %s\n";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_5,
                         sizeof("FAIL: Unexpected signal at %s\n"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_5);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_5);
    __gen_e_acsl_literal_string_4 = "FAIL: Unexpected execution at %s\n";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_4,
                         sizeof("FAIL: Unexpected execution at %s\n"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_4);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_4);
    __gen_e_acsl_literal_string_8 = "";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_8,sizeof(""));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_8);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_8);
  }
  return;
}

int main(int argc, char const **argv)
{
  int __retres;
  __e_acsl_memory_init(& argc,(char ***)(& argv),8UL);
  __e_acsl_globals_init();
  char empty_str[1] = {(char)'\000'};
  char *const_str = (char *)__gen_e_acsl_literal_string_6;
  char *src = __gen_e_acsl_strdup(__gen_e_acsl_literal_string_6);
  char *dest1 = malloc((size_t)5);
  char *dest2 = malloc((size_t)4);
  char dest3[256] =
    {(char)'a', (char)'b', (char)'c', (char)'d', (char)'\000'};
  size_t len = (size_t)0;
  char *unalloc_str = malloc((size_t)5);
  char *_barrier = malloc((size_t)1);
  free((void *)unalloc_str);
  {
    pid_t pid = __gen_e_acsl_fork();
    if (! pid) {
      __e_acsl_builtin_strcpy(dest1,(char const *)src);
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status;
      __e_acsl_store_block((void *)(& process_status),4UL);
      __gen_e_acsl_waitpid(pid,& process_status,0);
      signal_eval(process_status,0,__gen_e_acsl_literal_string_7);
      __e_acsl_delete_block((void *)(& process_status));
    }
  }
  {
    pid_t pid_0 = __gen_e_acsl_fork();
    if (! pid_0) {
      __e_acsl_builtin_strcpy(empty_str,__gen_e_acsl_literal_string_8);
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_0;
      __e_acsl_store_block((void *)(& process_status_0),4UL);
      __gen_e_acsl_waitpid(pid_0,& process_status_0,0);
      signal_eval(process_status_0,0,__gen_e_acsl_literal_string_9);
      __e_acsl_delete_block((void *)(& process_status_0));
    }
  }
  {
    pid_t pid_1 = __gen_e_acsl_fork();
    if (! pid_1) {
      __e_acsl_builtin_strcpy(dest2,(char const *)src);
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_1;
      __e_acsl_store_block((void *)(& process_status_1),4UL);
      __gen_e_acsl_waitpid(pid_1,& process_status_1,0);
      signal_eval(process_status_1,1,__gen_e_acsl_literal_string_10);
      __e_acsl_delete_block((void *)(& process_status_1));
    }
  }
  {
    pid_t pid_2 = __gen_e_acsl_fork();
    if (! pid_2) {
      __e_acsl_builtin_strcpy(unalloc_str,(char const *)src);
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_2;
      __e_acsl_store_block((void *)(& process_status_2),4UL);
      __gen_e_acsl_waitpid(pid_2,& process_status_2,0);
      signal_eval(process_status_2,1,__gen_e_acsl_literal_string_11);
      __e_acsl_delete_block((void *)(& process_status_2));
    }
  }
  {
    pid_t pid_3 = __gen_e_acsl_fork();
    if (! pid_3) {
      __e_acsl_builtin_strcpy(const_str,(char const *)src);
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_3;
      __e_acsl_store_block((void *)(& process_status_3),4UL);
      __gen_e_acsl_waitpid(pid_3,& process_status_3,0);
      signal_eval(process_status_3,1,__gen_e_acsl_literal_string_12);
      __e_acsl_delete_block((void *)(& process_status_3));
    }
  }
  {
    pid_t pid_4 = __gen_e_acsl_fork();
    if (! pid_4) {
      __e_acsl_builtin_strcpy(src,(char const *)const_str);
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_4;
      __e_acsl_store_block((void *)(& process_status_4),4UL);
      __gen_e_acsl_waitpid(pid_4,& process_status_4,0);
      signal_eval(process_status_4,0,__gen_e_acsl_literal_string_13);
      __e_acsl_delete_block((void *)(& process_status_4));
    }
  }
  {
    pid_t pid_5 = __gen_e_acsl_fork();
    if (! pid_5) {
      __e_acsl_builtin_strcpy(src,(char const *)src);
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_5;
      __e_acsl_store_block((void *)(& process_status_5),4UL);
      __gen_e_acsl_waitpid(pid_5,& process_status_5,0);
      signal_eval(process_status_5,1,__gen_e_acsl_literal_string_14);
      __e_acsl_delete_block((void *)(& process_status_5));
    }
  }
  {
    pid_t pid_6 = __gen_e_acsl_fork();
    if (! pid_6) {
      __e_acsl_builtin_strcpy(& dest3[5],(char const *)(dest3));
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_6;
      __e_acsl_store_block((void *)(& process_status_6),4UL);
      __gen_e_acsl_waitpid(pid_6,& process_status_6,0);
      signal_eval(process_status_6,0,__gen_e_acsl_literal_string_15);
      __e_acsl_delete_block((void *)(& process_status_6));
    }
  }
  {
    pid_t pid_7 = __gen_e_acsl_fork();
    if (! pid_7) {
      __e_acsl_builtin_strcpy(& dest3[4],(char const *)(dest3));
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_7;
      __e_acsl_store_block((void *)(& process_status_7),4UL);
      __gen_e_acsl_waitpid(pid_7,& process_status_7,0);
      signal_eval(process_status_7,1,__gen_e_acsl_literal_string_16);
      __e_acsl_delete_block((void *)(& process_status_7));
    }
  }
  {
    pid_t pid_8 = __gen_e_acsl_fork();
    if (! pid_8) {
      __e_acsl_builtin_strncpy(dest1,(char const *)src,(size_t)5);
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_8;
      __e_acsl_store_block((void *)(& process_status_8),4UL);
      __gen_e_acsl_waitpid(pid_8,& process_status_8,0);
      signal_eval(process_status_8,0,__gen_e_acsl_literal_string_17);
      __e_acsl_delete_block((void *)(& process_status_8));
    }
  }
  {
    pid_t pid_9 = __gen_e_acsl_fork();
    if (! pid_9) {
      __e_acsl_builtin_strncpy(dest1,(char const *)src,(size_t)6);
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_9;
      __e_acsl_store_block((void *)(& process_status_9),4UL);
      __gen_e_acsl_waitpid(pid_9,& process_status_9,0);
      signal_eval(process_status_9,1,__gen_e_acsl_literal_string_18);
      __e_acsl_delete_block((void *)(& process_status_9));
    }
  }
  {
    pid_t pid_10 = __gen_e_acsl_fork();
    if (! pid_10) {
      __e_acsl_builtin_strncpy(unalloc_str,(char const *)src,(size_t)5);
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_10;
      __e_acsl_store_block((void *)(& process_status_10),4UL);
      __gen_e_acsl_waitpid(pid_10,& process_status_10,0);
      signal_eval(process_status_10,1,__gen_e_acsl_literal_string_19);
      __e_acsl_delete_block((void *)(& process_status_10));
    }
  }
  {
    pid_t pid_11 = __gen_e_acsl_fork();
    if (! pid_11) {
      __e_acsl_builtin_strncpy(const_str,(char const *)src,(size_t)5);
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_11;
      __e_acsl_store_block((void *)(& process_status_11),4UL);
      __gen_e_acsl_waitpid(pid_11,& process_status_11,0);
      signal_eval(process_status_11,1,__gen_e_acsl_literal_string_20);
      __e_acsl_delete_block((void *)(& process_status_11));
    }
  }
  {
    pid_t pid_12 = __gen_e_acsl_fork();
    if (! pid_12) {
      __e_acsl_builtin_strncpy(src,(char const *)const_str,(size_t)5);
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_12;
      __e_acsl_store_block((void *)(& process_status_12),4UL);
      __gen_e_acsl_waitpid(pid_12,& process_status_12,0);
      signal_eval(process_status_12,0,__gen_e_acsl_literal_string_21);
      __e_acsl_delete_block((void *)(& process_status_12));
    }
  }
  {
    pid_t pid_13 = __gen_e_acsl_fork();
    if (! pid_13) {
      __e_acsl_builtin_strncpy(src,(char const *)src,(size_t)5);
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_13;
      __e_acsl_store_block((void *)(& process_status_13),4UL);
      __gen_e_acsl_waitpid(pid_13,& process_status_13,0);
      signal_eval(process_status_13,1,__gen_e_acsl_literal_string_22);
      __e_acsl_delete_block((void *)(& process_status_13));
    }
  }
  {
    pid_t pid_14 = __gen_e_acsl_fork();
    if (! pid_14) {
      __e_acsl_builtin_strncpy(& dest3[5],(char const *)(dest3),(size_t)5);
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_14;
      __e_acsl_store_block((void *)(& process_status_14),4UL);
      __gen_e_acsl_waitpid(pid_14,& process_status_14,0);
      signal_eval(process_status_14,0,__gen_e_acsl_literal_string_23);
      __e_acsl_delete_block((void *)(& process_status_14));
    }
  }
  {
    pid_t pid_15 = __gen_e_acsl_fork();
    if (! pid_15) {
      __e_acsl_builtin_strncpy(& dest3[4],(char const *)(dest3),(size_t)5);
      __gen_e_acsl_exit(0);
    }
    else {
      int process_status_15;
      __e_acsl_store_block((void *)(& process_status_15),4UL);
      __gen_e_acsl_waitpid(pid_15,& process_status_15,0);
      signal_eval(process_status_15,1,__gen_e_acsl_literal_string_24);
      __e_acsl_delete_block((void *)(& process_status_15));
    }
  }
  free((void *)src);
  free((void *)dest1);
  free((void *)dest2);
  test_memory_tracking();
  __retres = 0;
  __e_acsl_memory_clean();
  return __retres;
}


