/* 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_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_30;
char *__gen_e_acsl_literal_string_29;
char *__gen_e_acsl_literal_string_28;
char *__gen_e_acsl_literal_string_27;
char *__gen_e_acsl_literal_string_26;
char *__gen_e_acsl_literal_string_25;
char *__gen_e_acsl_literal_string_24;
char *__gen_e_acsl_literal_string_23;
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);

void test_memory_tracking(void)
{
  {
    char dest[4];
    __e_acsl_store_block((void *)(dest),4UL);
    __e_acsl_builtin_strcpy(dest,__gen_e_acsl_literal_string_6);
    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 * ((1 - 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 .. 1])",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 .. 1])";
      __gen_e_acsl_assert_data.file = "strcat.c";
      __gen_e_acsl_assert_data.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data.line = 21;
      __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 .. 1]); */ ;
    {
      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 *)dest",(void *)(dest));
      __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 * ((3 - 2) + 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 *)(dest + 1 * 2),
                                                        (size_t)__gen_e_acsl_if_2);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,
                                   "\\initialized(&dest[2 .. 3])",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(&dest[2 .. 3])";
      __gen_e_acsl_assert_data_2.file = "strcat.c";
      __gen_e_acsl_assert_data_2.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_2.line = 22;
      __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(&dest[2 .. 3]); */ ;
    {
      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 *)src",(void *)(src));
      __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 *)(src + 1 * 0),
                                                        (size_t)__gen_e_acsl_if_3);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
                                   "\\initialized(&src[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(&src[0 .. 1])";
      __gen_e_acsl_assert_data_3.file = "strcat.c";
      __gen_e_acsl_assert_data_3.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_3.line = 23;
      __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(&src[0 .. 1]); */ ;
    __e_acsl_builtin_strcat(dest,(char const *)(src));
    {
      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 * ((2 - 0) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,"size",0,
                                   __gen_e_acsl_size_4);
      if (__gen_e_acsl_size_4 <= 0) __gen_e_acsl_if_4 = 0;
      else {
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,"size",0,
                                     __gen_e_acsl_size_4);
        __gen_e_acsl_if_4 = __gen_e_acsl_size_4;
      }
      __gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(dest + 1 * 0),
                                                        (size_t)__gen_e_acsl_if_4);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,
                                   "\\initialized(&dest[0 .. 2])",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[0 .. 2])";
      __gen_e_acsl_assert_data_4.file = "strcat.c";
      __gen_e_acsl_assert_data_4.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_4.line = 26;
      __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[0 .. 2]); */ ;
    {
      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,"&dest[3]",
                                   (void *)(& dest[3]));
      __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_5,
                                     "sizeof(char)",0,sizeof(char));
      __gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)(& dest[3]),
                                                        sizeof(char));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,
                                   "\\initialized(&dest[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[3])";
      __gen_e_acsl_assert_data_5.file = "strcat.c";
      __gen_e_acsl_assert_data_5.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_5.line = 27;
      __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[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);
    __e_acsl_builtin_strcpy(dest_0,__gen_e_acsl_literal_string_6);
    char src_0[3] = {(char)'b', (char)'c', (char)'\000'};
    __e_acsl_store_block((void *)(src_0),3UL);
    __e_acsl_full_init((void *)(& src_0));
    {
      int __gen_e_acsl_size_5;
      int __gen_e_acsl_if_5;
      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 *)dest_0",(void *)(dest_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_5 = 1 * ((1 - 0) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,"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_6,"size",0,
                                     __gen_e_acsl_size_5);
        __gen_e_acsl_if_5 = __gen_e_acsl_size_5;
      }
      __gen_e_acsl_initialized_6 = __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_6,
                                   "\\initialized(&dest_0[0 .. 1])",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(&dest_0[0 .. 1])";
      __gen_e_acsl_assert_data_6.file = "strcat.c";
      __gen_e_acsl_assert_data_6.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_6.line = 33;
      __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(&dest_0[0 .. 1]); */ ;
    {
      int __gen_e_acsl_size_6;
      int __gen_e_acsl_if_6;
      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_int(& __gen_e_acsl_assert_data_7,
                                   "sizeof(char)",0,1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,
                                   "sizeof(char)",0,1);
      __gen_e_acsl_size_6 = 1 * ((3 - 2) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,"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_7,"size",0,
                                     __gen_e_acsl_size_6);
        __gen_e_acsl_if_6 = __gen_e_acsl_size_6;
      }
      __gen_e_acsl_initialized_7 = __e_acsl_initialized((void *)(dest_0 + 
                                                                 1 * 2),
                                                        (size_t)__gen_e_acsl_if_6);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,
                                   "\\initialized(&dest_0[2 .. 3])",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(&dest_0[2 .. 3])";
      __gen_e_acsl_assert_data_7.file = "strcat.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(&dest_0[2 .. 3]); */ ;
    {
      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 *)src_0",(void *)(src_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 * ((2 - 0) + 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 *)(src_0 + 
                                                                 1 * 0),
                                                        (size_t)__gen_e_acsl_if_7);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,
                                   "\\initialized(&src_0[0 .. 2])",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(&src_0[0 .. 2])";
      __gen_e_acsl_assert_data_8.file = "strcat.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(&src_0[0 .. 2]); */ ;
    __e_acsl_builtin_strncat(dest_0,(char const *)(src_0),(size_t)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_0",(void *)(dest_0));
      __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 * ((2 - 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_0 + 
                                                                 1 * 0),
                                                        (size_t)__gen_e_acsl_if_8);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_9,
                                   "\\initialized(&dest_0[0 .. 2])",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_0[0 .. 2])";
      __gen_e_acsl_assert_data_9.file = "strcat.c";
      __gen_e_acsl_assert_data_9.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_9.line = 38;
      __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_0[0 .. 2]); */ ;
    {
      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,
                                   "&dest_0[3]",(void *)(& dest_0[3]));
      __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_10,
                                     "sizeof(char)",0,sizeof(char));
      __gen_e_acsl_initialized_10 = __e_acsl_initialized((void *)(& dest_0[3]),
                                                         sizeof(char));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_10,
                                   "\\initialized(&dest_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(&dest_0[3])";
      __gen_e_acsl_assert_data_10.file = "strcat.c";
      __gen_e_acsl_assert_data_10.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_10.line = 39;
      __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(&dest_0[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);
    __e_acsl_builtin_strcpy(dest_1,__gen_e_acsl_literal_string_6);
    char src_1[2] = {(char)'b', (char)'\000'};
    __e_acsl_store_block((void *)(src_1),2UL);
    __e_acsl_full_init((void *)(& src_1));
    {
      int __gen_e_acsl_size_9;
      int __gen_e_acsl_if_9;
      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_9 = 1 * ((1 - 0) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_11,"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_11,"size",0,
                                     __gen_e_acsl_size_9);
        __gen_e_acsl_if_9 = __gen_e_acsl_size_9;
      }
      __gen_e_acsl_initialized_11 = __e_acsl_initialized((void *)(dest_1 + 
                                                                  1 * 0),
                                                         (size_t)__gen_e_acsl_if_9);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_11,
                                   "\\initialized(&dest_1[0 .. 1])",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 .. 1])";
      __gen_e_acsl_assert_data_11.file = "strcat.c";
      __gen_e_acsl_assert_data_11.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_11.line = 45;
      __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 .. 1]); */ ;
    {
      int __gen_e_acsl_size_10;
      int __gen_e_acsl_if_10;
      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,
                                   "(char *)dest_1",(void *)(dest_1));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_12,
                                   "sizeof(char)",0,1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_12,
                                   "sizeof(char)",0,1);
      __gen_e_acsl_size_10 = 1 * ((3 - 2) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_12,"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_12,"size",0,
                                     __gen_e_acsl_size_10);
        __gen_e_acsl_if_10 = __gen_e_acsl_size_10;
      }
      __gen_e_acsl_initialized_12 = __e_acsl_initialized((void *)(dest_1 + 
                                                                  1 * 2),
                                                         (size_t)__gen_e_acsl_if_10);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_12,
                                   "\\initialized(&dest_1[2 .. 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[2 .. 3])";
      __gen_e_acsl_assert_data_12.file = "strcat.c";
      __gen_e_acsl_assert_data_12.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_12.line = 46;
      __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[2 .. 3]); */ ;
    {
      int __gen_e_acsl_size_11;
      int __gen_e_acsl_if_11;
      int __gen_e_acsl_initialized_13;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_13 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_13,
                                   "(char *)src_1",(void *)(src_1));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_13,
                                   "sizeof(char)",0,1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_13,
                                   "sizeof(char)",0,1);
      __gen_e_acsl_size_11 = 1 * ((1 - 0) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_13,"size",0,
                                   __gen_e_acsl_size_11);
      if (__gen_e_acsl_size_11 <= 0) __gen_e_acsl_if_11 = 0;
      else {
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_13,"size",0,
                                     __gen_e_acsl_size_11);
        __gen_e_acsl_if_11 = __gen_e_acsl_size_11;
      }
      __gen_e_acsl_initialized_13 = __e_acsl_initialized((void *)(src_1 + 
                                                                  1 * 0),
                                                         (size_t)__gen_e_acsl_if_11);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_13,
                                   "\\initialized(&src_1[0 .. 1])",0,
                                   __gen_e_acsl_initialized_13);
      __gen_e_acsl_assert_data_13.blocking = 1;
      __gen_e_acsl_assert_data_13.kind = "Assertion";
      __gen_e_acsl_assert_data_13.pred_txt = "\\initialized(&src_1[0 .. 1])";
      __gen_e_acsl_assert_data_13.file = "strcat.c";
      __gen_e_acsl_assert_data_13.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_13.line = 47;
      __e_acsl_assert(__gen_e_acsl_initialized_13,
                      & __gen_e_acsl_assert_data_13);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_13);
    }
    /*@ assert \initialized(&src_1[0 .. 1]); */ ;
    __e_acsl_builtin_strncat(dest_1,(char const *)(src_1),(size_t)2);
    {
      int __gen_e_acsl_size_12;
      int __gen_e_acsl_if_12;
      int __gen_e_acsl_initialized_14;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_14 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_14,
                                   "(char *)dest_1",(void *)(dest_1));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,
                                   "sizeof(char)",0,1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,
                                   "sizeof(char)",0,1);
      __gen_e_acsl_size_12 = 1 * ((2 - 0) + 1);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,"size",0,
                                   __gen_e_acsl_size_12);
      if (__gen_e_acsl_size_12 <= 0) __gen_e_acsl_if_12 = 0;
      else {
        __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,"size",0,
                                     __gen_e_acsl_size_12);
        __gen_e_acsl_if_12 = __gen_e_acsl_size_12;
      }
      __gen_e_acsl_initialized_14 = __e_acsl_initialized((void *)(dest_1 + 
                                                                  1 * 0),
                                                         (size_t)__gen_e_acsl_if_12);
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,
                                   "\\initialized(&dest_1[0 .. 2])",0,
                                   __gen_e_acsl_initialized_14);
      __gen_e_acsl_assert_data_14.blocking = 1;
      __gen_e_acsl_assert_data_14.kind = "Assertion";
      __gen_e_acsl_assert_data_14.pred_txt = "\\initialized(&dest_1[0 .. 2])";
      __gen_e_acsl_assert_data_14.file = "strcat.c";
      __gen_e_acsl_assert_data_14.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_14.line = 50;
      __e_acsl_assert(__gen_e_acsl_initialized_14,
                      & __gen_e_acsl_assert_data_14);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_14);
    }
    /*@ assert \initialized(&dest_1[0 .. 2]); */ ;
    {
      int __gen_e_acsl_initialized_15;
      __e_acsl_assert_data_t __gen_e_acsl_assert_data_15 =
        {.values = (void *)0};
      __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_15,
                                   "&dest_1[3]",(void *)(& dest_1[3]));
      __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_15,
                                     "sizeof(char)",0,sizeof(char));
      __gen_e_acsl_initialized_15 = __e_acsl_initialized((void *)(& dest_1[3]),
                                                         sizeof(char));
      __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_15,
                                   "\\initialized(&dest_1[3])",0,
                                   __gen_e_acsl_initialized_15);
      __gen_e_acsl_assert_data_15.blocking = 1;
      __gen_e_acsl_assert_data_15.kind = "Assertion";
      __gen_e_acsl_assert_data_15.pred_txt = "!\\initialized(&dest_1[3])";
      __gen_e_acsl_assert_data_15.file = "strcat.c";
      __gen_e_acsl_assert_data_15.fct = "test_memory_tracking";
      __gen_e_acsl_assert_data_15.line = 51;
      __e_acsl_assert(! __gen_e_acsl_initialized_15,
                      & __gen_e_acsl_assert_data_15);
      __e_acsl_assert_clean(& __gen_e_acsl_assert_data_15);
    }
    /*@ assert !\initialized(&dest_1[3]); */ ;
    __e_acsl_delete_block((void *)(src_1));
    __e_acsl_delete_block((void *)(dest_1));
  }
  return;
}

