void build_tree(tree_desc *desc)
{
int *extra;
__e_acsl_store_block((void *)(& extra),(size_t)8);
__e_acsl_store_block((void *)(& desc),(size_t)8);
__e_acsl_temporal_pull_parameter((void *)(& desc),0U,8UL);
__e_acsl_temporal_store_nreferent((void *)(& extra),
(void *)(& desc->extra_bits));
__e_acsl_full_init((void *)(& extra));
extra = desc->extra_bits;
/*@ assert \valid(extra); */
{
int __gen_e_acsl_initialized;
int __gen_e_acsl_and;
__gen_e_acsl_initialized = __e_acsl_initialized((void *)(& extra),
sizeof(int *));
if (__gen_e_acsl_initialized) {
int __gen_e_acsl_valid;
__gen_e_acsl_valid = __e_acsl_valid((void *)extra,sizeof(int),
(void *)extra,(void *)(& extra));
__gen_e_acsl_and = __gen_e_acsl_valid;
}
else __gen_e_acsl_and = 0;
__e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion",
(char *)"build_tree",(char *)"\\valid(extra)",23);
}
__e_acsl_delete_block((void *)(& desc));
__e_acsl_delete_block((void *)(& extra));
return;
}
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;
}
void f(void const *s, int c, unsigned long n)
{
__e_acsl_store_block((void *)(& s),(size_t)8);
unsigned char const *p = (unsigned char const *)s;
__e_acsl_store_block((void *)(& p),(size_t)8);
__e_acsl_full_init((void *)(& p));
/*@ assert p - (unsigned char const *)s ≡ n - n; */
{
__e_acsl_mpz_t __gen_e_acsl_;
__e_acsl_mpz_t __gen_e_acsl_n;
__e_acsl_mpz_t __gen_e_acsl_sub;
int __gen_e_acsl_eq;
__gmpz_init_set_ui(__gen_e_acsl_,p - (unsigned char const *)s);
__gmpz_init_set_ui(__gen_e_acsl_n,n);
__gmpz_init(__gen_e_acsl_sub);
__gmpz_sub(__gen_e_acsl_sub,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_n),
(__e_acsl_mpz_struct const *)(__gen_e_acsl_n));
__gen_e_acsl_eq = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_),
(__e_acsl_mpz_struct const *)(__gen_e_acsl_sub));
__e_acsl_assert(__gen_e_acsl_eq == 0,(char *)"Assertion",(char *)"f",
(char *)"p - (unsigned char const *)s == n - n",16);
__gmpz_clear(__gen_e_acsl_);
__gmpz_clear(__gen_e_acsl_n);
__gmpz_clear(__gen_e_acsl_sub);
}
/*@ assert p - (unsigned char const *)s ≡ 0; */
__e_acsl_assert(p - (unsigned char const *)s == 0UL,(char *)"Assertion",
(char *)"f",(char *)"p - (unsigned char const *)s == 0",17);
__e_acsl_delete_block((void *)(& s));
__e_acsl_delete_block((void *)(& p));
return;
}
int f(void)
{
int __retres;
char *s1 = (char *)__gen_e_acsl_literal_string;
__e_acsl_store_block((void *)(& s1),(size_t)8);
__e_acsl_full_init((void *)(& s1));
char *s2 = (char *)__gen_e_acsl_literal_string_2;
__e_acsl_store_block((void *)(& s2),(size_t)8);
__e_acsl_full_init((void *)(& s2));
/*@ assert \valid_read(S); */
{
int __gen_e_acsl_valid_read;
__gen_e_acsl_valid_read = __e_acsl_valid_read((void *)S,sizeof(char),
(void *)S,(void *)(& S));
__e_acsl_assert(__gen_e_acsl_valid_read,(char *)"Assertion",(char *)"f",
(char *)"\\valid_read(S)",10);
}
/*@ assert \valid_read(s1); */
{
int __gen_e_acsl_initialized;
int __gen_e_acsl_and;
__gen_e_acsl_initialized = __e_acsl_initialized((void *)(& s1),
sizeof(char *));
if (__gen_e_acsl_initialized) {
int __gen_e_acsl_valid_read_2;
__gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)s1,
sizeof(char),
(void *)s1,
(void *)(& s1));
__gen_e_acsl_and = __gen_e_acsl_valid_read_2;
}
else __gen_e_acsl_and = 0;
__e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion",(char *)"f",
(char *)"\\valid_read(s1)",11);
}
/*@ assert \valid_read(s2); */
{
int __gen_e_acsl_initialized_2;
int __gen_e_acsl_and_2;
__gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& s2),
sizeof(char *));
if (__gen_e_acsl_initialized_2) {
int __gen_e_acsl_valid_read_3;
__gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)s2,
sizeof(char),
(void *)s2,
(void *)(& s2));
__gen_e_acsl_and_2 = __gen_e_acsl_valid_read_3;
}
else __gen_e_acsl_and_2 = 0;
__e_acsl_assert(__gen_e_acsl_and_2,(char *)"Assertion",(char *)"f",
(char *)"\\valid_read(s2)",12);
}
__retres = 0;
__e_acsl_delete_block((void *)(& s2));
__e_acsl_delete_block((void *)(& s1));
return __retres;
}
void atp_NORMAL_computeAverageAccel(ArrayInt *Accel, int *AverageAccel)
{
__e_acsl_store_block((void *)(& AverageAccel),(size_t)8);
__e_acsl_store_block((void *)(& Accel),(size_t)8);
__e_acsl_initialize((void *)AverageAccel,sizeof(int));
*AverageAccel = (((((*Accel)[4] + (*Accel)[3]) + (*Accel)[2]) + (*Accel)[1]) + (*Accel)[0]) / 5;
__e_acsl_delete_block((void *)(& AverageAccel));
__e_acsl_delete_block((void *)(& Accel));
return;
}
int goto_bts(void)
{
int __retres;
int *p;
__e_acsl_store_block((void *)(& p),(size_t)8);
{
int a = 0;
__e_acsl_store_block((void *)(& a),(size_t)4);
__e_acsl_full_init((void *)(& a));
__e_acsl_full_init((void *)(& p));
p = & a;
/*@ 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 *)"goto_bts",(char *)"\\valid(p)",13);
}
__e_acsl_delete_block((void *)(& a));
goto L;
__e_acsl_delete_block((void *)(& a));
}
L:
/*@ 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_2;
/*@ assert Eva: dangling_pointer: ¬\dangling(&p); */
__gen_e_acsl_valid_2 = __e_acsl_valid((void *)p,sizeof(int),(void *)p,
(void *)(& p));
__gen_e_acsl_and_2 = __gen_e_acsl_valid_2;
}
else __gen_e_acsl_and_2 = 0;
__e_acsl_assert(! __gen_e_acsl_and_2,(char *)"Assertion",
(char *)"goto_bts",(char *)"!\\valid(p)",18);
}
__retres = 0;
__e_acsl_delete_block((void *)(& p));
return __retres;
}
int *pfun(char c, int *p, int *p2, int *p3, int *p4, int i)
{
__e_acsl_store_block((void *)(& p),(size_t)8);
__e_acsl_temporal_pull_parameter((void *)(& p),1U,8UL);
int *q = p;
__e_acsl_store_block((void *)(& q),(size_t)8);
__e_acsl_full_init((void *)(& q));
__e_acsl_temporal_store_nreferent((void *)(& q),(void *)(& p));
__e_acsl_temporal_save_return((void *)(& q));
__e_acsl_delete_block((void *)(& p));
__e_acsl_delete_block((void *)(& q));
return q;
}
int main(void)
{
int __retres;
int av;
__e_acsl_memory_init((int *)0,(char ***)0,(size_t)8);
__e_acsl_store_block((void *)(& av),(size_t)4);
ArrayInt Accel = {1, 2, 3, 4, 5};
__e_acsl_store_block((void *)(Accel),(size_t)20);
__e_acsl_full_init((void *)(& Accel));
__gen_e_acsl_atp_NORMAL_computeAverageAccel(& Accel,& av);
__retres = 0;
__e_acsl_delete_block((void *)(& av));
__e_acsl_delete_block((void *)(Accel));
__e_acsl_memory_clean();
return __retres;
}
/*@ ensures
∀ ℤ n;
1 < n ≤ 3 ⇒ \old(*(t + n) ≡ 12) ∧ \old(*(t + (n - 1)) > 5);
ensures \let m = 4; \old(*(t + m) ≡ -4) ∧ \old(*(t + (m - 4))) ≡ 9;
*/
void __gen_e_acsl_f(int *t)
{
__e_acsl_store_block((void *)(& t),(size_t)8);
f(t);
__e_acsl_delete_block((void *)(& t));
return;
}
void f(void const *s, int c, unsigned long n)
{
__e_acsl_store_block((void *)(& s),(size_t)4);
unsigned char const *p = (unsigned char const *)s;
__e_acsl_store_block((void *)(& p),(size_t)4);
__e_acsl_full_init((void *)(& p));
/*@ assert p - (unsigned char const *)s ≡ n - n; */
__e_acsl_assert(p - (unsigned char const *)s == n - (long long)n,
(char *)"Assertion",(char *)"f",
(char *)"p - (unsigned char const *)s == n - n",16);
/*@ assert p - (unsigned char const *)s ≡ 0; */
__e_acsl_assert(p - (unsigned char const *)s == 0U,(char *)"Assertion",
(char *)"f",(char *)"p - (unsigned char const *)s == 0",17);
__e_acsl_delete_block((void *)(& s));
__e_acsl_delete_block((void *)(& p));
return;
}
void signal_eval(int status, int expect_signal, char const *at)
{
__e_acsl_store_block((void *)(& at),(size_t)8);
__e_acsl_store_block((void *)(& expect_signal),(size_t)4);
__e_acsl_store_block((void *)(& status),(size_t)4);
int signalled = (int)((signed char)((status & 0x7f) + 1)) >> 1 > 0;
__e_acsl_store_block((void *)(& signalled),(size_t)4);
__e_acsl_full_init((void *)(& signalled));
if (signalled) {
if (expect_signal) __e_acsl_builtin_printf("s",
__gen_e_acsl_literal_string,
at);
else goto _LAND_1;
}
else
_LAND_1:
if (! signalled) {
if (! expect_signal) __e_acsl_builtin_printf("s",
__gen_e_acsl_literal_string_2,
at);
else goto _LAND_0;
}
else
_LAND_0:
if (! signalled) {
if (expect_signal) {
__e_acsl_builtin_printf("s",__gen_e_acsl_literal_string_3,at);
__gen_e_acsl_exit(1);
}
else goto _LAND;
}
else {
_LAND: ;
if (signalled)
if (! expect_signal) {
__e_acsl_builtin_printf("s",__gen_e_acsl_literal_string_4,at);
__gen_e_acsl_exit(2);
}
}
__e_acsl_delete_block((void *)(& at));
__e_acsl_delete_block((void *)(& expect_signal));
__e_acsl_delete_block((void *)(& status));
__e_acsl_delete_block((void *)(& signalled));
return;
}
int main(int argc, char const **argv)
{
int __retres;
__e_acsl_memory_init(& argc,(char ***)(& argv),(size_t)8);
int a = 1;
__e_acsl_store_block((void *)(& a),(size_t)4);
__e_acsl_full_init((void *)(& a));
int *p = & a;
__e_acsl_store_block((void *)(& p),(size_t)8);
__e_acsl_full_init((void *)(& p));
__e_acsl_temporal_store_nblock((void *)(& p),(void *)(& a));
uintptr_t addr = (unsigned long)(& addr);
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_temporal_save_nreferent_parameter((void *)(& p),1U);
__e_acsl_temporal_save_nblock_parameter((void *)(& a),2U);
__e_acsl_full_init((void *)(& p));
p = pfun((char)'a',p,& a,(int *)0,(int *)addr,2);
__e_acsl_temporal_pull_return((void *)(& p));
/*@ 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)",28);
}
__retres = 0;
__e_acsl_delete_block((void *)(& p));
__e_acsl_delete_block((void *)(& a));
__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;
}
void apply_specifier(char *format, int spec)
{
int n;
char *tmp_1;
__e_acsl_store_block((void *)(& tmp_1),(size_t)8);
__e_acsl_store_block((void *)(& n),(size_t)4);
__e_acsl_store_block((void *)(& spec),(size_t)4);
__e_acsl_store_block((void *)(& format),(size_t)8);
void *p = (void *)0;
__e_acsl_store_block((void *)(& p),(size_t)8);
__e_acsl_full_init((void *)(& p));
__e_acsl_full_init((void *)(& tmp_1));
tmp_1 = __gen_e_acsl_strchr(__gen_e_acsl_literal_string_5,spec);
if (tmp_1 != (char *)0) __e_acsl_builtin_printf("e",(char const *)format,
1.0);
else {
char *tmp_0;
__e_acsl_store_block((void *)(& tmp_0),(size_t)8);
__e_acsl_full_init((void *)(& tmp_0));
tmp_0 = __gen_e_acsl_strchr(__gen_e_acsl_literal_string_6,spec);
if (tmp_0 != (char *)0) __e_acsl_builtin_printf("D",(char const *)format,
1U);
else {
char *tmp;
__e_acsl_store_block((void *)(& tmp),(size_t)8);
__e_acsl_full_init((void *)(& tmp));
tmp = __gen_e_acsl_strchr(__gen_e_acsl_literal_string_7,spec);
if (tmp != (char *)0) __e_acsl_builtin_printf("d",(char const *)format,
97);
else
if (spec == 's') __e_acsl_builtin_printf("s",(char const *)format,
__gen_e_acsl_literal_string_8);
else
if (spec == 'n') __e_acsl_builtin_printf("i",(char const *)format,
& n);
else
if (spec == 'p') __e_acsl_builtin_printf("p",
(char const *)format,p);
else __gen_e_acsl_abort();
__e_acsl_delete_block((void *)(& tmp));
}
__e_acsl_delete_block((void *)(& tmp_0));
}
__e_acsl_delete_block((void *)(& spec));
__e_acsl_delete_block((void *)(& format));
__e_acsl_delete_block((void *)(& tmp_1));
__e_acsl_delete_block((void *)(& p));
__e_acsl_delete_block((void *)(& n));
return;
}
/*@ requires \valid(&argc);
requires \valid(&argv); */
int main(int argc, char **argv)
{
int __retres;
__e_acsl_memory_init(& argc,& argv,(size_t)8);
{
int __gen_e_acsl_valid;
int __gen_e_acsl_valid_2;
__gen_e_acsl_valid = __e_acsl_valid((void *)(& argc),sizeof(int),
(void *)(& argc),(void *)0);
__e_acsl_assert(__gen_e_acsl_valid,(char *)"Precondition",(char *)"main",
(char *)"\\valid(&argc)",7);
__gen_e_acsl_valid_2 = __e_acsl_valid((void *)(& argv),sizeof(char **),
(void *)(& argv),(void *)0);
__e_acsl_assert(__gen_e_acsl_valid_2,(char *)"Precondition",
(char *)"main",(char *)"\\valid(&argv)",8);
}
__retres = __gen_e_acsl_main(argc,argv);
__e_acsl_delete_block((void *)(& argv));
__e_acsl_memory_clean();
return __retres;
}
int main(void)
{
int __retres;
temporal t1;
temporal t2;
temporal *tp;
temporal tarr[2];
larger l;
larger *lp;
larger larr[2];
__e_acsl_memory_init((int *)0,(char ***)0,(size_t)8);
__e_acsl_store_block((void *)(larr),(size_t)64);
__e_acsl_store_block((void *)(& lp),(size_t)8);
__e_acsl_store_block((void *)(& l),(size_t)32);
__e_acsl_store_block((void *)(tarr),(size_t)32);
__e_acsl_store_block((void *)(& t2),(size_t)16);
__e_acsl_store_block((void *)(& t1),(size_t)16);
int a = 1;
__e_acsl_store_block((void *)(& a),(size_t)4);
__e_acsl_full_init((void *)(& a));
int b = 2;
__e_acsl_temporal_store_nblock((void *)(& t1.p),(void *)(& a));
__e_acsl_initialize((void *)(& t1.p),sizeof(char *));
t1.p = (char *)(& a);
__e_acsl_temporal_store_nreferent((void *)(& t1.q),(void *)(& t1.p));
__e_acsl_initialize((void *)(& t1.q),sizeof(char *));
t1.q = t1.p;
/*@ assert \valid(t1.p) ∧ \valid(t1.q); */
{
int __gen_e_acsl_initialized;
int __gen_e_acsl_and;
int __gen_e_acsl_and_3;
__gen_e_acsl_initialized = __e_acsl_initialized((void *)(& t1.p),
sizeof(char *));
if (__gen_e_acsl_initialized) {
int __gen_e_acsl_valid;
__gen_e_acsl_valid = __e_acsl_valid((void *)t1.p,sizeof(char),
(void *)t1.p,(void *)(& t1.p));
__gen_e_acsl_and = __gen_e_acsl_valid;
}
else __gen_e_acsl_and = 0;
if (__gen_e_acsl_and) {
int __gen_e_acsl_initialized_2;
int __gen_e_acsl_and_2;
__gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& t1.q),
sizeof(char *));
if (__gen_e_acsl_initialized_2) {
int __gen_e_acsl_valid_2;
__gen_e_acsl_valid_2 = __e_acsl_valid((void *)t1.q,sizeof(char),
(void *)t1.q,(void *)(& t1.q));
__gen_e_acsl_and_2 = __gen_e_acsl_valid_2;
}
else __gen_e_acsl_and_2 = 0;
__gen_e_acsl_and_3 = __gen_e_acsl_and_2;
}
else __gen_e_acsl_and_3 = 0;
__e_acsl_assert(__gen_e_acsl_and_3,(char *)"Assertion",(char *)"main",
(char *)"\\valid(t1.p) && \\valid(t1.q)",31);
}
/*@ assert ¬\valid(t2.p) ∧ ¬\valid(t2.q); */
{
int __gen_e_acsl_initialized_3;
int __gen_e_acsl_and_4;
int __gen_e_acsl_and_6;
__gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& t2.p),
sizeof(char *));
if (__gen_e_acsl_initialized_3) {
int __gen_e_acsl_valid_3;
__gen_e_acsl_valid_3 = __e_acsl_valid((void *)t2.p,sizeof(char),
(void *)t2.p,(void *)(& t2.p));
__gen_e_acsl_and_4 = __gen_e_acsl_valid_3;
}
else __gen_e_acsl_and_4 = 0;
if (! __gen_e_acsl_and_4) {
int __gen_e_acsl_initialized_4;
int __gen_e_acsl_and_5;
__gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& t2.q),
sizeof(char *));
if (__gen_e_acsl_initialized_4) {
int __gen_e_acsl_valid_4;
__gen_e_acsl_valid_4 = __e_acsl_valid((void *)t2.q,sizeof(char),
(void *)t2.q,(void *)(& t2.q));
__gen_e_acsl_and_5 = __gen_e_acsl_valid_4;
}
else __gen_e_acsl_and_5 = 0;
__gen_e_acsl_and_6 = ! __gen_e_acsl_and_5;
}
else __gen_e_acsl_and_6 = 0;
__e_acsl_assert(__gen_e_acsl_and_6,(char *)"Assertion",(char *)"main",
(char *)"!\\valid(t2.p) && !\\valid(t2.q)",32);
}
__e_acsl_temporal_memcpy((void *)(& t2),(void *)(& t1),(size_t)16);
__e_acsl_full_init((void *)(& t2));
t2 = t1;
/*@ assert \valid(t2.p) ∧ \valid(t2.q); */
{
int __gen_e_acsl_initialized_5;
int __gen_e_acsl_and_7;
int __gen_e_acsl_and_9;
__gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)(& t2.p),
sizeof(char *));
if (__gen_e_acsl_initialized_5) {
int __gen_e_acsl_valid_5;
__gen_e_acsl_valid_5 = __e_acsl_valid((void *)t2.p,sizeof(char),
(void *)t2.p,(void *)(& t2.p));
__gen_e_acsl_and_7 = __gen_e_acsl_valid_5;
}
else __gen_e_acsl_and_7 = 0;
if (__gen_e_acsl_and_7) {
int __gen_e_acsl_initialized_6;
int __gen_e_acsl_and_8;
__gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(& t2.q),
sizeof(char *));
if (__gen_e_acsl_initialized_6) {
int __gen_e_acsl_valid_6;
__gen_e_acsl_valid_6 = __e_acsl_valid((void *)t2.q,sizeof(char),
(void *)t2.q,(void *)(& t2.q));
__gen_e_acsl_and_8 = __gen_e_acsl_valid_6;
}
else __gen_e_acsl_and_8 = 0;
__gen_e_acsl_and_9 = __gen_e_acsl_and_8;
}
else __gen_e_acsl_and_9 = 0;
__e_acsl_assert(__gen_e_acsl_and_9,(char *)"Assertion",(char *)"main",
(char *)"\\valid(t2.p) && \\valid(t2.q)",35);
}
__e_acsl_temporal_store_nblock((void *)(& t2.p),(void *)0);
__e_acsl_initialize((void *)(& t2.p),sizeof(char *));
t2.p = (char *)0;
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_initialize((void *)(& t2.q),sizeof(char *));
t2.q = (char *)malloc((unsigned long)4);
__e_acsl_temporal_store_nblock((void *)(& t2.q),(void *)*(& t2.q));
/*@ assert ¬\valid(t2.p) ∧ \valid(t2.q); */
{
int __gen_e_acsl_initialized_7;
int __gen_e_acsl_and_10;
int __gen_e_acsl_and_12;
__gen_e_acsl_initialized_7 = __e_acsl_initialized((void *)(& t2.p),
sizeof(char *));
if (__gen_e_acsl_initialized_7) {
int __gen_e_acsl_valid_7;
__gen_e_acsl_valid_7 = __e_acsl_valid((void *)t2.p,sizeof(char),
(void *)t2.p,(void *)(& t2.p));
__gen_e_acsl_and_10 = __gen_e_acsl_valid_7;
}
else __gen_e_acsl_and_10 = 0;
if (! __gen_e_acsl_and_10) {
int __gen_e_acsl_initialized_8;
int __gen_e_acsl_and_11;
__gen_e_acsl_initialized_8 = __e_acsl_initialized((void *)(& t2.q),
sizeof(char *));
if (__gen_e_acsl_initialized_8) {
int __gen_e_acsl_valid_8;
__gen_e_acsl_valid_8 = __e_acsl_valid((void *)t2.q,sizeof(char),
(void *)t2.q,(void *)(& t2.q));
__gen_e_acsl_and_11 = __gen_e_acsl_valid_8;
}
else __gen_e_acsl_and_11 = 0;
__gen_e_acsl_and_12 = __gen_e_acsl_and_11;
}
else __gen_e_acsl_and_12 = 0;
__e_acsl_assert(__gen_e_acsl_and_12,(char *)"Assertion",(char *)"main",
(char *)"!\\valid(t2.p) && \\valid(t2.q)",39);
}
__e_acsl_temporal_memcpy((void *)(& l.t),(void *)(& t2),(size_t)16);
__e_acsl_initialize((void *)(& l.t),sizeof(struct temporal_t));
l.t = t2;
/*@ assert ¬\valid(l.t.p) ∧ \valid(l.t.q); */
{
int __gen_e_acsl_initialized_9;
int __gen_e_acsl_and_13;
int __gen_e_acsl_and_15;
__gen_e_acsl_initialized_9 = __e_acsl_initialized((void *)(& l.t.p),
sizeof(char *));
if (__gen_e_acsl_initialized_9) {
int __gen_e_acsl_valid_9;
__gen_e_acsl_valid_9 = __e_acsl_valid((void *)l.t.p,sizeof(char),
(void *)l.t.p,(void *)(& l.t.p));
__gen_e_acsl_and_13 = __gen_e_acsl_valid_9;
}
else __gen_e_acsl_and_13 = 0;
if (! __gen_e_acsl_and_13) {
int __gen_e_acsl_initialized_10;
int __gen_e_acsl_and_14;
__gen_e_acsl_initialized_10 = __e_acsl_initialized((void *)(& l.t.q),
sizeof(char *));
if (__gen_e_acsl_initialized_10) {
int __gen_e_acsl_valid_10;
__gen_e_acsl_valid_10 = __e_acsl_valid((void *)l.t.q,sizeof(char),
(void *)l.t.q,
(void *)(& l.t.q));
__gen_e_acsl_and_14 = __gen_e_acsl_valid_10;
}
else __gen_e_acsl_and_14 = 0;
__gen_e_acsl_and_15 = __gen_e_acsl_and_14;
}
else __gen_e_acsl_and_15 = 0;
__e_acsl_assert(__gen_e_acsl_and_15,(char *)"Assertion",(char *)"main",
(char *)"!\\valid(l.t.p) && \\valid(l.t.q)",42);
}
__e_acsl_temporal_store_nblock((void *)(& lp),(void *)(& l));
__e_acsl_full_init((void *)(& lp));
lp = & l;
/*@ assert ¬\valid(lp->t.p); */
{
int __gen_e_acsl_initialized_11;
int __gen_e_acsl_and_16;
__gen_e_acsl_initialized_11 = __e_acsl_initialized((void *)(& lp->t.p),
sizeof(char *));
if (__gen_e_acsl_initialized_11) {
int __gen_e_acsl_valid_read;
int __gen_e_acsl_valid_11;
__gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(& lp->t.p),
sizeof(char *),
(void *)(& lp->t.p),
(void *)0);
__e_acsl_assert(__gen_e_acsl_valid_read,(char *)"RTE",(char *)"main",
(char *)"mem_access: \\valid_read(&lp->t.p)",45);
__gen_e_acsl_valid_11 = __e_acsl_valid((void *)lp->t.p,sizeof(char),
(void *)lp->t.p,
(void *)(& lp->t.p));
__gen_e_acsl_and_16 = __gen_e_acsl_valid_11;
}
else __gen_e_acsl_and_16 = 0;
__e_acsl_assert(! __gen_e_acsl_and_16,(char *)"Assertion",(char *)"main",
(char *)"!\\valid(lp->t.p)",45);
}
__e_acsl_temporal_memcpy((void *)(tarr),(void *)(& t2),(size_t)16);
__e_acsl_initialize((void *)(tarr),sizeof(temporal));
tarr[0] = t2;
/*@ assert ¬\valid(tarr[0].p) ∧ \valid(tarr[0].q); */
{
int __gen_e_acsl_initialized_12;
int __gen_e_acsl_and_17;
int __gen_e_acsl_and_19;
__gen_e_acsl_initialized_12 = __e_acsl_initialized((void *)(& tarr[0].p),
sizeof(char *));
if (__gen_e_acsl_initialized_12) {
int __gen_e_acsl_valid_12;
__gen_e_acsl_valid_12 = __e_acsl_valid((void *)tarr[0].p,sizeof(char),
(void *)tarr[0].p,
(void *)(& tarr[0].p));
__gen_e_acsl_and_17 = __gen_e_acsl_valid_12;
}
else __gen_e_acsl_and_17 = 0;
if (! __gen_e_acsl_and_17) {
int __gen_e_acsl_initialized_13;
int __gen_e_acsl_and_18;
__gen_e_acsl_initialized_13 = __e_acsl_initialized((void *)(& tarr[0].q),
sizeof(char *));
if (__gen_e_acsl_initialized_13) {
int __gen_e_acsl_valid_13;
__gen_e_acsl_valid_13 = __e_acsl_valid((void *)tarr[0].q,
sizeof(char),
(void *)tarr[0].q,
(void *)(& tarr[0].q));
__gen_e_acsl_and_18 = __gen_e_acsl_valid_13;
}
else __gen_e_acsl_and_18 = 0;
__gen_e_acsl_and_19 = __gen_e_acsl_and_18;
}
else __gen_e_acsl_and_19 = 0;
__e_acsl_assert(__gen_e_acsl_and_19,(char *)"Assertion",(char *)"main",
(char *)"!\\valid(tarr[0].p) && \\valid(tarr[0].q)",48);
}
__e_acsl_temporal_memcpy((void *)(larr),(void *)(& l),(size_t)32);
__e_acsl_initialize((void *)(larr),sizeof(larger));
larr[0] = l;
/*@ assert ¬\valid(larr[0].t.p) ∧ \valid(larr[0].t.q); */
{
int __gen_e_acsl_initialized_14;
int __gen_e_acsl_and_20;
int __gen_e_acsl_and_22;
__gen_e_acsl_initialized_14 = __e_acsl_initialized((void *)(& larr[0].t.p),
sizeof(char *));
if (__gen_e_acsl_initialized_14) {
int __gen_e_acsl_valid_14;
__gen_e_acsl_valid_14 = __e_acsl_valid((void *)larr[0].t.p,
sizeof(char),
(void *)larr[0].t.p,
(void *)(& larr[0].t.p));
__gen_e_acsl_and_20 = __gen_e_acsl_valid_14;
}
else __gen_e_acsl_and_20 = 0;
if (! __gen_e_acsl_and_20) {
int __gen_e_acsl_initialized_15;
int __gen_e_acsl_and_21;
__gen_e_acsl_initialized_15 = __e_acsl_initialized((void *)(& larr[0].t.q),
sizeof(char *));
if (__gen_e_acsl_initialized_15) {
int __gen_e_acsl_valid_15;
__gen_e_acsl_valid_15 = __e_acsl_valid((void *)larr[0].t.q,
sizeof(char),
(void *)larr[0].t.q,
(void *)(& larr[0].t.q));
__gen_e_acsl_and_21 = __gen_e_acsl_valid_15;
}
else __gen_e_acsl_and_21 = 0;
__gen_e_acsl_and_22 = __gen_e_acsl_and_21;
}
else __gen_e_acsl_and_22 = 0;
__e_acsl_assert(__gen_e_acsl_and_22,(char *)"Assertion",(char *)"main",
(char *)"!\\valid(larr[0].t.p) && \\valid(larr[0].t.q)",
51);
}
__retres = 0;
__e_acsl_delete_block((void *)(larr));
__e_acsl_delete_block((void *)(& lp));
__e_acsl_delete_block((void *)(& l));
__e_acsl_delete_block((void *)(tarr));
__e_acsl_delete_block((void *)(& t2));
__e_acsl_delete_block((void *)(& t1));
__e_acsl_delete_block((void *)(& a));
__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(void)
{
int __retres;
int n;
__e_acsl_memory_init((int *)0,(char ***)0,(size_t)8);
__e_acsl_store_block((void *)(& n),(size_t)4);
__e_acsl_full_init((void *)(& n));
n = 7;
L: ;
__e_acsl_full_init((void *)(& n));
n = 9;
K: ;
__e_acsl_full_init((void *)(& n));
n = 666;
/*@ assert \let i = 3; \at(n + i ≡ 10,L); */ ;
/*@ assert ∃ ℤ j; 2 ≤ j < 5 ∧ \at(n + j ≡ 11,L); */ ;
/*@
assert \let k = -7;
∃ ℤ u;
9 ≤ u < 21 ∧
(∀ ℤ v; -5 < v ≤ 6 ⇒ \at((u > 0? n + k: u + v) > 0,K));
*/
;
/*@ assert \let i = 3; \at(n + i,L) ≡ 10; */ ;
unsigned int m = (unsigned int)3;
G: ;
m = (unsigned int)(-3);
/*@ assert ∃ ℤ k; -9 < k < 0 ∧ \at(m + k,G) ≡ 0; */ ;
/*@
assert
∃ ℤ u;
9 ≤ u < 21 ∧
(∀ ℤ v; -5 < v ≤ (u < 15? u + 6: 3) ⇒ \at((n + u) + v > 0,K));
*/
;
int t[5] = {9, 12, 12, 12, -4};
__e_acsl_store_block((void *)(t),(size_t)20);
__e_acsl_full_init((void *)(& t));
__gen_e_acsl_f(t);
g();
/*@
assert
∃ ℤ u;
10 ≤ u < 20 ∧
(∃ ℤ v;
-10 < v ≤ -5 + (\let u = -2; u) ∧
(∃ ℤ w;
100 < w ≤ 200 ∧
\at((((n - u) + (\let u = 42; u)) + v) + w > 0,K)));
*/
;
/*@ assert ∃ ℤ j; 2 ≤ j < 10000000000000000 ∧ \at(n + j ≡ 11,L);
*/
;
/*@ assert \let i = n; \at(n + i ≡ 10,L); */ ;
__retres = 0;
__e_acsl_delete_block((void *)(t));
__e_acsl_delete_block((void *)(& n));
__e_acsl_memory_clean();
return __retres;
}
/*@ ensures
*\old(AverageAccel) ≡
(((((*\old(Accel))[4] + (*\old(Accel))[3]) + (*\old(Accel))[2]) +
(*\old(Accel))[1])
+ (*\old(Accel))[0])
/ 5;
*/
void __gen_e_acsl_atp_NORMAL_computeAverageAccel(ArrayInt *Accel,
int *AverageAccel)
{
ArrayInt *__gen_e_acsl_at_6;
ArrayInt *__gen_e_acsl_at_5;
ArrayInt *__gen_e_acsl_at_4;
ArrayInt *__gen_e_acsl_at_3;
ArrayInt *__gen_e_acsl_at_2;
int *__gen_e_acsl_at;
__gen_e_acsl_at_6 = Accel;
__gen_e_acsl_at_5 = Accel;
__gen_e_acsl_at_4 = Accel;
__gen_e_acsl_at_3 = Accel;
__gen_e_acsl_at_2 = Accel;
__gen_e_acsl_at = AverageAccel;
__e_acsl_store_block((void *)(& AverageAccel),(size_t)8);
__e_acsl_store_block((void *)(& Accel),(size_t)8);
atp_NORMAL_computeAverageAccel(Accel,AverageAccel);
{
int __gen_e_acsl_valid_read;
int __gen_e_acsl_valid_read_2;
int __gen_e_acsl_valid_read_3;
int __gen_e_acsl_valid_read_4;
int __gen_e_acsl_valid_read_5;
int __gen_e_acsl_valid_read_6;
__gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(*__gen_e_acsl_at_6),
sizeof(int),
(void *)(*__gen_e_acsl_at_6),
(void *)(*__gen_e_acsl_at_6));
__e_acsl_assert(__gen_e_acsl_valid_read,(char *)"RTE",
(char *)"atp_NORMAL_computeAverageAccel",
(char *)"mem_access: \\valid_read((int *)*__gen_e_acsl_at_6)",
8);
__gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at_5)[1]),
sizeof(int),
(void *)(& (*__gen_e_acsl_at_5)[1]),
(void *)0);
__e_acsl_assert(__gen_e_acsl_valid_read_2,(char *)"RTE",
(char *)"atp_NORMAL_computeAverageAccel",
(char *)"mem_access: \\valid_read(&(*__gen_e_acsl_at_5)[1])",
8);
__gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at_4)[2]),
sizeof(int),
(void *)(& (*__gen_e_acsl_at_4)[2]),
(void *)0);
__e_acsl_assert(__gen_e_acsl_valid_read_3,(char *)"RTE",
(char *)"atp_NORMAL_computeAverageAccel",
(char *)"mem_access: \\valid_read(&(*__gen_e_acsl_at_4)[2])",
8);
__gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at_3)[3]),
sizeof(int),
(void *)(& (*__gen_e_acsl_at_3)[3]),
(void *)0);
__e_acsl_assert(__gen_e_acsl_valid_read_4,(char *)"RTE",
(char *)"atp_NORMAL_computeAverageAccel",
(char *)"mem_access: \\valid_read(&(*__gen_e_acsl_at_3)[3])",
8);
__gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at_2)[4]),
sizeof(int),
(void *)(& (*__gen_e_acsl_at_2)[4]),
(void *)0);
__e_acsl_assert(__gen_e_acsl_valid_read_5,(char *)"RTE",
(char *)"atp_NORMAL_computeAverageAccel",
(char *)"mem_access: \\valid_read(&(*__gen_e_acsl_at_2)[4])",
8);
__gen_e_acsl_valid_read_6 = __e_acsl_valid_read((void *)__gen_e_acsl_at,
sizeof(int),
(void *)__gen_e_acsl_at,
(void *)(& __gen_e_acsl_at));
__e_acsl_assert(__gen_e_acsl_valid_read_6,(char *)"RTE",
(char *)"atp_NORMAL_computeAverageAccel",
(char *)"mem_access: \\valid_read(__gen_e_acsl_at)",8);
__e_acsl_assert(*__gen_e_acsl_at == (int)((((((*__gen_e_acsl_at_2)[4] + (long)(*__gen_e_acsl_at_3)[3]) + (*__gen_e_acsl_at_4)[2]) + (*__gen_e_acsl_at_5)[1]) + (*__gen_e_acsl_at_6)[0]) / 5L),
(char *)"Postcondition",
(char *)"atp_NORMAL_computeAverageAccel",
(char *)"*\\old(AverageAccel) ==\n(((((*\\old(Accel))[4] + (*\\old(Accel))[3]) + (*\\old(Accel))[2]) +\n (*\\old(Accel))[1])\n + (*\\old(Accel))[0])\n/ 5",
8);
__e_acsl_delete_block((void *)(& AverageAccel));
__e_acsl_delete_block((void *)(& Accel));
return;
}
}
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;
}
/* compiler builtin:
void *__builtin_alloca(unsigned long); */
void test_specifier_application(char const *allowed, char const *fmt,
int only_negative, char *at)
{
size_t tmp;
unsigned long __lengthof_format;
__e_acsl_store_block((void *)(& __lengthof_format),(size_t)8);
__e_acsl_store_block((void *)(& tmp),(size_t)8);
__e_acsl_store_block((void *)(& at),(size_t)8);
__e_acsl_store_block((void *)(& only_negative),(size_t)4);
__e_acsl_store_block((void *)(& fmt),(size_t)8);
__e_acsl_store_block((void *)(& allowed),(size_t)8);
__e_acsl_full_init((void *)(& tmp));
tmp = __gen_e_acsl_strlen(fmt);
int len = (int)tmp;
__e_acsl_store_block((void *)(& len),(size_t)4);
__e_acsl_full_init((void *)(& len));
/*@ assert
alloca_bounds: 0 < sizeof(char) * (len + 1) ≤ 18446744073709551615;
*/
{
int __gen_e_acsl_and;
if (0L < 1L * (len + 1L)) {
__e_acsl_mpz_t __gen_e_acsl_;
__e_acsl_mpz_t __gen_e_acsl__2;
int __gen_e_acsl_le;
__gmpz_init_set_si(__gen_e_acsl_,1L * (len + 1L));
__gmpz_init_set_ui(__gen_e_acsl__2,18446744073709551615UL);
__gen_e_acsl_le = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_),
(__e_acsl_mpz_struct const *)(__gen_e_acsl__2));
__gen_e_acsl_and = __gen_e_acsl_le <= 0;
__gmpz_clear(__gen_e_acsl_);
__gmpz_clear(__gen_e_acsl__2);
}
else __gen_e_acsl_and = 0;
__e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion",
(char *)"test_specifier_application",
(char *)"alloca_bounds: 0 < sizeof(char) * (len + 1) <= 18446744073709551615",
82);
}
__e_acsl_full_init((void *)(& __lengthof_format));
__lengthof_format = (unsigned long)(len + 1);
char *format = __builtin_alloca(sizeof(char) * __lengthof_format);
__e_acsl_store_block((void *)format,sizeof(char) * __lengthof_format);
__e_acsl_store_block((void *)(& format),(size_t)8);
__e_acsl_full_init((void *)(& format));
__gen_e_acsl_strcpy(format,fmt);
{
int i_0 = 0;
__e_acsl_store_block((void *)(& i_0),(size_t)4);
__e_acsl_full_init((void *)(& i_0));
while (1) {
size_t tmp_3;
__e_acsl_store_block((void *)(& tmp_3),(size_t)8);
__e_acsl_full_init((void *)(& tmp_3));
tmp_3 = __gen_e_acsl_strlen(valid_specifiers);
;
if (! ((size_t)i_0 < tmp_3)) {
__e_acsl_delete_block((void *)(& tmp_3));
break;
}
{
char *tmp_2;
__e_acsl_store_block((void *)(& tmp_2),(size_t)8);
int c = (int)*(valid_specifiers + i_0);
__e_acsl_store_block((void *)(& c),(size_t)4);
__e_acsl_full_init((void *)(& c));
__e_acsl_initialize((void *)(format + (len - 1)),sizeof(char));
*(format + (len - 1)) = (char)c;
__e_acsl_full_init((void *)(& tmp_2));
tmp_2 = __gen_e_acsl_strchr(allowed,c);
if (tmp_2) {
if (! only_negative) {
{
pid_t pid = fork();
__e_acsl_store_block((void *)(& pid),(size_t)4);
__e_acsl_full_init((void *)(& pid));
if (! pid) {
apply_specifier(format,c);
__gen_e_acsl_exit(0);
}
else {
int process_status;
__e_acsl_store_block((void *)(& process_status),(size_t)4);
waitpid(pid,& process_status,0);
signal_eval(process_status,0,(char const *)at);
__e_acsl_delete_block((void *)(& process_status));
}
__e_acsl_delete_block((void *)(& pid));
}
}
}
else {
{
pid_t pid_0 = fork();
__e_acsl_store_block((void *)(& pid_0),(size_t)4);
__e_acsl_full_init((void *)(& pid_0));
if (! pid_0) {
apply_specifier(format,c);
__gen_e_acsl_exit(0);
}
else {
int process_status_0;
__e_acsl_store_block((void *)(& process_status_0),(size_t)4);
waitpid(pid_0,& process_status_0,0);
signal_eval(process_status_0,1,(char const *)at);
__e_acsl_delete_block((void *)(& process_status_0));
}
__e_acsl_delete_block((void *)(& pid_0));
}
}
__e_acsl_delete_block((void *)(& tmp_2));
__e_acsl_delete_block((void *)(& c));
}
__e_acsl_full_init((void *)(& i_0));
i_0 ++;
__e_acsl_delete_block((void *)(& tmp_3));
}
__e_acsl_delete_block((void *)(& i_0));
}
__e_acsl_delete_block((void *)format);
__e_acsl_delete_block((void *)(& at));
__e_acsl_delete_block((void *)(& only_negative));
__e_acsl_delete_block((void *)(& fmt));
__e_acsl_delete_block((void *)(& allowed));
__e_acsl_delete_block((void *)(& __lengthof_format));
__e_acsl_delete_block((void *)(& format));
__e_acsl_delete_block((void *)(& tmp));
__e_acsl_delete_block((void *)(& len));
return;
}
int switch_valid(void)
{
int __retres;
int *p;
int *q;
int *s;
__e_acsl_store_block((void *)(& s),(size_t)8);
__e_acsl_store_block((void *)(& q),(size_t)8);
__e_acsl_store_block((void *)(& p),(size_t)8);
int i = 1;
__e_acsl_store_block((void *)(& i),(size_t)4);
__e_acsl_full_init((void *)(& i));
__e_acsl_full_init((void *)(& s));
s = & i;
switch (i) {
default:
{
int a1 = 0;
__e_acsl_store_block((void *)(& a1),(size_t)4);
__e_acsl_full_init((void *)(& a1));
__e_acsl_full_init((void *)(& p));
p = & a1;
{
int a2 = 0;
__e_acsl_store_block((void *)(& a2),(size_t)4);
__e_acsl_full_init((void *)(& a2));
__e_acsl_full_init((void *)(& q));
q = & a2;
/*@ 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 *)"switch_valid",(char *)"\\valid(p)",76);
}
/*@ assert \valid(q); */
{
int __gen_e_acsl_initialized_2;
int __gen_e_acsl_and_2;
__gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& q),
sizeof(int *));
if (__gen_e_acsl_initialized_2) {
int __gen_e_acsl_valid_2;
__gen_e_acsl_valid_2 = __e_acsl_valid((void *)q,sizeof(int),
(void *)q,(void *)(& q));
__gen_e_acsl_and_2 = __gen_e_acsl_valid_2;
}
else __gen_e_acsl_and_2 = 0;
__e_acsl_assert(__gen_e_acsl_and_2,(char *)"Assertion",
(char *)"switch_valid",(char *)"\\valid(q)",77);
}
/*@ assert \valid(s); */
{
int __gen_e_acsl_initialized_3;
int __gen_e_acsl_and_3;
__gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& s),
sizeof(int *));
if (__gen_e_acsl_initialized_3) {
int __gen_e_acsl_valid_3;
__gen_e_acsl_valid_3 = __e_acsl_valid((void *)s,sizeof(int),
(void *)s,(void *)(& s));
__gen_e_acsl_and_3 = __gen_e_acsl_valid_3;
}
else __gen_e_acsl_and_3 = 0;
__e_acsl_assert(__gen_e_acsl_and_3,(char *)"Assertion",
(char *)"switch_valid",(char *)"\\valid(s)",78);
}
__e_acsl_delete_block((void *)(& a1));
__e_acsl_delete_block((void *)(& a2));
break;
__e_acsl_delete_block((void *)(& a2));
}
__e_acsl_full_init((void *)(& q));
q = & i;
__e_acsl_full_init((void *)(& p));
p = q;
__e_acsl_full_init((void *)(& s));
s = (int *)0;
__e_acsl_delete_block((void *)(& a1));
}
}
/*@ assert ¬\valid(q); */
{
int __gen_e_acsl_initialized_4;
int __gen_e_acsl_and_4;
__gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& q),
sizeof(int *));
if (__gen_e_acsl_initialized_4) {
int __gen_e_acsl_valid_4;
__gen_e_acsl_valid_4 = __e_acsl_valid((void *)q,sizeof(int),(void *)q,
(void *)(& q));
__gen_e_acsl_and_4 = __gen_e_acsl_valid_4;
}
else __gen_e_acsl_and_4 = 0;
__e_acsl_assert(! __gen_e_acsl_and_4,(char *)"Assertion",
(char *)"switch_valid",(char *)"!\\valid(q)",87);
}
/*@ assert ¬\valid(p); */
{
int __gen_e_acsl_initialized_5;
int __gen_e_acsl_and_5;
__gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)(& p),
sizeof(int *));
if (__gen_e_acsl_initialized_5) {
int __gen_e_acsl_valid_5;
__gen_e_acsl_valid_5 = __e_acsl_valid((void *)p,sizeof(int),(void *)p,
(void *)(& p));
__gen_e_acsl_and_5 = __gen_e_acsl_valid_5;
}
else __gen_e_acsl_and_5 = 0;
__e_acsl_assert(! __gen_e_acsl_and_5,(char *)"Assertion",
(char *)"switch_valid",(char *)"!\\valid(p)",88);
}
/*@ assert \valid(s); */
{
int __gen_e_acsl_initialized_6;
int __gen_e_acsl_and_6;
__gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(& s),
sizeof(int *));
if (__gen_e_acsl_initialized_6) {
int __gen_e_acsl_valid_6;
__gen_e_acsl_valid_6 = __e_acsl_valid((void *)s,sizeof(int),(void *)s,
(void *)(& s));
__gen_e_acsl_and_6 = __gen_e_acsl_valid_6;
}
else __gen_e_acsl_and_6 = 0;
__e_acsl_assert(__gen_e_acsl_and_6,(char *)"Assertion",
(char *)"switch_valid",(char *)"\\valid(s)",89);
}
__retres = 0;
__e_acsl_delete_block((void *)(& s));
__e_acsl_delete_block((void *)(& q));
__e_acsl_delete_block((void *)(& p));
__e_acsl_delete_block((void *)(& i));
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(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 __gen_e_acsl_main(int argc, char **argv)
{
int __retres;
int i;
/*@ assert ∀ int k; 0 ≤ k < argc ⇒ \valid(argv + k); */
{
int __gen_e_acsl_forall;
int __gen_e_acsl_k;
__e_acsl_store_block((void *)(& argv),(size_t)8);
__gen_e_acsl_forall = 1;
__gen_e_acsl_k = 0;
while (1) {
if (__gen_e_acsl_k < argc) ; else break;
{
int __gen_e_acsl_valid;
__gen_e_acsl_valid = __e_acsl_valid((void *)(argv + __gen_e_acsl_k),
sizeof(char *),(void *)argv,
(void *)(& argv));
if (__gen_e_acsl_valid) ;
else {
__gen_e_acsl_forall = 0;
goto e_acsl_end_loop1;
}
}
__gen_e_acsl_k ++;
}
e_acsl_end_loop1: ;
__e_acsl_assert(__gen_e_acsl_forall,(char *)"Assertion",(char *)"main",
(char *)"\\forall int k; 0 <= k < argc ==> \\valid(argv + k)",
12);
}
/*@ assert \block_length(argv) ≡ (argc + 1) * sizeof(char *); */
{
unsigned long __gen_e_acsl_block_length;
__e_acsl_mpz_t __gen_e_acsl_block_length_2;
__e_acsl_mpz_t __gen_e_acsl_;
int __gen_e_acsl_eq;
__gen_e_acsl_block_length = __e_acsl_block_length((void *)argv);
__gmpz_init_set_ui(__gen_e_acsl_block_length_2,__gen_e_acsl_block_length);
__gmpz_init_set_si(__gen_e_acsl_,(argc + 1L) * 8);
__gen_e_acsl_eq = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_block_length_2),
(__e_acsl_mpz_struct const *)(__gen_e_acsl_));
__e_acsl_assert(__gen_e_acsl_eq == 0,(char *)"Assertion",(char *)"main",
(char *)"\\block_length(argv) == (argc + 1) * sizeof(char *)",
13);
__gmpz_clear(__gen_e_acsl_block_length_2);
__gmpz_clear(__gen_e_acsl_);
}
/*@ assert *(argv + argc) ≡ \null; */
{
int __gen_e_acsl_valid_read;
__gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(argv + argc),
sizeof(char *),
(void *)argv,
(void *)(& argv));
__e_acsl_assert(__gen_e_acsl_valid_read,(char *)"RTE",(char *)"main",
(char *)"mem_access: \\valid_read(argv + argc)",15);
/*@ assert Eva: mem_access: \valid_read(argv + argc); */
__e_acsl_assert(*(argv + argc) == (char *)0,(char *)"Assertion",
(char *)"main",(char *)"*(argv + argc) == \\null",15);
}
/*@ assert ¬\valid(*(argv + argc)); */
{
int __gen_e_acsl_initialized;
int __gen_e_acsl_and;
__gen_e_acsl_initialized = __e_acsl_initialized((void *)(argv + argc),
sizeof(char *));
if (__gen_e_acsl_initialized) {
int __gen_e_acsl_valid_read_2;
int __gen_e_acsl_valid_2;
__gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(argv + argc),
sizeof(char *),
(void *)argv,
(void *)(& argv));
__e_acsl_assert(__gen_e_acsl_valid_read_2,(char *)"RTE",(char *)"main",
(char *)"mem_access: \\valid_read(argv + argc)",16);
/*@ assert Eva: mem_access: \valid_read(argv + argc); */
__gen_e_acsl_valid_2 = __e_acsl_valid((void *)*(argv + argc),
sizeof(char),
(void *)*(argv + argc),
(void *)(argv + argc));
__gen_e_acsl_and = __gen_e_acsl_valid_2;
}
else __gen_e_acsl_and = 0;
__e_acsl_assert(! __gen_e_acsl_and,(char *)"Assertion",(char *)"main",
(char *)"!\\valid(*(argv + argc))",16);
}
i = 0;
while (i < argc) {
{
size_t tmp;
tmp = __gen_e_acsl_strlen((char const *)*(argv + i));
int len = (int)tmp;
/*@ assert \valid(*(argv + i)); */
{
int __gen_e_acsl_initialized_2;
int __gen_e_acsl_and_2;
__gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(argv + i),
sizeof(char *));
if (__gen_e_acsl_initialized_2) {
int __gen_e_acsl_valid_read_3;
int __gen_e_acsl_valid_3;
__gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(argv + i),
sizeof(char *),
(void *)argv,
(void *)(& argv));
__e_acsl_assert(__gen_e_acsl_valid_read_3,(char *)"RTE",
(char *)"main",
(char *)"mem_access: \\valid_read(argv + i)",19);
__gen_e_acsl_valid_3 = __e_acsl_valid((void *)*(argv + i),
sizeof(char),
(void *)*(argv + i),
(void *)(argv + i));
__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(*(argv + i))",19);
}
/*@ assert ∀ int k; 0 ≤ k ≤ len ⇒ \valid(*(argv + i) + k); */
{
int __gen_e_acsl_forall_2;
long __gen_e_acsl_k_2;
__gen_e_acsl_forall_2 = 1;
__gen_e_acsl_k_2 = 0;
while (1) {
if (__gen_e_acsl_k_2 <= (long)len) ; else break;
{
int __gen_e_acsl_valid_read_4;
int __gen_e_acsl_valid_4;
__gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(
argv + i),
sizeof(char *),
(void *)argv,
(void *)(& argv));
__e_acsl_assert(__gen_e_acsl_valid_read_4,(char *)"RTE",
(char *)"main",
(char *)"mem_access: \\valid_read(argv + i)",20);
__gen_e_acsl_valid_4 = __e_acsl_valid((void *)(*(argv + i) + __gen_e_acsl_k_2),
sizeof(char),
(void *)*(argv + i),
(void *)(argv + i));
if (__gen_e_acsl_valid_4) ;
else {
__gen_e_acsl_forall_2 = 0;
goto e_acsl_end_loop2;
}
}
__gen_e_acsl_k_2 ++;
}
e_acsl_end_loop2: ;
__e_acsl_assert(__gen_e_acsl_forall_2,(char *)"Assertion",
(char *)"main",
(char *)"\\forall int k; 0 <= k <= len ==> \\valid(*(argv + i) + k)",
20);
}
}
i ++;
}
__retres = 0;
__e_acsl_delete_block((void *)(& argv));
return __retres;
}
int goto_valid(void)
{
int __retres;
int *p;
int *q;
int *r;
__e_acsl_store_block((void *)(& r),(size_t)8);
__e_acsl_store_block((void *)(& q),(size_t)8);
__e_acsl_store_block((void *)(& p),(size_t)8);
int a = 9;
{
int a1 = 0;
__e_acsl_store_block((void *)(& a1),(size_t)4);
__e_acsl_full_init((void *)(& a1));
__e_acsl_full_init((void *)(& p));
p = & a1;
{
int a2 = 0;
__e_acsl_store_block((void *)(& a2),(size_t)4);
__e_acsl_full_init((void *)(& a2));
__e_acsl_full_init((void *)(& q));
q = & a2;
{
int a3 = 0;
__e_acsl_store_block((void *)(& a3),(size_t)4);
__e_acsl_full_init((void *)(& a3));
__e_acsl_full_init((void *)(& r));
r = & a3;
__e_acsl_delete_block((void *)(& a2));
__e_acsl_delete_block((void *)(& a3));
goto FIRST;
__e_acsl_full_init((void *)(& p));
p = (int *)0;
__e_acsl_full_init((void *)(& q));
q = & a;
__e_acsl_full_init((void *)(& r));
r = q;
__e_acsl_delete_block((void *)(& a3));
__e_acsl_delete_block((void *)(& a2));
}
}
FIRST:
/*@ 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 *)"goto_valid",(char *)"\\valid(p)",46);
}
/*@ assert ¬\valid(q); */
{
int __gen_e_acsl_initialized_2;
int __gen_e_acsl_and_2;
__gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& q),
sizeof(int *));
if (__gen_e_acsl_initialized_2) {
int __gen_e_acsl_valid_2;
__gen_e_acsl_valid_2 = __e_acsl_valid((void *)q,sizeof(int),
(void *)q,(void *)(& q));
__gen_e_acsl_and_2 = __gen_e_acsl_valid_2;
}
else __gen_e_acsl_and_2 = 0;
__e_acsl_assert(! __gen_e_acsl_and_2,(char *)"Assertion",
(char *)"goto_valid",(char *)"!\\valid(q)",47);
}
/*@ assert ¬\valid(r); */
{
int __gen_e_acsl_initialized_3;
int __gen_e_acsl_and_3;
__gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& r),
sizeof(int *));
if (__gen_e_acsl_initialized_3) {
int __gen_e_acsl_valid_3;
__gen_e_acsl_valid_3 = __e_acsl_valid((void *)r,sizeof(int),
(void *)r,(void *)(& r));
__gen_e_acsl_and_3 = __gen_e_acsl_valid_3;
}
else __gen_e_acsl_and_3 = 0;
__e_acsl_assert(! __gen_e_acsl_and_3,(char *)"Assertion",
(char *)"goto_valid",(char *)"!\\valid(r)",48);
}
__e_acsl_delete_block((void *)(& a1));
goto SECOND;
__e_acsl_full_init((void *)(& q));
q = & a;
__e_acsl_full_init((void *)(& r));
r = q;
__e_acsl_full_init((void *)(& p));
p = r;
__e_acsl_delete_block((void *)(& a1));
}
SECOND:
/*@ assert ¬\valid(p); */
{
int __gen_e_acsl_initialized_4;
int __gen_e_acsl_and_4;
__gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& p),
sizeof(int *));
if (__gen_e_acsl_initialized_4) {
int __gen_e_acsl_valid_4;
__gen_e_acsl_valid_4 = __e_acsl_valid((void *)p,sizeof(int),(void *)p,
(void *)(& p));
__gen_e_acsl_and_4 = __gen_e_acsl_valid_4;
}
else __gen_e_acsl_and_4 = 0;
__e_acsl_assert(! __gen_e_acsl_and_4,(char *)"Assertion",
(char *)"goto_valid",(char *)"!\\valid(p)",56);
}
/*@ assert ¬\valid(q); */
{
int __gen_e_acsl_initialized_5;
int __gen_e_acsl_and_5;
__gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)(& q),
sizeof(int *));
if (__gen_e_acsl_initialized_5) {
int __gen_e_acsl_valid_5;
__gen_e_acsl_valid_5 = __e_acsl_valid((void *)q,sizeof(int),(void *)q,
(void *)(& q));
__gen_e_acsl_and_5 = __gen_e_acsl_valid_5;
}
else __gen_e_acsl_and_5 = 0;
__e_acsl_assert(! __gen_e_acsl_and_5,(char *)"Assertion",
(char *)"goto_valid",(char *)"!\\valid(q)",57);
}
/*@ assert ¬\valid(r); */
{
int __gen_e_acsl_initialized_6;
int __gen_e_acsl_and_6;
__gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(& r),
sizeof(int *));
if (__gen_e_acsl_initialized_6) {
int __gen_e_acsl_valid_6;
__gen_e_acsl_valid_6 = __e_acsl_valid((void *)r,sizeof(int),(void *)r,
(void *)(& r));
__gen_e_acsl_and_6 = __gen_e_acsl_valid_6;
}
else __gen_e_acsl_and_6 = 0;
__e_acsl_assert(! __gen_e_acsl_and_6,(char *)"Assertion",
(char *)"goto_valid",(char *)"!\\valid(r)",58);
}
__retres = 0;
__e_acsl_delete_block((void *)(& r));
__e_acsl_delete_block((void *)(& q));
__e_acsl_delete_block((void *)(& p));
return __retres;
}
void continue_valid(void)
{
int *p;
int *q;
__e_acsl_store_block((void *)(& q),(size_t)8);
__e_acsl_store_block((void *)(& p),(size_t)8);
int i = 0;
while (1) {
int tmp;
tmp = i;
i ++;
;
if (! tmp) break;
{
/*@ 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 *)"continue_valid",(char *)"!\\valid(p)",130);
}
/*@ assert ¬\valid(q); */
{
int __gen_e_acsl_initialized_2;
int __gen_e_acsl_and_2;
__gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& q),
sizeof(int *));
if (__gen_e_acsl_initialized_2) {
int __gen_e_acsl_valid_2;
__gen_e_acsl_valid_2 = __e_acsl_valid((void *)q,sizeof(int),
(void *)q,(void *)(& q));
__gen_e_acsl_and_2 = __gen_e_acsl_valid_2;
}
else __gen_e_acsl_and_2 = 0;
__e_acsl_assert(! __gen_e_acsl_and_2,(char *)"Assertion",
(char *)"continue_valid",(char *)"!\\valid(q)",131);
}
int a1 = 1;
__e_acsl_store_block((void *)(& a1),(size_t)4);
__e_acsl_full_init((void *)(& a1));
__e_acsl_full_init((void *)(& p));
p = & a1;
/*@ assert \valid(p); */
{
int __gen_e_acsl_initialized_3;
int __gen_e_acsl_and_3;
__gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& p),
sizeof(int *));
if (__gen_e_acsl_initialized_3) {
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_3 = __gen_e_acsl_valid_3;
}
else __gen_e_acsl_and_3 = 0;
__e_acsl_assert(__gen_e_acsl_and_3,(char *)"Assertion",
(char *)"continue_valid",(char *)"\\valid(p)",135);
}
/*@ assert ¬\valid(q); */
{
int __gen_e_acsl_initialized_4;
int __gen_e_acsl_and_4;
__gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& q),
sizeof(int *));
if (__gen_e_acsl_initialized_4) {
int __gen_e_acsl_valid_4;
__gen_e_acsl_valid_4 = __e_acsl_valid((void *)q,sizeof(int),
(void *)q,(void *)(& q));
__gen_e_acsl_and_4 = __gen_e_acsl_valid_4;
}
else __gen_e_acsl_and_4 = 0;
__e_acsl_assert(! __gen_e_acsl_and_4,(char *)"Assertion",
(char *)"continue_valid",(char *)"!\\valid(q)",136);
}
{
int a2 = 1;
__e_acsl_store_block((void *)(& a2),(size_t)4);
__e_acsl_full_init((void *)(& a2));
__e_acsl_full_init((void *)(& q));
q = & a2;
/*@ assert \valid(p); */
{
int __gen_e_acsl_initialized_5;
int __gen_e_acsl_and_5;
__gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)(& p),
sizeof(int *));
if (__gen_e_acsl_initialized_5) {
int __gen_e_acsl_valid_5;
__gen_e_acsl_valid_5 = __e_acsl_valid((void *)p,sizeof(int),
(void *)p,(void *)(& p));
__gen_e_acsl_and_5 = __gen_e_acsl_valid_5;
}
else __gen_e_acsl_and_5 = 0;
__e_acsl_assert(__gen_e_acsl_and_5,(char *)"Assertion",
(char *)"continue_valid",(char *)"\\valid(p)",141);
}
/*@ assert \valid(q); */
{
int __gen_e_acsl_initialized_6;
int __gen_e_acsl_and_6;
__gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(& q),
sizeof(int *));
if (__gen_e_acsl_initialized_6) {
int __gen_e_acsl_valid_6;
__gen_e_acsl_valid_6 = __e_acsl_valid((void *)q,sizeof(int),
(void *)q,(void *)(& q));
__gen_e_acsl_and_6 = __gen_e_acsl_valid_6;
}
else __gen_e_acsl_and_6 = 0;
__e_acsl_assert(__gen_e_acsl_and_6,(char *)"Assertion",
(char *)"continue_valid",(char *)"\\valid(q)",142);
}
__e_acsl_delete_block((void *)(& a1));
__e_acsl_delete_block((void *)(& a2));
continue;
__e_acsl_delete_block((void *)(& a2));
}
if (i == 5) {
__e_acsl_delete_block((void *)(& a1));
break;
}
__e_acsl_delete_block((void *)(& a1));
}
}
/*@ assert ¬\valid(p); */
{
int __gen_e_acsl_initialized_7;
int __gen_e_acsl_and_7;
__gen_e_acsl_initialized_7 = __e_acsl_initialized((void *)(& p),
sizeof(int *));
if (__gen_e_acsl_initialized_7) {
int __gen_e_acsl_valid_7;
__gen_e_acsl_valid_7 = __e_acsl_valid((void *)p,sizeof(int),(void *)p,
(void *)(& p));
__gen_e_acsl_and_7 = __gen_e_acsl_valid_7;
}
else __gen_e_acsl_and_7 = 0;
__e_acsl_assert(! __gen_e_acsl_and_7,(char *)"Assertion",
(char *)"continue_valid",(char *)"!\\valid(p)",150);
}
/*@ assert ¬\valid(q); */
{
int __gen_e_acsl_initialized_8;
int __gen_e_acsl_and_8;
__gen_e_acsl_initialized_8 = __e_acsl_initialized((void *)(& q),
sizeof(int *));
if (__gen_e_acsl_initialized_8) {
int __gen_e_acsl_valid_8;
__gen_e_acsl_valid_8 = __e_acsl_valid((void *)q,sizeof(int),(void *)q,
(void *)(& q));
__gen_e_acsl_and_8 = __gen_e_acsl_valid_8;
}
else __gen_e_acsl_and_8 = 0;
__e_acsl_assert(! __gen_e_acsl_and_8,(char *)"Assertion",
(char *)"continue_valid",(char *)"!\\valid(q)",151);
}
__e_acsl_delete_block((void *)(& q));
__e_acsl_delete_block((void *)(& p));
return;
}
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 while_valid(void)
{
int __retres;
int *p;
int *q;
int *r;
__e_acsl_store_block((void *)(& r),(size_t)8);
__e_acsl_store_block((void *)(& q),(size_t)8);
__e_acsl_store_block((void *)(& p),(size_t)8);
int i = 5;
{
int a0 = 0;
__e_acsl_store_block((void *)(& a0),(size_t)4);
__e_acsl_full_init((void *)(& a0));
__e_acsl_full_init((void *)(& r));
r = & a0;
while (1) {
i --;
if (! i) break;
{
int a1 = 0;
__e_acsl_store_block((void *)(& a1),(size_t)4);
__e_acsl_full_init((void *)(& a1));
__e_acsl_full_init((void *)(& p));
p = & a1;
{
int a2 = 0;
__e_acsl_store_block((void *)(& a2),(size_t)4);
__e_acsl_full_init((void *)(& a2));
__e_acsl_full_init((void *)(& q));
q = & a2;
/*@ 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 *)"while_valid",(char *)"\\valid(p)",108);
}
/*@ assert \valid(q); */
{
int __gen_e_acsl_initialized_2;
int __gen_e_acsl_and_2;
__gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& q),
sizeof(int *));
if (__gen_e_acsl_initialized_2) {
int __gen_e_acsl_valid_2;
__gen_e_acsl_valid_2 = __e_acsl_valid((void *)q,sizeof(int),
(void *)q,(void *)(& q));
__gen_e_acsl_and_2 = __gen_e_acsl_valid_2;
}
else __gen_e_acsl_and_2 = 0;
__e_acsl_assert(__gen_e_acsl_and_2,(char *)"Assertion",
(char *)"while_valid",(char *)"\\valid(q)",109);
}
/*@ assert \valid(r); */
{
int __gen_e_acsl_initialized_3;
int __gen_e_acsl_and_3;
__gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& r),
sizeof(int *));
if (__gen_e_acsl_initialized_3) {
int __gen_e_acsl_valid_3;
__gen_e_acsl_valid_3 = __e_acsl_valid((void *)r,sizeof(int),
(void *)r,(void *)(& r));
__gen_e_acsl_and_3 = __gen_e_acsl_valid_3;
}
else __gen_e_acsl_and_3 = 0;
__e_acsl_assert(__gen_e_acsl_and_3,(char *)"Assertion",
(char *)"while_valid",(char *)"\\valid(r)",110);
}
if (! i) {
__e_acsl_delete_block((void *)(& a1));
__e_acsl_delete_block((void *)(& a2));
break;
}
__e_acsl_delete_block((void *)(& a2));
__e_acsl_delete_block((void *)(& a1));
}
}
}
/*@ assert ¬\valid(p); */
{
int __gen_e_acsl_initialized_4;
int __gen_e_acsl_and_4;
__gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& p),
sizeof(int *));
if (__gen_e_acsl_initialized_4) {
int __gen_e_acsl_valid_4;
__gen_e_acsl_valid_4 = __e_acsl_valid((void *)p,sizeof(int),
(void *)p,(void *)(& p));
__gen_e_acsl_and_4 = __gen_e_acsl_valid_4;
}
else __gen_e_acsl_and_4 = 0;
__e_acsl_assert(! __gen_e_acsl_and_4,(char *)"Assertion",
(char *)"while_valid",(char *)"!\\valid(p)",116);
}
/*@ assert ¬\valid(q); */
{
int __gen_e_acsl_initialized_5;
int __gen_e_acsl_and_5;
__gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)(& q),
sizeof(int *));
if (__gen_e_acsl_initialized_5) {
int __gen_e_acsl_valid_5;
__gen_e_acsl_valid_5 = __e_acsl_valid((void *)q,sizeof(int),
(void *)q,(void *)(& q));
__gen_e_acsl_and_5 = __gen_e_acsl_valid_5;
}
else __gen_e_acsl_and_5 = 0;
__e_acsl_assert(! __gen_e_acsl_and_5,(char *)"Assertion",
(char *)"while_valid",(char *)"!\\valid(q)",117);
}
/*@ assert \valid(r); */
{
int __gen_e_acsl_initialized_6;
int __gen_e_acsl_and_6;
__gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(& r),
sizeof(int *));
if (__gen_e_acsl_initialized_6) {
int __gen_e_acsl_valid_6;
__gen_e_acsl_valid_6 = __e_acsl_valid((void *)r,sizeof(int),
(void *)r,(void *)(& r));
__gen_e_acsl_and_6 = __gen_e_acsl_valid_6;
}
else __gen_e_acsl_and_6 = 0;
__e_acsl_assert(__gen_e_acsl_and_6,(char *)"Assertion",
(char *)"while_valid",(char *)"\\valid(r)",118);
__e_acsl_delete_block((void *)(& a0));
}
}
__retres = 0;
__e_acsl_delete_block((void *)(& r));
__e_acsl_delete_block((void *)(& q));
__e_acsl_delete_block((void *)(& p));
return __retres;
}
