int main(void)
{
int __retres;
__e_acsl_memory_init((int *)0,(char ***)0,(size_t)8);
__e_acsl_globals_init();
int i = 4;
while (1) {
int tmp;
tmp = i;
/*@ assert Eva: signed_overflow: -2147483648 ≤ i - 1; */
i --;
;
if (! tmp) break;
{
char *s = (char *)__gen_e_acsl_literal_string_3;
__e_acsl_store_block((void *)(& s),(size_t)8);
__e_acsl_full_init((void *)(& s));
/*@ assert \valid_read(s); */
{
int __gen_e_acsl_initialized;
int __gen_e_acsl_and;
__gen_e_acsl_initialized = __e_acsl_initialized((void *)(& s),
sizeof(char *));
if (__gen_e_acsl_initialized) {
int __gen_e_acsl_valid_read;
__gen_e_acsl_valid_read = __e_acsl_valid_read((void *)s,
sizeof(char),
(void *)s,
(void *)(& s));
__gen_e_acsl_and = __gen_e_acsl_valid_read;
}
else __gen_e_acsl_and = 0;
__e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion",(char *)"main",
(char *)"\\valid_read(s)",20);
}
/*@ assert ¬\valid(s); */
{
int __gen_e_acsl_initialized_2;
int __gen_e_acsl_and_2;
__gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& s),
sizeof(char *));
if (__gen_e_acsl_initialized_2) {
int __gen_e_acsl_valid;
__gen_e_acsl_valid = __e_acsl_valid((void *)s,sizeof(char),
(void *)s,(void *)(& s));
__gen_e_acsl_and_2 = __gen_e_acsl_valid;
}
else __gen_e_acsl_and_2 = 0;
__e_acsl_assert(! __gen_e_acsl_and_2,(char *)"Assertion",
(char *)"main",(char *)"!\\valid(s)",21);
__e_acsl_delete_block((void *)(& s));
}
}
}
f();
__retres = 0;
__e_acsl_delete_block((void *)(& S));
__e_acsl_memory_clean();
return __retres;
}
int main(int argc, char const **argv)
{
int __retres;
__e_acsl_memory_init(& argc,(char ***)(& argv),(size_t)8);
__e_acsl_globals_init();
__e_acsl_store_block((void *)(& __retres),(size_t)4);
__e_acsl_full_init((void *)(& __retres));
__retres = 0;
__e_acsl_delete_block((void *)(& argv));
__e_acsl_delete_block((void *)(& argc));
__e_acsl_delete_block((void *)(& test_specifier_application));
__e_acsl_delete_block((void *)(& apply_specifier));
__e_acsl_delete_block((void *)(& valid_specifiers));
__e_acsl_delete_block((void *)(& signal_eval));
__e_acsl_delete_block((void *)(& __fc_p_time_tm));
__e_acsl_delete_block((void *)(& __fc_time_tm));
__e_acsl_delete_block((void *)(__fc_fds));
__e_acsl_delete_block((void *)(& __fc_fds_state));
__e_acsl_delete_block((void *)(& __fc_time));
__e_acsl_delete_block((void *)(& __fc_p_fopen));
__e_acsl_delete_block((void *)(__fc_fopen));
__e_acsl_delete_block((void *)(& __fc_rand_max));
__e_acsl_delete_block((void *)(& __retres));
__e_acsl_memory_clean();
return __retres;
}
int main(void)
{
int __retres;
__e_acsl_memory_init((int *)0,(char ***)0,(size_t)4);
__e_acsl_globals_init();
char const *s = __gen_e_acsl_literal_string;
__e_acsl_store_block((void *)(& s),(size_t)4);
__e_acsl_full_init((void *)(& s));
f((void const *)s,'0',(unsigned long)11);
__retres = 0;
__e_acsl_delete_block((void *)(& s));
__e_acsl_memory_clean();
return __retres;
}
int main(void)
{
int __retres;
int t[2];
__e_acsl_memory_init((int *)0,(char ***)0,(size_t)8);
__e_acsl_globals_init();
int x = 0;
int i = 1;
t[0] = 1;
t[1] = 2;
printf(__gen_e_acsl_literal_string,x,t[0],t[i]);
__retres = 0;
__e_acsl_memory_clean();
return __retres;
}
int main(void)
{
int __retres;
__e_acsl_memory_init((int *)0,(char ***)0,(size_t)8);
__e_acsl_globals_init();
PA = (int *)(& A);
/*@ assert \offset((int *)A) ≡ 0; */
{
unsigned long __gen_e_acsl_offset;
__gen_e_acsl_offset = __e_acsl_offset((void *)(A));
__e_acsl_assert(__gen_e_acsl_offset == 0UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset((int *)A) == 0",13);
}
/*@ assert \offset(&A[3]) ≡ 12; */
{
unsigned long __gen_e_acsl_offset_2;
__gen_e_acsl_offset_2 = __e_acsl_offset((void *)(& A[3]));
__e_acsl_assert(__gen_e_acsl_offset_2 == 12UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(&A[3]) == 12",14);
}
/*@ assert \offset(PA) ≡ 0; */
{
unsigned long __gen_e_acsl_offset_3;
__gen_e_acsl_offset_3 = __e_acsl_offset((void *)PA);
__e_acsl_assert(__gen_e_acsl_offset_3 == 0UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(PA) == 0",15);
}
PA ++;
/*@ assert \offset(PA + 1) ≡ 8; */
{
unsigned long __gen_e_acsl_offset_4;
__gen_e_acsl_offset_4 = __e_acsl_offset((void *)(PA + 1));
__e_acsl_assert(__gen_e_acsl_offset_4 == 8UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(PA + 1) == 8",17);
}
int a[4] = {1, 2, 3, 4};
__e_acsl_store_block((void *)(a),(size_t)16);
__e_acsl_full_init((void *)(& a));
/*@ assert \offset((int *)a) ≡ 0; */
{
unsigned long __gen_e_acsl_offset_5;
__gen_e_acsl_offset_5 = __e_acsl_offset((void *)(a));
__e_acsl_assert(__gen_e_acsl_offset_5 == 0UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset((int *)a) == 0",21);
}
/*@ assert \offset(&a[1]) ≡ 4; */
{
unsigned long __gen_e_acsl_offset_6;
__gen_e_acsl_offset_6 = __e_acsl_offset((void *)(& a[1]));
__e_acsl_assert(__gen_e_acsl_offset_6 == 4UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(&a[1]) == 4",22);
}
/*@ assert \offset(&a[3]) ≡ 12; */
{
unsigned long __gen_e_acsl_offset_7;
__gen_e_acsl_offset_7 = __e_acsl_offset((void *)(& a[3]));
__e_acsl_assert(__gen_e_acsl_offset_7 == 12UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(&a[3]) == 12",23);
}
long l = (long)4;
__e_acsl_store_block((void *)(& l),(size_t)8);
__e_acsl_full_init((void *)(& l));
char *pl = (char *)(& l);
__e_acsl_store_block((void *)(& pl),(size_t)8);
__e_acsl_full_init((void *)(& pl));
/*@ assert \offset(&l) ≡ 0; */
{
unsigned long __gen_e_acsl_offset_8;
__gen_e_acsl_offset_8 = __e_acsl_offset((void *)(& l));
__e_acsl_assert(__gen_e_acsl_offset_8 == 0UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(&l) == 0",28);
}
/*@ assert \offset(pl) ≡ 0; */
{
unsigned long __gen_e_acsl_offset_9;
__gen_e_acsl_offset_9 = __e_acsl_offset((void *)pl);
__e_acsl_assert(__gen_e_acsl_offset_9 == 0UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(pl) == 0",29);
}
/*@ assert \offset(pl + 1) ≡ 1; */
{
unsigned long __gen_e_acsl_offset_10;
__gen_e_acsl_offset_10 = __e_acsl_offset((void *)(pl + 1));
__e_acsl_assert(__gen_e_acsl_offset_10 == 1UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(pl + 1) == 1",30);
}
/*@ assert \offset(pl + 7) ≡ 7; */
{
unsigned long __gen_e_acsl_offset_11;
__gen_e_acsl_offset_11 = __e_acsl_offset((void *)(pl + 7));
__e_acsl_assert(__gen_e_acsl_offset_11 == 7UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(pl + 7) == 7",31);
}
int *pi = (int *)(& l);
__e_acsl_store_block((void *)(& pi),(size_t)8);
__e_acsl_full_init((void *)(& pi));
/*@ assert \offset(pi) ≡ 0; */
{
unsigned long __gen_e_acsl_offset_12;
__gen_e_acsl_offset_12 = __e_acsl_offset((void *)pi);
__e_acsl_assert(__gen_e_acsl_offset_12 == 0UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(pi) == 0",33);
}
__e_acsl_full_init((void *)(& pi));
pi ++;
/*@ assert \offset(pi) ≡ 4; */
{
unsigned long __gen_e_acsl_offset_13;
__gen_e_acsl_offset_13 = __e_acsl_offset((void *)pi);
__e_acsl_assert(__gen_e_acsl_offset_13 == 4UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(pi) == 4",35);
}
char *p = malloc((unsigned long)12);
__e_acsl_store_block((void *)(& p),(size_t)8);
__e_acsl_full_init((void *)(& p));
/*@ assert \offset(p) ≡ 0; */
{
unsigned long __gen_e_acsl_offset_14;
__gen_e_acsl_offset_14 = __e_acsl_offset((void *)p);
__e_acsl_assert(__gen_e_acsl_offset_14 == 0UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(p) == 0",39);
}
/*@ assert \offset(p + 1) ≡ 1; */
{
unsigned long __gen_e_acsl_offset_15;
__gen_e_acsl_offset_15 = __e_acsl_offset((void *)(p + 1));
__e_acsl_assert(__gen_e_acsl_offset_15 == 1UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(p + 1) == 1",40);
}
/*@ assert \offset(p + 11) ≡ 11; */
{
unsigned long __gen_e_acsl_offset_16;
__gen_e_acsl_offset_16 = __e_acsl_offset((void *)(p + 11));
__e_acsl_assert(__gen_e_acsl_offset_16 == 11UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(p + 11) == 11",41);
}
__e_acsl_full_init((void *)(& p));
p += 5;
/*@ assert \offset(p + 5) ≡ 10; */
{
unsigned long __gen_e_acsl_offset_17;
__gen_e_acsl_offset_17 = __e_acsl_offset((void *)(p + 5));
__e_acsl_assert(__gen_e_acsl_offset_17 == 10UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(p + 5) == 10",43);
}
/*@ assert \offset(p - 5) ≡ 0; */
{
unsigned long __gen_e_acsl_offset_18;
__gen_e_acsl_offset_18 = __e_acsl_offset((void *)(p - 5));
__e_acsl_assert(__gen_e_acsl_offset_18 == 0UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(p - 5) == 0",44);
}
long *q = malloc((unsigned long)30 * sizeof(long));
__e_acsl_store_block((void *)(& q),(size_t)8);
__e_acsl_full_init((void *)(& q));
/*@ assert \offset(q) ≡ 0; */
{
unsigned long __gen_e_acsl_offset_19;
__gen_e_acsl_offset_19 = __e_acsl_offset((void *)q);
__e_acsl_assert(__gen_e_acsl_offset_19 == 0UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(q) == 0",49);
}
__e_acsl_full_init((void *)(& q));
q ++;
/*@ assert \offset(q) ≡ sizeof(long); */
{
unsigned long __gen_e_acsl_offset_20;
__gen_e_acsl_offset_20 = __e_acsl_offset((void *)q);
__e_acsl_assert(__gen_e_acsl_offset_20 == 8UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(q) == sizeof(long)",51);
}
__e_acsl_full_init((void *)(& q));
q += 2;
/*@ assert \offset(q) ≡ sizeof(long) * 3; */
{
unsigned long __gen_e_acsl_offset_21;
__gen_e_acsl_offset_21 = __e_acsl_offset((void *)q);
__e_acsl_assert(__gen_e_acsl_offset_21 == 24UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(q) == sizeof(long) * 3",
53);
}
__e_acsl_full_init((void *)(& q));
q += 4;
/*@ assert \offset(q) ≡ sizeof(long) * 7; */
{
unsigned long __gen_e_acsl_offset_22;
__gen_e_acsl_offset_22 = __e_acsl_offset((void *)q);
__e_acsl_assert(__gen_e_acsl_offset_22 == 56UL,(char *)"Assertion",
(char *)"main",(char *)"\\offset(q) == sizeof(long) * 7",
55);
}
__retres = 0;
__e_acsl_delete_block((void *)(& PA));
__e_acsl_delete_block((void *)(A));
__e_acsl_delete_block((void *)(& q));
__e_acsl_delete_block((void *)(& p));
__e_acsl_delete_block((void *)(& pi));
__e_acsl_delete_block((void *)(& pl));
__e_acsl_delete_block((void *)(& l));
__e_acsl_delete_block((void *)(a));
__e_acsl_memory_clean();
return __retres;
}
int main(void)
{
int __retres;
struct Zero zero;
__e_acsl_memory_init((int *)0,(char ***)0,(size_t)8);
__e_acsl_globals_init();
__e_acsl_store_block((void *)(& zero),(size_t)0);
/*@ assert \block_length(&ZERO) ≡ 0; */
{
unsigned long __gen_e_acsl_block_length;
__gen_e_acsl_block_length = __e_acsl_block_length((void *)(& ZERO));
__e_acsl_assert(__gen_e_acsl_block_length == 0UL,(char *)"Assertion",
(char *)"main",(char *)"\\block_length(&ZERO) == 0",15);
}
/*@ assert \block_length(&zero) ≡ 0; */
{
unsigned long __gen_e_acsl_block_length_2;
__gen_e_acsl_block_length_2 = __e_acsl_block_length((void *)(& zero));
__e_acsl_assert(__gen_e_acsl_block_length_2 == 0UL,(char *)"Assertion",
(char *)"main",(char *)"\\block_length(&zero) == 0",16);
}
PA = (int *)(& A);
/*@ assert \block_length((int *)A) ≡ sizeof(A); */
{
unsigned long __gen_e_acsl_block_length_3;
__gen_e_acsl_block_length_3 = __e_acsl_block_length((void *)(A));
__e_acsl_assert(__gen_e_acsl_block_length_3 == 16UL,(char *)"Assertion",
(char *)"main",
(char *)"\\block_length((int *)A) == sizeof(A)",20);
}
/*@ assert \block_length(&A[3]) ≡ sizeof(A); */
{
unsigned long __gen_e_acsl_block_length_4;
__gen_e_acsl_block_length_4 = __e_acsl_block_length((void *)(& A[3]));
__e_acsl_assert(__gen_e_acsl_block_length_4 == 16UL,(char *)"Assertion",
(char *)"main",
(char *)"\\block_length(&A[3]) == sizeof(A)",21);
}
/*@ assert \block_length(PA) ≡ sizeof(A); */
{
unsigned long __gen_e_acsl_block_length_5;
__gen_e_acsl_block_length_5 = __e_acsl_block_length((void *)PA);
__e_acsl_assert(__gen_e_acsl_block_length_5 == 16UL,(char *)"Assertion",
(char *)"main",(char *)"\\block_length(PA) == sizeof(A)",
22);
}
PA ++;
/*@ assert \block_length(PA + 1) ≡ \block_length(&A[1]); */
{
unsigned long __gen_e_acsl_block_length_6;
unsigned long __gen_e_acsl_block_length_7;
__gen_e_acsl_block_length_6 = __e_acsl_block_length((void *)(PA + 1));
__gen_e_acsl_block_length_7 = __e_acsl_block_length((void *)(& A[1]));
__e_acsl_assert(__gen_e_acsl_block_length_6 == __gen_e_acsl_block_length_7,
(char *)"Assertion",(char *)"main",
(char *)"\\block_length(PA + 1) == \\block_length(&A[1])",
24);
}
int a[4] = {1, 2, 3, 4};
__e_acsl_store_block((void *)(a),(size_t)16);
__e_acsl_full_init((void *)(& a));
int *pa = (int *)(& a);
__e_acsl_store_block((void *)(& pa),(size_t)8);
__e_acsl_full_init((void *)(& pa));
/*@ assert \block_length((int *)a) ≡ sizeof(a); */
{
unsigned long __gen_e_acsl_block_length_8;
__gen_e_acsl_block_length_8 = __e_acsl_block_length((void *)(a));
__e_acsl_assert(__gen_e_acsl_block_length_8 == 16UL,(char *)"Assertion",
(char *)"main",
(char *)"\\block_length((int *)a) == sizeof(a)",29);
}
/*@ assert \block_length(&a[3]) ≡ sizeof(a); */
{
unsigned long __gen_e_acsl_block_length_9;
__gen_e_acsl_block_length_9 = __e_acsl_block_length((void *)(& a[3]));
__e_acsl_assert(__gen_e_acsl_block_length_9 == 16UL,(char *)"Assertion",
(char *)"main",
(char *)"\\block_length(&a[3]) == sizeof(a)",30);
}
/*@ assert \block_length(pa) ≡ sizeof(a); */
{
unsigned long __gen_e_acsl_block_length_10;
__gen_e_acsl_block_length_10 = __e_acsl_block_length((void *)pa);
__e_acsl_assert(__gen_e_acsl_block_length_10 == 16UL,(char *)"Assertion",
(char *)"main",(char *)"\\block_length(pa) == sizeof(a)",
31);
}
__e_acsl_full_init((void *)(& pa));
pa ++;
/*@ assert \block_length(pa + 1) ≡ \block_length(&a[1]); */
{
unsigned long __gen_e_acsl_block_length_11;
unsigned long __gen_e_acsl_block_length_12;
__gen_e_acsl_block_length_11 = __e_acsl_block_length((void *)(pa + 1));
__gen_e_acsl_block_length_12 = __e_acsl_block_length((void *)(& a[1]));
__e_acsl_assert(__gen_e_acsl_block_length_11 == __gen_e_acsl_block_length_12,
(char *)"Assertion",(char *)"main",
(char *)"\\block_length(pa + 1) == \\block_length(&a[1])",
33);
}
long l = (long)4;
__e_acsl_store_block((void *)(& l),(size_t)8);
__e_acsl_full_init((void *)(& l));
char *pl = (char *)(& l);
__e_acsl_store_block((void *)(& pl),(size_t)8);
__e_acsl_full_init((void *)(& pl));
/*@ assert \block_length(&l) ≡ sizeof(long); */
{
unsigned long __gen_e_acsl_block_length_13;
__gen_e_acsl_block_length_13 = __e_acsl_block_length((void *)(& l));
__e_acsl_assert(__gen_e_acsl_block_length_13 == 8UL,(char *)"Assertion",
(char *)"main",
(char *)"\\block_length(&l) == sizeof(long)",39);
}
/*@ assert \block_length(pl) ≡ sizeof(long); */
{
unsigned long __gen_e_acsl_block_length_14;
__gen_e_acsl_block_length_14 = __e_acsl_block_length((void *)pl);
__e_acsl_assert(__gen_e_acsl_block_length_14 == 8UL,(char *)"Assertion",
(char *)"main",
(char *)"\\block_length(pl) == sizeof(long)",40);
}
/*@ assert \block_length(pl + 7) ≡ sizeof(long); */
{
unsigned long __gen_e_acsl_block_length_15;
__gen_e_acsl_block_length_15 = __e_acsl_block_length((void *)(pl + 7));
__e_acsl_assert(__gen_e_acsl_block_length_15 == 8UL,(char *)"Assertion",
(char *)"main",
(char *)"\\block_length(pl + 7) == sizeof(long)",41);
}
int *pi = (int *)(& l);
__e_acsl_store_block((void *)(& pi),(size_t)8);
__e_acsl_full_init((void *)(& pi));
/*@ assert \block_length(pi) ≡ \block_length(&l); */
{
unsigned long __gen_e_acsl_block_length_16;
unsigned long __gen_e_acsl_block_length_17;
__gen_e_acsl_block_length_16 = __e_acsl_block_length((void *)pi);
__gen_e_acsl_block_length_17 = __e_acsl_block_length((void *)(& l));
__e_acsl_assert(__gen_e_acsl_block_length_16 == __gen_e_acsl_block_length_17,
(char *)"Assertion",(char *)"main",
(char *)"\\block_length(pi) == \\block_length(&l)",43);
}
__e_acsl_full_init((void *)(& pi));
pi ++;
/*@ assert \block_length(pi) ≡ \block_length(&l); */
{
unsigned long __gen_e_acsl_block_length_18;
unsigned long __gen_e_acsl_block_length_19;
__gen_e_acsl_block_length_18 = __e_acsl_block_length((void *)pi);
__gen_e_acsl_block_length_19 = __e_acsl_block_length((void *)(& l));
__e_acsl_assert(__gen_e_acsl_block_length_18 == __gen_e_acsl_block_length_19,
(char *)"Assertion",(char *)"main",
(char *)"\\block_length(pi) == \\block_length(&l)",45);
}
size_t size = (unsigned long)12;
char *p = malloc(size);
__e_acsl_store_block((void *)(& p),(size_t)8);
__e_acsl_full_init((void *)(& p));
/*@ assert \block_length(p) ≡ size; */
{
unsigned long __gen_e_acsl_block_length_20;
__gen_e_acsl_block_length_20 = __e_acsl_block_length((void *)p);
__e_acsl_assert(__gen_e_acsl_block_length_20 == size,(char *)"Assertion",
(char *)"main",(char *)"\\block_length(p) == size",50);
}
/*@ assert \block_length(p + 11) ≡ size; */
{
unsigned long __gen_e_acsl_block_length_21;
__gen_e_acsl_block_length_21 = __e_acsl_block_length((void *)(p + 11));
__e_acsl_assert(__gen_e_acsl_block_length_21 == size,(char *)"Assertion",
(char *)"main",(char *)"\\block_length(p + 11) == size",
51);
}
__e_acsl_full_init((void *)(& p));
p += 5;
/*@ assert \block_length(p + 5) ≡ \block_length(p - 5); */
{
unsigned long __gen_e_acsl_block_length_22;
unsigned long __gen_e_acsl_block_length_23;
__gen_e_acsl_block_length_22 = __e_acsl_block_length((void *)(p + 5));
__gen_e_acsl_block_length_23 = __e_acsl_block_length((void *)(p - 5));
__e_acsl_assert(__gen_e_acsl_block_length_22 == __gen_e_acsl_block_length_23,
(char *)"Assertion",(char *)"main",
(char *)"\\block_length(p + 5) == \\block_length(p - 5)",
53);
}
size = (unsigned long)30 * sizeof(long);
long *q = malloc(size);
__e_acsl_store_block((void *)(& q),(size_t)8);
__e_acsl_full_init((void *)(& q));
/*@ assert \block_length(q) ≡ size; */
{
unsigned long __gen_e_acsl_block_length_24;
__gen_e_acsl_block_length_24 = __e_acsl_block_length((void *)q);
__e_acsl_assert(__gen_e_acsl_block_length_24 == size,(char *)"Assertion",
(char *)"main",(char *)"\\block_length(q) == size",59);
}
__e_acsl_full_init((void *)(& q));
q += 4;
/*@ assert \block_length(q) ≡ size; */
{
unsigned long __gen_e_acsl_block_length_25;
__gen_e_acsl_block_length_25 = __e_acsl_block_length((void *)q);
__e_acsl_assert(__gen_e_acsl_block_length_25 == size,(char *)"Assertion",
(char *)"main",(char *)"\\block_length(q) == size",61);
}
__retres = 0;
__e_acsl_delete_block((void *)(& ZERO));
__e_acsl_delete_block((void *)(& PA));
__e_acsl_delete_block((void *)(A));
__e_acsl_delete_block((void *)(& q));
__e_acsl_delete_block((void *)(& p));
__e_acsl_delete_block((void *)(& pi));
__e_acsl_delete_block((void *)(& pl));
__e_acsl_delete_block((void *)(& l));
__e_acsl_delete_block((void *)(& pa));
__e_acsl_delete_block((void *)(a));
__e_acsl_delete_block((void *)(& zero));
__e_acsl_memory_clean();
return __retres;
}
int main(void)
{
int __retres;
int *p;
int *q;
__e_acsl_memory_init((int *)0,(char ***)0,(size_t)8);
__e_acsl_globals_init();
__e_acsl_store_block((void *)(& q),(size_t)8);
__e_acsl_store_block((void *)(& p),(size_t)8);
int counter = 0;
size_t limit = (unsigned long)10000;
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_full_init((void *)(& p));
p = (int *)malloc((unsigned long)(1024 * 1024));
__e_acsl_temporal_store_nblock((void *)(& p),(void *)*(& p));
__e_acsl_temporal_store_nreferent((void *)(& q),(void *)(& p));
__e_acsl_full_init((void *)(& q));
q = p;
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_temporal_save_nreferent_parameter((void *)(& p),0U);
free((void *)p);
while ((size_t)counter < limit) {
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_full_init((void *)(& p));
p = (int *)malloc((unsigned long)(1024 * 1024));
__e_acsl_temporal_store_nblock((void *)(& p),(void *)*(& p));
counter ++;
/*@ assert Eva: dangling_pointer: ¬\dangling(&q); */
if (p != q) {
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_temporal_save_nreferent_parameter((void *)(& p),0U);
free((void *)p);
}
else {
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_temporal_save_nreferent_parameter((void *)(& p),1U);
__gen_e_acsl_printf_va_1(__gen_e_acsl_literal_string,(void *)p,counter);
break;
}
__e_acsl_temporal_store_nblock((void *)(& p),(void *)0);
__e_acsl_full_init((void *)(& p));
p = (int *)0;
}
/*@ assert Eva: dangling_pointer: ¬\dangling(&p); */
if (p) {
/*@ assert Eva: dangling_pointer: ¬\dangling(&q); */
__e_acsl_initialize((void *)q,sizeof(int));
/*@ assert Eva: mem_access: \valid(q); */
*q = 1;
__e_acsl_initialize((void *)p,sizeof(int));
*p = 2;
}
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_temporal_save_nreferent_parameter((void *)(& p),0U);
free((void *)p);
__retres = 0;
__e_acsl_delete_block((void *)(& q));
__e_acsl_delete_block((void *)(& p));
__e_acsl_memory_clean();
return __retres;
}
int main(int argc, char **argv)
{
int __retres;
__e_acsl_memory_init(& argc,& argv,(size_t)8);
__e_acsl_globals_init();
int *p = (int *)0;
__e_acsl_store_block((void *)(& p),(size_t)8);
__e_acsl_full_init((void *)(& p));
int *q = (int *)0;
int a = 1;
int b = 2;
__e_acsl_store_block((void *)(& b),(size_t)4);
__e_acsl_full_init((void *)(& b));
int c = 3;
__e_acsl_full_init((void *)(& p));
p = & b;
/*@ assert \valid(p); */
{
int __gen_e_acsl_initialized;
int __gen_e_acsl_and;
__gen_e_acsl_initialized = __e_acsl_initialized((void *)(& p),
sizeof(int *));
if (__gen_e_acsl_initialized) {
int __gen_e_acsl_valid;
__gen_e_acsl_valid = __e_acsl_valid((void *)p,sizeof(int),(void *)p,
(void *)(& p));
__gen_e_acsl_and = __gen_e_acsl_valid;
}
else __gen_e_acsl_and = 0;
__e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion",(char *)"main",
(char *)"\\valid(p)",24);
}
/*@ assert ¬\valid(p + 1); */
{
int __gen_e_acsl_valid_2;
__gen_e_acsl_valid_2 = __e_acsl_valid((void *)(p + 1),sizeof(int),
(void *)p,(void *)(& p));
__e_acsl_assert(! __gen_e_acsl_valid_2,(char *)"Assertion",
(char *)"main",(char *)"!\\valid(p + 1)",26);
}
__e_acsl_full_init((void *)(& p));
p = & B;
/*@ assert \valid(p); */
{
int __gen_e_acsl_initialized_2;
int __gen_e_acsl_and_2;
__gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& p),
sizeof(int *));
if (__gen_e_acsl_initialized_2) {
int __gen_e_acsl_valid_3;
__gen_e_acsl_valid_3 = __e_acsl_valid((void *)p,sizeof(int),(void *)p,
(void *)(& p));
__gen_e_acsl_and_2 = __gen_e_acsl_valid_3;
}
else __gen_e_acsl_and_2 = 0;
__e_acsl_assert(__gen_e_acsl_and_2,(char *)"Assertion",(char *)"main",
(char *)"\\valid(p)",29);
}
/*@ assert ¬\valid(p + 1); */
{
int __gen_e_acsl_valid_4;
__gen_e_acsl_valid_4 = __e_acsl_valid((void *)(p + 1),sizeof(int),
(void *)p,(void *)(& p));
__e_acsl_assert(! __gen_e_acsl_valid_4,(char *)"Assertion",
(char *)"main",(char *)"!\\valid(p + 1)",31);
}
char *pmin = malloc(sizeof(int));
__e_acsl_store_block((void *)(& pmin),(size_t)8);
__e_acsl_full_init((void *)(& pmin));
char *pmax = malloc(sizeof(int));
__e_acsl_store_block((void *)(& pmax),(size_t)8);
__e_acsl_full_init((void *)(& pmax));
if ((unsigned long)pmin > (unsigned long)pmax) {
char *t = pmin;
__e_acsl_store_block((void *)(& t),(size_t)8);
__e_acsl_full_init((void *)(& t));
__e_acsl_full_init((void *)(& pmin));
pmin = pmax;
__e_acsl_full_init((void *)(& pmax));
pmax = t;
__e_acsl_delete_block((void *)(& t));
}
__e_acsl_initialize((void *)pmin,sizeof(char));
/*@ assert Eva: mem_access: \valid(pmin); */
*pmin = (char)'P';
__e_acsl_initialize((void *)pmax,sizeof(char));
/*@ assert Eva: mem_access: \valid(pmax); */
*pmax = (char)'L';
int diff = (int)((unsigned long)pmax - (unsigned long)pmin);
/*@ assert \valid(pmin); */
{
int __gen_e_acsl_initialized_3;
int __gen_e_acsl_and_3;
__gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& pmin),
sizeof(char *));
if (__gen_e_acsl_initialized_3) {
int __gen_e_acsl_valid_5;
__gen_e_acsl_valid_5 = __e_acsl_valid((void *)pmin,sizeof(char),
(void *)pmin,(void *)(& pmin));
__gen_e_acsl_and_3 = __gen_e_acsl_valid_5;
}
else __gen_e_acsl_and_3 = 0;
__e_acsl_assert(__gen_e_acsl_and_3,(char *)"Assertion",(char *)"main",
(char *)"\\valid(pmin)",49);
}
/*@ assert \valid(pmax); */
{
int __gen_e_acsl_initialized_4;
int __gen_e_acsl_and_4;
__gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& pmax),
sizeof(char *));
if (__gen_e_acsl_initialized_4) {
int __gen_e_acsl_valid_6;
__gen_e_acsl_valid_6 = __e_acsl_valid((void *)pmax,sizeof(char),
(void *)pmax,(void *)(& pmax));
__gen_e_acsl_and_4 = __gen_e_acsl_valid_6;
}
else __gen_e_acsl_and_4 = 0;
__e_acsl_assert(__gen_e_acsl_and_4,(char *)"Assertion",(char *)"main",
(char *)"\\valid(pmax)",50);
}
/*@ assert ¬\valid(pmin + diff); */
{
int __gen_e_acsl_valid_7;
__gen_e_acsl_valid_7 = __e_acsl_valid((void *)(pmin + diff),sizeof(char),
(void *)pmin,(void *)(& pmin));
__e_acsl_assert(! __gen_e_acsl_valid_7,(char *)"Assertion",
(char *)"main",(char *)"!\\valid(pmin + diff)",52);
}
/*@ assert ¬\valid(pmax - diff); */
{
int __gen_e_acsl_valid_8;
__gen_e_acsl_valid_8 = __e_acsl_valid((void *)(pmax - diff),sizeof(char),
(void *)pmax,(void *)(& pmax));
__e_acsl_assert(! __gen_e_acsl_valid_8,(char *)"Assertion",
(char *)"main",(char *)"!\\valid(pmax - diff)",54);
}
__retres = 0;
__e_acsl_delete_block((void *)(& B));
__e_acsl_delete_block((void *)(& pmax));
__e_acsl_delete_block((void *)(& pmin));
__e_acsl_delete_block((void *)(& b));
__e_acsl_delete_block((void *)(& p));
__e_acsl_memory_clean();
return __retres;
}
int main(int argc, char const **argv)
{
int __retres;
__e_acsl_memory_init(& argc,(char ***)(& argv),(size_t)8);
__e_acsl_globals_init();
char *strings[2][2] =
{{(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_4}};
__e_acsl_store_block((void *)(strings),(size_t)32);
__e_acsl_full_init((void *)(& strings));
__e_acsl_temporal_store_nblock((void *)(& strings[1][1]),
(void *)__gen_e_acsl_literal_string_4);
__e_acsl_temporal_store_nblock((void *)(& strings[1][0]),
(void *)__gen_e_acsl_literal_string_3);
__e_acsl_temporal_store_nblock((void *)(& strings[0][1]),
(void *)__gen_e_acsl_literal_string_2);
__e_acsl_temporal_store_nblock((void *)(& strings[0][0]),
(void *)__gen_e_acsl_literal_string);
char **p = (char **)(strings);
__e_acsl_store_block((void *)(& p),(size_t)8);
__e_acsl_full_init((void *)(& p));
__e_acsl_temporal_store_nblock((void *)(& p),(void *)(strings));
/*@ assert \valid_read(p); */
{
int __gen_e_acsl_initialized;
int __gen_e_acsl_and;
__gen_e_acsl_initialized = __e_acsl_initialized((void *)(& p),
sizeof(char **));
if (__gen_e_acsl_initialized) {
int __gen_e_acsl_valid_read;
__gen_e_acsl_valid_read = __e_acsl_valid_read((void *)p,sizeof(char *),
(void *)p,(void *)(& p));
__gen_e_acsl_and = __gen_e_acsl_valid_read;
}
else __gen_e_acsl_and = 0;
__e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion",(char *)"main",
(char *)"\\valid_read(p)",41);
}
/*@ assert \valid_read(*p); */
{
int __gen_e_acsl_initialized_2;
int __gen_e_acsl_and_3;
__gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)p,
sizeof(char *));
if (__gen_e_acsl_initialized_2) {
int __gen_e_acsl_initialized_3;
int __gen_e_acsl_and_2;
int __gen_e_acsl_valid_read_3;
__gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& p),
sizeof(char **));
if (__gen_e_acsl_initialized_3) {
int __gen_e_acsl_valid_read_2;
__gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)p,
sizeof(char *),
(void *)p,
(void *)(& p));
__gen_e_acsl_and_2 = __gen_e_acsl_valid_read_2;
}
else __gen_e_acsl_and_2 = 0;
__e_acsl_assert(__gen_e_acsl_and_2,(char *)"RTE",(char *)"main",
(char *)"mem_access: \\valid_read(p)",42);
__gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)*p,
sizeof(char),
(void *)*p,(void *)p);
__gen_e_acsl_and_3 = __gen_e_acsl_valid_read_3;
}
else __gen_e_acsl_and_3 = 0;
__e_acsl_assert(__gen_e_acsl_and_3,(char *)"Assertion",(char *)"main",
(char *)"\\valid_read(*p)",42);
}
char *str[4] =
{(char *)__gen_e_acsl_literal_string_5,
(char *)__gen_e_acsl_literal_string_6,
(char *)__gen_e_acsl_literal_string_7,
(char *)0};
__e_acsl_store_block((void *)(str),(size_t)32);
__e_acsl_full_init((void *)(& str));
__e_acsl_temporal_store_nblock((void *)(& str[3]),(void *)0);
__e_acsl_temporal_store_nblock((void *)(& str[2]),
(void *)__gen_e_acsl_literal_string_7);
__e_acsl_temporal_store_nblock((void *)(& str[1]),
(void *)__gen_e_acsl_literal_string_6);
__e_acsl_temporal_store_nblock((void *)(str),
(void *)__gen_e_acsl_literal_string_5);
__e_acsl_temporal_store_nblock((void *)(& p),(void *)(& str));
__e_acsl_full_init((void *)(& p));
p = (char **)(& str);
/*@ assert \valid_read(p); */
{
int __gen_e_acsl_initialized_4;
int __gen_e_acsl_and_4;
__gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& p),
sizeof(char **));
if (__gen_e_acsl_initialized_4) {
int __gen_e_acsl_valid_read_4;
__gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)p,
sizeof(char *),
(void *)p,
(void *)(& p));
__gen_e_acsl_and_4 = __gen_e_acsl_valid_read_4;
}
else __gen_e_acsl_and_4 = 0;
__e_acsl_assert(__gen_e_acsl_and_4,(char *)"Assertion",(char *)"main",
(char *)"\\valid_read(p)",48);
}
/*@ assert \valid_read(*p); */
{
int __gen_e_acsl_initialized_5;
int __gen_e_acsl_and_6;
__gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)p,
sizeof(char *));
if (__gen_e_acsl_initialized_5) {
int __gen_e_acsl_initialized_6;
int __gen_e_acsl_and_5;
int __gen_e_acsl_valid_read_6;
__gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(& p),
sizeof(char **));
if (__gen_e_acsl_initialized_6) {
int __gen_e_acsl_valid_read_5;
__gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)p,
sizeof(char *),
(void *)p,
(void *)(& p));
__gen_e_acsl_and_5 = __gen_e_acsl_valid_read_5;
}
else __gen_e_acsl_and_5 = 0;
__e_acsl_assert(__gen_e_acsl_and_5,(char *)"RTE",(char *)"main",
(char *)"mem_access: \\valid_read(p)",49);
__gen_e_acsl_valid_read_6 = __e_acsl_valid_read((void *)*p,
sizeof(char),
(void *)*p,(void *)p);
__gen_e_acsl_and_6 = __gen_e_acsl_valid_read_6;
}
else __gen_e_acsl_and_6 = 0;
__e_acsl_assert(__gen_e_acsl_and_6,(char *)"Assertion",(char *)"main",
(char *)"\\valid_read(*p)",49);
}
char **P = (char **)(Strings);
__e_acsl_store_block((void *)(& P),(size_t)8);
__e_acsl_full_init((void *)(& P));
__e_acsl_temporal_store_nblock((void *)(& P),(void *)(Strings));
/*@ assert \valid_read(P); */
{
int __gen_e_acsl_initialized_7;
int __gen_e_acsl_and_7;
__gen_e_acsl_initialized_7 = __e_acsl_initialized((void *)(& P),
sizeof(char **));
if (__gen_e_acsl_initialized_7) {
int __gen_e_acsl_valid_read_7;
__gen_e_acsl_valid_read_7 = __e_acsl_valid_read((void *)P,
sizeof(char *),
(void *)P,
(void *)(& P));
__gen_e_acsl_and_7 = __gen_e_acsl_valid_read_7;
}
else __gen_e_acsl_and_7 = 0;
__e_acsl_assert(__gen_e_acsl_and_7,(char *)"Assertion",(char *)"main",
(char *)"\\valid_read(P)",53);
}
/*@ assert \valid_read(*P); */
{
int __gen_e_acsl_initialized_8;
int __gen_e_acsl_and_9;
__gen_e_acsl_initialized_8 = __e_acsl_initialized((void *)P,
sizeof(char *));
if (__gen_e_acsl_initialized_8) {
int __gen_e_acsl_initialized_9;
int __gen_e_acsl_and_8;
int __gen_e_acsl_valid_read_9;
__gen_e_acsl_initialized_9 = __e_acsl_initialized((void *)(& P),
sizeof(char **));
if (__gen_e_acsl_initialized_9) {
int __gen_e_acsl_valid_read_8;
__gen_e_acsl_valid_read_8 = __e_acsl_valid_read((void *)P,
sizeof(char *),
(void *)P,
(void *)(& P));
__gen_e_acsl_and_8 = __gen_e_acsl_valid_read_8;
}
else __gen_e_acsl_and_8 = 0;
__e_acsl_assert(__gen_e_acsl_and_8,(char *)"RTE",(char *)"main",
(char *)"mem_access: \\valid_read(P)",54);
__gen_e_acsl_valid_read_9 = __e_acsl_valid_read((void *)*P,
sizeof(char),
(void *)*P,(void *)P);
__gen_e_acsl_and_9 = __gen_e_acsl_valid_read_9;
}
else __gen_e_acsl_and_9 = 0;
__e_acsl_assert(__gen_e_acsl_and_9,(char *)"Assertion",(char *)"main",
(char *)"\\valid_read(*P)",54);
}
__e_acsl_temporal_store_nblock((void *)(& P),(void *)(& Str));
__e_acsl_full_init((void *)(& P));
P = (char **)(& Str);
/*@ assert \valid_read(P); */
{
int __gen_e_acsl_initialized_10;
int __gen_e_acsl_and_10;
__gen_e_acsl_initialized_10 = __e_acsl_initialized((void *)(& P),
sizeof(char **));
if (__gen_e_acsl_initialized_10) {
int __gen_e_acsl_valid_read_10;
__gen_e_acsl_valid_read_10 = __e_acsl_valid_read((void *)P,
sizeof(char *),
(void *)P,
(void *)(& P));
__gen_e_acsl_and_10 = __gen_e_acsl_valid_read_10;
}
else __gen_e_acsl_and_10 = 0;
__e_acsl_assert(__gen_e_acsl_and_10,(char *)"Assertion",(char *)"main",
(char *)"\\valid_read(P)",58);
}
/*@ assert \valid_read(*P); */
{
int __gen_e_acsl_initialized_11;
int __gen_e_acsl_and_12;
__gen_e_acsl_initialized_11 = __e_acsl_initialized((void *)P,
sizeof(char *));
if (__gen_e_acsl_initialized_11) {
int __gen_e_acsl_initialized_12;
int __gen_e_acsl_and_11;
int __gen_e_acsl_valid_read_12;
__gen_e_acsl_initialized_12 = __e_acsl_initialized((void *)(& P),
sizeof(char **));
if (__gen_e_acsl_initialized_12) {
int __gen_e_acsl_valid_read_11;
__gen_e_acsl_valid_read_11 = __e_acsl_valid_read((void *)P,
sizeof(char *),
(void *)P,
(void *)(& P));
__gen_e_acsl_and_11 = __gen_e_acsl_valid_read_11;
}
else __gen_e_acsl_and_11 = 0;
__e_acsl_assert(__gen_e_acsl_and_11,(char *)"RTE",(char *)"main",
(char *)"mem_access: \\valid_read(P)",59);
__gen_e_acsl_valid_read_12 = __e_acsl_valid_read((void *)*P,
sizeof(char),
(void *)*P,(void *)P);
__gen_e_acsl_and_12 = __gen_e_acsl_valid_read_12;
}
else __gen_e_acsl_and_12 = 0;
__e_acsl_assert(__gen_e_acsl_and_12,(char *)"Assertion",(char *)"main",
(char *)"\\valid_read(*P)",59);
}
int extra_lbits[1] = {0};
__e_acsl_store_block((void *)(extra_lbits),(size_t)4);
__e_acsl_full_init((void *)(& extra_lbits));
tree_desc l_desc = {.extra_bits = extra_lbits};
__e_acsl_store_block((void *)(& l_desc),(size_t)8);
__e_acsl_full_init((void *)(& l_desc));
__e_acsl_temporal_store_nblock((void *)(& l_desc.extra_bits),
(void *)(extra_lbits));
tree_desc descs[2] =
{{.extra_bits = extra_lbits}, {.extra_bits = extra_lbits}};