/*@ 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_22 = "strcat.c:99";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_22,
                         sizeof("strcat.c:99"));
    __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 = "strcat.c:98";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_21,
                         sizeof("strcat.c:98"));
    __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 = "strcat.c:85";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_20,
                         sizeof("strcat.c:85"));
    __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 = "strcat.c:84";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_19,
                         sizeof("strcat.c:84"));
    __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 = "strcat.c:83";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_18,
                         sizeof("strcat.c:83"));
    __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 = "strcat.c:82";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_17,
                         sizeof("strcat.c:82"));
    __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 = "strcat.c:81";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_16,
                         sizeof("strcat.c:81"));
    __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 = "strcat.c:80";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_15,
                         sizeof("strcat.c:80"));
    __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 = "strcat.c:79";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_14,
                         sizeof("strcat.c:79"));
    __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 = "strcat.c:78";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_13,
                         sizeof("strcat.c:78"));
    __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 = "strcat.c:77";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_12,
                         sizeof("strcat.c:77"));
    __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 = "strcat.c:76";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_11,
                         sizeof("strcat.c:76"));
    __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 = "strcat.c:75";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_10,
                         sizeof("strcat.c:75"));
    __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 = "strcat.c:73";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_9,
                         sizeof("strcat.c:73"));
    __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_30 = "strcat.c:108";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_30,
                         sizeof("strcat.c:108"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_30);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_30);
    __gen_e_acsl_literal_string_29 = "strcat.c:107";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_29,
                         sizeof("strcat.c:107"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_29);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_29);
    __gen_e_acsl_literal_string_28 = "strcat.c:106";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_28,
                         sizeof("strcat.c:106"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_28);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_28);
    __gen_e_acsl_literal_string_27 = "strcat.c:104";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_27,
                         sizeof("strcat.c:104"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_27);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_27);
    __gen_e_acsl_literal_string_26 = "strcat.c:103";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_26,
                         sizeof("strcat.c:103"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_26);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_26);
    __gen_e_acsl_literal_string_25 = "strcat.c:102";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_25,
                         sizeof("strcat.c:102"));
    __e_acsl_full_init((void *)__gen_e_acsl_literal_string_25);
    __e_acsl_mark_readonly((void *)__gen_e_acsl_literal_string_25);
    __gen_e_acsl_literal_string_24 = "strcat.c:101";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_24,
                         sizeof("strcat.c:101"));
    __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 = "strcat.c:100";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_23,
                         sizeof("strcat.c:100"));
    __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_7 = "abcd";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_7,
                         sizeof("abcd"));
    __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 = "a";
    __e_acsl_store_block((void *)__gen_e_acsl_literal_string_6,sizeof("a"));
    __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 *const_str = (char *)__gen_e_acsl_literal_string_7;
  char *unalloc_str = malloc((size_t)5);
  char *_barrier = malloc((size_t)1);
  char *empty_str = (char *)__gen_e_acsl_literal_string_8;
  free((void *)unalloc_str);
  {
    char dest1[9] =
      {(char)'d', (char)'c', (char)'b', (char)'a', (char)'\000'};
    __e_acsl_store_block((void *)(dest1),9UL);
    __e_acsl_full_init((void *)(& dest1));
    char dest2[8] =
      {(char)'d', (char)'c', (char)'b', (char)'a', (char)'\000'};
    __e_acsl_store_block((void *)(dest2),8UL);
    __e_acsl_full_init((void *)(& dest2));
    char dest3[5] =
      {(char)'-', (char)'-', (char)'-', (char)'-', (char)'\000'};
    __e_acsl_store_block((void *)(dest3),5UL);
    __e_acsl_full_init((void *)(& dest3));
    char dest4[10] =
      {(char)'d', (char)'c', (char)'b', (char)'a', (char)'\000'};
    __e_acsl_store_block((void *)(dest4),10UL);
    __e_acsl_full_init((void *)(& dest4));
    char *pd1 = (char *)(& dest1);
    __e_acsl_store_block((void *)(& pd1),8UL);
    __e_acsl_full_init((void *)(& pd1));
    char *pd2 = (char *)(& dest2);
    __e_acsl_store_block((void *)(& pd2),8UL);
    __e_acsl_full_init((void *)(& pd2));
    char *pd3 = (char *)(& dest3);
    __e_acsl_store_block((void *)(& pd3),8UL);
    __e_acsl_full_init((void *)(& pd3));
    char *pd4 = (char *)(& dest4);
    __e_acsl_store_block((void *)(& pd4),8UL);
    __e_acsl_full_init((void *)(& pd4));
    {
      pid_t pid = __gen_e_acsl_fork();
      if (! pid) {
        __e_acsl_builtin_strcat(dest1,(char const *)const_str);
        __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_9);
        __e_acsl_delete_block((void *)(& process_status));
      }
    }
    {
      pid_t pid_0 = __gen_e_acsl_fork();
      if (! pid_0) {
        __e_acsl_builtin_strcat(dest3,(char const *)empty_str);
        __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_10);
        __e_acsl_delete_block((void *)(& process_status_0));
      }
    }
    {
      pid_t pid_1 = __gen_e_acsl_fork();
      if (! pid_1) {
        __e_acsl_builtin_strcat(dest2,(char const *)const_str);
        __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_11);
        __e_acsl_delete_block((void *)(& process_status_1));
      }
    }
    {
      pid_t pid_2 = __gen_e_acsl_fork();
      if (! pid_2) {
        __e_acsl_builtin_strcat(unalloc_str,(char const *)const_str);
        __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_12);
        __e_acsl_delete_block((void *)(& process_status_2));
      }
    }
    {
      pid_t pid_3 = __gen_e_acsl_fork();
      if (! pid_3) {
        __e_acsl_builtin_strcat(dest2,(char const *)unalloc_str);
        __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_13);
        __e_acsl_delete_block((void *)(& process_status_3));
      }
    }
    {
      pid_t pid_4 = __gen_e_acsl_fork();
      if (! pid_4) {
        __e_acsl_builtin_strcat((char *)0,__gen_e_acsl_literal_string_8);
        __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,1,__gen_e_acsl_literal_string_14);
        __e_acsl_delete_block((void *)(& process_status_4));
      }
    }
    {
      pid_t pid_5 = __gen_e_acsl_fork();
      if (! pid_5) {
        __e_acsl_builtin_strcat(dest1,(char const *)0);
        __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_15);
        __e_acsl_delete_block((void *)(& process_status_5));
      }
    }
    {
      pid_t pid_6 = __gen_e_acsl_fork();
      if (! pid_6) {
        __e_acsl_builtin_strcat(const_str,(char const *)const_str);
        __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,1,__gen_e_acsl_literal_string_16);
        __e_acsl_delete_block((void *)(& process_status_6));
      }
    }
    {
      pid_t pid_7 = __gen_e_acsl_fork();
      if (! pid_7) {
        __e_acsl_builtin_strcat(pd1,(char const *)pd1);
        __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_17);
        __e_acsl_delete_block((void *)(& process_status_7));
      }
    }
    {
      pid_t pid_8 = __gen_e_acsl_fork();
      if (! pid_8) {
        __e_acsl_builtin_strcat(pd1 + 3,(char const *)pd1);
        __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,1,__gen_e_acsl_literal_string_18);
        __e_acsl_delete_block((void *)(& process_status_8));
      }
    }
    {
      pid_t pid_9 = __gen_e_acsl_fork();
      if (! pid_9) {
        __e_acsl_builtin_strcat(pd4 + 4,(char const *)pd4);
        __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_19);
        __e_acsl_delete_block((void *)(& process_status_9));
      }
    }
    {
      pid_t pid_10 = __gen_e_acsl_fork();
      if (! pid_10) {
        __e_acsl_initialize((void *)(pd4 + 5),sizeof(char));
        *(pd4 + 5) = (char)'\000';
        __e_acsl_builtin_strcat(pd4 + 5,(char const *)pd4);
        __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,0,__gen_e_acsl_literal_string_20);
        __e_acsl_delete_block((void *)(& process_status_10));
      }
      __e_acsl_delete_block((void *)(& pd4));
      __e_acsl_delete_block((void *)(& pd3));
      __e_acsl_delete_block((void *)(& pd2));
      __e_acsl_delete_block((void *)(& pd1));
      __e_acsl_delete_block((void *)(dest4));
      __e_acsl_delete_block((void *)(dest3));
      __e_acsl_delete_block((void *)(dest2));
      __e_acsl_delete_block((void *)(dest1));
    }
  }
  {
    char dest1_0[9] =
      {(char)'d', (char)'c', (char)'b', (char)'a', (char)'\000'};
    __e_acsl_store_block((void *)(dest1_0),9UL);
    __e_acsl_full_init((void *)(& dest1_0));
    char dest2_0[8] =
      {(char)'d', (char)'c', (char)'b', (char)'a', (char)'\000'};
    __e_acsl_store_block((void *)(dest2_0),8UL);
    __e_acsl_full_init((void *)(& dest2_0));
    char dest3_0[5] =
      {(char)'-', (char)'-', (char)'-', (char)'-', (char)'\000'};
    __e_acsl_store_block((void *)(dest3_0),5UL);
    __e_acsl_full_init((void *)(& dest3_0));
    char dest4_0[10] =
      {(char)'d', (char)'c', (char)'b', (char)'a', (char)'\000'};
    __e_acsl_store_block((void *)(dest4_0),10UL);
    __e_acsl_full_init((void *)(& dest4_0));
    char *pd1_0 = (char *)(& dest1_0);
    __e_acsl_store_block((void *)(& pd1_0),8UL);
    __e_acsl_full_init((void *)(& pd1_0));
    char *pd2_0 = (char *)(& dest2_0);
    __e_acsl_store_block((void *)(& pd2_0),8UL);
    __e_acsl_full_init((void *)(& pd2_0));
    char *pd3_0 = (char *)(& dest3_0);
    __e_acsl_store_block((void *)(& pd3_0),8UL);
    __e_acsl_full_init((void *)(& pd3_0));
    char *pd4_0 = (char *)(& dest4_0);
    __e_acsl_store_block((void *)(& pd4_0),8UL);
    __e_acsl_full_init((void *)(& pd4_0));
    {
      pid_t pid_11 = __gen_e_acsl_fork();
      if (! pid_11) {
        __e_acsl_builtin_strncat(dest1_0,(char const *)const_str,(size_t)4);
        __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,0,__gen_e_acsl_literal_string_21);
        __e_acsl_delete_block((void *)(& process_status_11));
      }
    }
    {
      pid_t pid_12 = __gen_e_acsl_fork();
      if (! pid_12) {
        __e_acsl_builtin_strncat(dest2_0,(char const *)const_str,(size_t)4);
        __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,1,__gen_e_acsl_literal_string_22);
        __e_acsl_delete_block((void *)(& process_status_12));
      }
    }
    {
      pid_t pid_13 = __gen_e_acsl_fork();
      if (! pid_13) {
        __e_acsl_builtin_strncat(unalloc_str,(char const *)const_str,
                                 (size_t)1);
        __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_23);
        __e_acsl_delete_block((void *)(& process_status_13));
      }
    }
    {
      pid_t pid_14 = __gen_e_acsl_fork();
      if (! pid_14) {
        __e_acsl_builtin_strncat(dest2_0,(char const *)unalloc_str,(size_t)1);
        __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,1,__gen_e_acsl_literal_string_24);
        __e_acsl_delete_block((void *)(& process_status_14));
      }
    }
    {
      pid_t pid_15 = __gen_e_acsl_fork();
      if (! pid_15) {
        __e_acsl_builtin_strncat((char *)0,(char const *)const_str,(size_t)1);
        __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_25);
        __e_acsl_delete_block((void *)(& process_status_15));
      }
    }
    {
      pid_t pid_16 = __gen_e_acsl_fork();
      if (! pid_16) {
        __e_acsl_builtin_strncat(dest2_0,(char const *)0,(size_t)1);
        __gen_e_acsl_exit(0);
      }
      else {
        int process_status_16;
        __e_acsl_store_block((void *)(& process_status_16),4UL);
        __gen_e_acsl_waitpid(pid_16,& process_status_16,0);
        signal_eval(process_status_16,1,__gen_e_acsl_literal_string_26);
        __e_acsl_delete_block((void *)(& process_status_16));
      }
    }
    {
      pid_t pid_17 = __gen_e_acsl_fork();
      if (! pid_17) {
        __e_acsl_builtin_strncat(const_str,(char const *)const_str,(size_t)1);
        __gen_e_acsl_exit(0);
      }
      else {
        int process_status_17;
        __e_acsl_store_block((void *)(& process_status_17),4UL);
        __gen_e_acsl_waitpid(pid_17,& process_status_17,0);
        signal_eval(process_status_17,1,__gen_e_acsl_literal_string_27);
        __e_acsl_delete_block((void *)(& process_status_17));
      }
    }
    {
      pid_t pid_18 = __gen_e_acsl_fork();
      if (! pid_18) {
        __e_acsl_builtin_strncat(pd1_0,(char const *)pd1_0,(size_t)1);
        __gen_e_acsl_exit(0);
      }
      else {
        int process_status_18;
        __e_acsl_store_block((void *)(& process_status_18),4UL);
        __gen_e_acsl_waitpid(pid_18,& process_status_18,0);
        signal_eval(process_status_18,1,__gen_e_acsl_literal_string_28);
        __e_acsl_delete_block((void *)(& process_status_18));
      }
    }
    {
      pid_t pid_19 = __gen_e_acsl_fork();
      if (! pid_19) {
        __e_acsl_builtin_strncat(pd1_0 + 3,(char const *)pd1_0,(size_t)5);
        __gen_e_acsl_exit(0);
      }
      else {
        int process_status_19;
        __e_acsl_store_block((void *)(& process_status_19),4UL);
        __gen_e_acsl_waitpid(pid_19,& process_status_19,0);
        signal_eval(process_status_19,1,__gen_e_acsl_literal_string_29);
        __e_acsl_delete_block((void *)(& process_status_19));
      }
    }
    {
      pid_t pid_20 = __gen_e_acsl_fork();
      if (! pid_20) {
        __e_acsl_builtin_strncat(pd4_0 + 4,(char const *)pd4_0,(size_t)5);
        __gen_e_acsl_exit(0);
      }
      else {
        int process_status_20;
        __e_acsl_store_block((void *)(& process_status_20),4UL);
        __gen_e_acsl_waitpid(pid_20,& process_status_20,0);
        signal_eval(process_status_20,1,__gen_e_acsl_literal_string_30);
        __e_acsl_delete_block((void *)(& process_status_20));
      }
      __e_acsl_delete_block((void *)(& pd4_0));
      __e_acsl_delete_block((void *)(& pd3_0));
      __e_acsl_delete_block((void *)(& pd2_0));
      __e_acsl_delete_block((void *)(& pd1_0));
      __e_acsl_delete_block((void *)(dest4_0));
      __e_acsl_delete_block((void *)(dest3_0));
      __e_acsl_delete_block((void *)(dest2_0));
      __e_acsl_delete_block((void *)(dest1_0));
    }
  }
  test_memory_tracking();
  __retres = 0;
  __e_acsl_memory_clean();
  return __retres;
}


