file_content
stringlengths 65
76k
| goals
int64 1
283
|
|---|---|
/*@ assigns \nothing;
ensures \result == \min(\max(min, v), max);
*/
int clamp(int v, int min, int max)
{
int low = v > min ? v : min;
return low < max ? low : max;
}
| 7 |
/*@ requires n > 0;
assigns \nothing;
ensures 0 <= \result && \result < n;
*/
int pick_index(int n) { return 0; }
/*@ requires n > 0 && \valid(p+ (0..n-1));
assigns \nothing;
*/
int pick_element(int* p, int n) {
int i = pick_index(n);
//@ assert (0 <= i && i < n);
return p[i];
}
/*@
requires \valid(p);
assigns \nothing;
ensures \result == p[0];
*/
int pick_first(int* p) {
return p[0];
}
| 18 |
/*@ requires n>0 && \valid(s+(0..n-1)) && \valid(t+(0..n-1));
assigns s[0..n-1];
ensures \forall integer i; 0<=i<n ==> s[i]==t[i];
*/
void copy1(int s[], int t[], int n) {
/*@ loop invariant 0<=i<=n;
loop invariant \forall integer j; 0<=j<i ==> s[j]==t[j];
loop variant n-i;
*/
for(int i=0;i<n;i++){
s[i]=t[i];
}
}
| 18 |
#include <limits.h>
#include <string.h>
/*@ predicate matcher_ab(char * x0) = ((((x0[0]=='\0')) ? (\false) : (((x0[0]=='a') &&
\false))) || (((x0[0]=='\0')) ? (\false) : (((x0[0]=='a') &&
((((x0+1)[0]=='\0')) ? (\false) : ((((x0+1)[0]=='b') &&
(((x0+1)+1)[0]=='\0'))))))));*/
/*@
requires ((strlen(x0)>=0) &&
\valid(x0+(0..(strlen(x0)+1)-1)));
assigns \nothing;
ensures \result <==> matcher_ab(x0);
*/
int matcher_ab(char * x0) {
char x2 = x0[0];
int x3 = x2 == '\0';
int x7;
if (x3) {
x7 = 0/*false*/;
} else {
int x4 = x2 == 'a';
int x6;
if (x4) {
x6 = 0/*false*/;
} else {
x6 = 0/*false*/;
}
x7 = x6;
}
int x17;
if (x3) {
x17 = 0/*false*/;
} else {
int x4 = x2 == 'a';
int x16;
if (x4) {
char *x5 = x0+1;
char x8 = x5[0];
int x9 = x8 == '\0';
int x15;
if (x9) {
x15 = 0/*false*/;
} else {
int x10 = x8 == 'b';
int x14;
if (x10) {
char *x11 = x5+1;
char x12 = x11[0];
int x13 = x12 == '\0';
x14 = x13;
} else {
x14 = 0/*false*/;
}
x15 = x14;
}
x16 = x15;
} else {
x16 = 0/*false*/;
}
x17 = x16;
}
int x18 = x7 || x17;
return x18;
}
| 21 |
/*@
requires n>0;
requires 0<=k<n;
requires\valid(a+ (0..n-1));
ensures\forall integer i;
0<= i<=k ==>a[k]>=a[i];
*/
void q2(int a[],int n,int k)
{
/*@
loop invariant\forall integer i;
0<= i<j ==> a[j]>=a[i];loop invariant 0<=j<=k;
loop assigns j,a[0..j+1];
loop variant k-j;
*/
for (int j=0;j<k;j++)
{
if(a[j]>a[j+1])
{
int t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}
}
}
| 23 |
/*@
requires n>0;
requires\valid(a+ (0..n-1));
ensures\forall integer i;
0<= i<n-1 ==>a[n-1]>=a[i];
*/
void bubbleinnerloop(int a[], int n)
{
/*@
loop invariant\forall integer i;
0<= i<j ==> a[j]>=a[i];loop invariant 0<=j<=n-1;
loop assigns j,a[0..j+1];
loop variant n-1-j;
*/
for (int j = 0; j < n - 1; j++)
{
if (a[j] > a[j + 1])
{
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
| 24 |
#include <limits.h>
/*@
requires (\valid(x0+x1) &&
\valid(x0+x2));
ensures ((x0[x1]==\old(x0[x2])) &&
(x0[x2]==\old(x0[x1])));
assigns x0[x1], x0[x2];
*/
void inswap(int * x0, int x1, int x2) {
int x4 = x0[x1];
int x5 = x0[x2];
x0[x1] = x5;
x0[x2] = x4;
}
/*@
requires ((x26>0) &&
\valid(x25+(0..x26-1)));
ensures (\forall int x203; (((0<=x203) &&
(x203<(x26-1))) ==> (x25[x203]<=x25[(x203+1)])));
assigns x25[(0..x26-1)];
*/
void insort(int * x25, int x26) {
int x29 = x26;
/*@
loop invariant ((((0<=x29) &&
(x29<=x26)) &&
(\forall int x152; (((x29<=x152) &&
(x152<(x26-1))) ==> (x25[x152]<=x25[(x152+1)])))) &&
(\forall int x168; ((((0<=x168) &&
(x168<x29)) &&
(x29<=(x26-1))) ==> (x25[x168]<=x25[x29]))));
loop assigns x29, x25[(0..x26-1)];
loop variant x29;
*/
for (;;) {
int x30 = x29;
int x31 = x30 > 1;
if (!x31) break;
int x33 = 0;
int x34 = x29;
/*@
loop invariant ((((((((0<=x29) &&
(x29<=x26)) &&
(0<=x36)) &&
(x36<=x29)) &&
(0<=x33)) &&
(x33<=(x29-1))) &&
((x29-1)<x26)) &&
(\forall int x74; (((0<=x74) &&
(x74<x36)) ==> (x25[x74]<=x25[x33]))));
loop assigns x36, x33;
loop variant (x29-x36);
*/
for(int x36=0; x36 < x34; x36++) {
int x37 = x25[x36];
int x38 = x33;
int x39 = x25[x38];
int x40 = x37 >= x39;
if (x40) {
x33 = x36;
} else {
}
}
int x96 = x33;
int x95 = x34 - 1;
inswap(x25,x95,x96);
/*@assert (\forall int x98; ((((x29-1)<x98) &&
(x98<(x26-1))) ==> (x25[x98]<=x25[(x98+1)])));*/
/*@assert ((x29<=(x26-1)) ==> (x25[(x29-1)]<=x25[x29]));*/
/*@assert (\forall int x127; (((0<=x127) &&
(x127<x29)) ==> (x25[x127]<=x25[(x29-1)])));*/
x29 = x95;
}
}
| 37 |
#include<stdio.h>
enum type1 {scalene,isoscele,equilateral};
enum type2 {right,acute,obtuse};
/*@
requires a>=b &&a>=c;
behavior eq:
assumes a==b &&b==c;
ensures \result==equilateral;
behavior is:
assumes a==b && b!=c|| b==c && c!=a|| c==a && a!=b;
ensures \result==isoscele;
behavior sc:
assumes a!=b && b!=c && c!=a;
ensures \result==scalene;
complete behaviors;
disjoint behaviors;
*/
enum type1 func1(int a,int b,int c){
if(a==b && b==c) return equilateral;
else if(a==b || b==c || c==a) return isoscele;
else return scalene;
}
/*@
requires a>=b>0 && a>=c>0 && a*a<=10000000 && c*c<=10000000 && b*b<=10000000;
behavior ri:
assumes a*a==b*b+c*c;
ensures \result==right;
behavior ac:
assumes a*a<b*b+c*c;
ensures \result==acute;
behavior ob:
assumes a*a>b*b+c*c;
ensures \result==obtuse;
complete behaviors;
disjoint behaviors;
*/
enum type2 func2(int a,int b,int c){
//since a is assumed as hypotenuse
if(a*a==b*b+c*c) return right;
else if (a*a<b*b+c*c) return acute;
else return obtuse;
}
| 30 |
#define LENGTH 100
int vec[LENGTH];
int max;
/*@ requires \valid(u+(0..size-1)) && 0 < size;
@ ensures 0 <= \result < size &&
@ (\forall integer a; 0 <= a < size ==> u[a] <= u[\result]);
@ assigns max;
@*/
int maxarray(int u[], int size) {
int i = 1;
max = 0;
/*@ loop invariant
@ 0 <= max < i <= size &&
@ (\forall integer a;
@ 0 <= a < i ==> u[a] <= u[max]);
@ loop assigns i, max;
@ loop variant size-i;
@*/
while (i < size) {
if (u[i] > u[max]) { max = i; }
i++;
}
return max;
}
void main() {
max = maxarray(vec, LENGTH);
/*@ assert 0 <= max < LENGTH &&
@ (\forall integer a;
@ 0 <= a < LENGTH ==> vec[a] <= vec[max]);
@*/
}
| 17 |
/*@
requires n > 0;
requires \valid(t+(0..(n-1)));
ensures 0 <= \result < n;
ensures \forall integer k; 0 <= k < n ==> t[k] >= t[\result];
ensures \forall integer k; 0 <= k < \result ==> t[k] > t[\result];
*/
int min(int * t, int n) {
int minInd = 0, i =0;
/*@
loop assigns i, minInd;
loop invariant 0 <= i < n;
loop invariant 0 <= minInd < n;
loop invariant 0 <= minInd <= i;
loop invariant \forall integer k; 0 <= k <= i ==> t[minInd] <= t[k];
loop invariant \forall integer k; 0 <= k < minInd ==> t[k] > t[minInd];
loop variant n-1-i;
*/
while(i<n-1)
if (t[++i] < t[minInd])
minInd = i;
//@ assert i == n-1;
return minInd;
}
| 23 |
#include <limits.h>
/*@
assigns \nothing;
ensures (\result==(x0*x0));
*/
int square(int x0) {
int x2 = x0 * x0;
return x2;
}
/*@
assigns \nothing;
ensures (\result==(((x6*x6)*x6)*x6));
*/
int pow4(int x6) {
int x8 = square(x6);
int x9 = square(x8);
return x9;
}
/*@
assigns \nothing;
ensures (\result==(((x15*x15)*x15)*x15));
*/
int pow4b(int x15) {
int x17 = square(x15);
int x18 = x17 * x17;
return x18;
}
| 23 |
/*@ requires 0 <= from <= to;
@ requires \valid(s+(0..to-1));
@ ensures -1 == \result || from <= \result < to;
@ ensures \result == -1 ==>
@ (\forall int i; from <= i < to ==> s[i] != c);
@ ensures from <= \result < to ==>
@ s[\result] == c &&
@ (\forall int i; from <= i < \result ==> s[i] != c);
@ assigns \nothing;
@*/
static int indexOf(char* s, char c, int from, int to) {
/*@ loop invariant from <= k <= to;
@ loop invariant \forall int i; from <= i < k ==> s[i] != c;
@ loop assigns k;
@ loop variant to - k;
@*/
for(int k = from; k < to; k++) {
if(s[k] == c) {
return k;
}
}
return -1;
}
/*@ predicate replace_space_by_new_line{L1,L2}(char* s, int n) =
@ \forall int i; 0 <= i < n && \at(s[i], L1) != \at(s[i],L2) ==>
@ \at(s[i], L1) == ' ' && \at(s[i],L2) == '\n';
*/
/*@ predicate at_least_lineLength(char* s, int lineLength, int n) =
@ \forall int i,j; 0 <= i < j < n && s[i] == '\n' && s[j] == '\n' ==> j-i >= lineLength;
*/
/*@ requires lineLength > 0;
@ requires 0 < n;
@ requires \valid(s+(0..n-1));
@ requires \forall int i; 0 <= i < n ==> s[i] != '\n';
@ ensures replace_space_by_new_line{Pre,Post}(s,n);
@ ensures at_least_lineLength(s,lineLength,n);
@ assigns s[0 .. n -1];
@*/
void wrapLines_simpl(char* s, int lineLength, int n) {
int lastBreak = -1;
int lastSpace = indexOf(s, ' ', 0, n);
/*@ loop invariant -1 <= lastSpace < n;
@ loop invariant -1 <= lastBreak < n;
@ loop invariant lastSpace == -1 || (lastBreak < lastSpace < n && s[lastSpace] == ' ');
@ loop invariant \forall int i; lastBreak < i < n ==> \at(s[i], LoopEntry) == s[i];
@ loop invariant replace_space_by_new_line{LoopEntry,Here}(s,n);
@ loop invariant at_least_lineLength(s,lineLength,n);
@ loop assigns s[0..n-1],lastBreak,lastSpace;
@ loop variant lastSpace == -1 ? 0 : n + 1 - lastSpace;
@*/
while(lastSpace != -1) {
if(lastSpace - lastBreak > lineLength) {
s[lastSpace] = '\n';
lastBreak = lastSpace;
}
lastSpace = indexOf(s, ' ', lastSpace+1, n);
}
return;
}
/*@ predicate impossible_to_break(char* s, int length, int n) =
@ \forall int i; 0 <= i < n - length ==>
@ (\forall int j; i <= j <= i + length ==> s[j] != '\n') ==>
@ (\forall int j; i <= j <= i + length ==> s[j] != ' ');
*/
/*@ predicate break_largest{L1,L2}(char* s, int length, int n) =
@ \forall int a, b, c; 0 <= a < b < c < n &&
@ (a == -1 || \at(s[a],L2) == '\n') &&
@ \at(s[b],L2) == '\n' && \at(s[b],L1) == ' ' &&
@ (\at(s[c],L2) == ' ' || \at(s[c],L2) == '\n') ==>
@ c - a > length;
*/
/*@ requires 0 < length;
@ requires 0 < n < 2147483646; // the length of array is limited to MAX_INT -1 because of an overflow
@ requires \valid(s+(0..n-1));
@ ensures replace_space_by_new_line{Pre,Post}(s,n);
@ ensures impossible_to_break(s,length,n);
@ ensures break_largest{Pre,Post}(s, length, n);
@ assigns s[0 .. n-1];
@*/
void wrapLines(char* s, int length, int n) {
int lastChange = -1;
int lastSpace = -1;
/*@ loop invariant -1 <= lastSpace < n;
@ loop invariant -1 <= lastChange <= lastSpace;
@ loop invariant lastSpace <= lastChange + length + 1;
@ loop invariant lastChange == -1 || s[lastChange] == '\n';
@ loop invariant 0 <= lastSpace ==> \at(s[\at(lastSpace,Here)],LoopEntry) == ' ' || \at(s[\at(lastSpace,Here)],LoopEntry) == '\n';
@ loop invariant \forall int x; lastChange < x < n ==> s[x] == \at(s[x],LoopEntry);
@ loop invariant \forall int x; lastChange < x <= lastSpace ==> s[x] != '\n';
@ loop invariant replace_space_by_new_line{LoopEntry,Here}(s,n);
@ loop invariant impossible_to_break(s, length, lastSpace);
@ loop invariant \forall int a, b, c; 0 <= a < b < c < n &&
b <= lastChange && (a == -1 || s[a] == '\n') &&
s[b] == '\n' && \at(s[b],LoopEntry) == ' ' &&
(s[c] == ' ' || s[c] == '\n') ==> c - a > length;
@ loop assigns s[0 .. n-1],lastChange, lastSpace;
@ loop variant 2*n - lastSpace - lastChange;
@*/
while(1) {
int nextSpace = indexOf(s, ' ', lastSpace + 1,n);
int nextNewLine = indexOf(s, '\n', lastSpace + 1,n);
if(nextSpace == -1) {
/*n - lastChange can overflow if the array contain no space and is of size MAX_INT*/
if(n - lastChange > length &&
(nextNewLine - lastChange > length || nextNewLine == -1) &&
lastSpace >= 0) {
s[lastSpace] = '\n';
}
return;
}
if(0 <= nextNewLine && nextNewLine < nextSpace) {
if(nextNewLine - lastChange > length && lastSpace >= 0) {
s[lastSpace] = '\n';
}
lastChange = lastSpace = nextNewLine;
} else {
if(nextSpace - lastChange > length) {
if(lastChange == lastSpace) {
s[nextSpace] = '\n';
lastChange = lastSpace = nextSpace;
} else {
s[lastSpace] = '\n';
lastChange = lastSpace;
}
} else {
lastSpace = nextSpace;
}
}
}
return;
}
| 114 |
#include <limits.h>
#include <string.h>
/*@
requires ((strlen(x0)>=0) &&
\valid(x0+(0..strlen(x0))));
*/
int matcher(char * x0) {
int x2 = strlen(x0);
int x3 = 0 < x2;
int x6;
if (x3) {
char x4 = x0[0];
int x5 = 'a' == x4;
x6 = x5;
} else {
x6 = 0/*false*/;
}
int x7;
if (x6) {
x7 = 1/*true*/;
} else {
x7 = 0/*false*/;
}
return x7;
}
| 4 |
/*@ requires \valid(i) && \valid(j);
@ requires r == \null || \valid(r);
@ assigns *r;
@ behavior zero:
@ assumes r == \null;
@ assigns \nothing;
@ ensures \result == -1;
@ behavior normal:
@ assumes \valid(r);
@ assigns *r;
@ ensures *r == ((*i < *j) ? *j : *i);
@ ensures \result == 0;
@*/
int max2(int *r, int* i, int* j) {
if (!r) return -1;
*r = (*i < *j) ? *j : *i;
return 0;
}
| 23 |
/* run.config
EXECNOW: make tests/aorai/Aorai_test.cmxs
OPT: -aorai-ltl tests/aorai/test_switch2.ltl -aorai-test 1 -aorai-acceptance -load-module tests/aorai/Aorai_test.cmxs -aorai-test-number @PTEST_NUMBER@
*/
int status=0;
int rr=1;
//@ global invariant inv : 0<=rr<=50;
/*@ requires rr<50;
@ behavior j :
@ ensures rr<51;
*/
void opa() {
rr++;
}
void opb () {
status=1;
}
void opc() {
rr=9000;
}
int main(){
switch (rr) {
case 1 :
opa();
break;
case 3 :
opa();
default :
opc();
}
opb();
return 1;
}
| 14 |
/*@
requires n>0;
requires \valid_read(a + (0..n-1));
behavior sorted:
assumes \forall integer i;
1<=i<n ==> a[i]>=a[i-1];
ensures \result ==1;
behavior unsorted:
assumes \exists integer i;
1<=i<n && a[i]< a[i-1];
ensures \result ==0;
complete behaviors;
disjoint behaviors;
*/
int is_sorted(int a[],int n){
/*@
loop invariant \forall integer j;
1<=j<i ==> a[j]>=a[j-1];
loop invariant 1<= i <= n;
loop assigns i;
loop variant n-i;
*/
for (int i=1;i<n;i++){
if (a[i-1]>a[i]){
return 0;
}
}
return 1;
}
| 17 |
/*@
behavior a_less:
assumes a<b;
ensures \result == a;
behavior b_less:
assumes a>=b;
ensures \result == b;
*/
int min(int a, int b){
if(a<b)
return a;
else
return b;
}
| 4 |
/* run.config
OPT: -obfuscate
*/
int my_var = 0;
/*@ global invariant I: my_var >= 0; */
enum my_enum {
first, second, third = 4
};
/*@ requires my_var > 0;
ensures my_var > \old(my_var);
ensures \forall integer x; x == x; */
int my_func () {
enum my_enum x = first;
/*@ assert my_var >= first; */
my_var++;
if (!my_var) goto end;
return my_var + x;
end: ;
return -1;
}
/*@ requires \valid(p);
ensures *p == 0;
*/
void f(int* p);
/*@ behavior bhv:
exits never: \false;
complete behaviors bhv;
disjoint behaviors bhv; */
int logic(int f1)
{
int V1;
V1 = 0;
if (f1) goto end;
V1 ++;
/*@ assert property: V1 ? 1: 0; */ ;
end: ;
return V1;
}
int main(int* p) {
if ("ti\rti" == "ti\rti") f(p);
}
/* Obfuscate logic types and logic constructors. */
/*@ type t = T | F; */
#include "stdint.h"
/* Do not obfuscate builtins and stdlib types and functions. */
int builtin_and_stdlib () {
int32_t x = 42;
Frama_C_show_each(x);
/*@ assert \true; */
return 1;
}
/* obfuscate names of arguments of function pointers. */
typedef void (*fct_ptr)(int x, int y);
struct S { fct_ptr my_func; };
void implem(int c, int d) { };
struct S example_struct = { .my_func = implem };
void test_func(struct S* s) { s->my_func(3,4); example_struct.my_func(5,6); }
| 4 |
/*@
requires n > 0;
requires \valid_read (a + (0..n-1));
requires \valid_read (b + (0..n-1));
assigns \nothing;
behavior equal:
assumes \forall integer k; 0 <= k < n ==> b[k] == a[k];
ensures \result == 1;
behavior not_equal:
assumes \exists integer k; 0 <= k < n && b[k] != a[k];
ensures \result == 0;
*/
int check(int *a, int *b, int n) {
/*@
loop invariant 0 <= i <= n;
loop invariant \forall integer k; 0 <= k < i ==> a[k] == b[k];
loop assigns i;
*/
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
return 0;
}
}
return 1;
}
int main() {
int a[] = {1,2,3,4,5};
int b[] = {1,2,3,4,5};
check(a, b, 5);
}
| 4 |
#include <limits.h>
/*@ predicate is_pos(int x0) = (x0>0);*/
/*@
assigns \nothing;
ensures \result <==> is_pos(x0);
*/
int is_pos(int x0) {
int x2 = x0 > 0;
return x2;
}
/*@ predicate is_nat(int x3) = (x3>=0);*/
/*@
assigns \nothing;
ensures \result <==> is_nat(x3);
*/
int is_nat(int x3) {
int x5 = x3 >= 0;
return x5;
}
/*@
requires is_pos(x6);
assigns \nothing;
ensures is_nat(\result);
*/
int minus1(int x6) {
int x8 = x6 - 1;
return x8;
}
| 13 |
/*@
requires \valid(a) && \valid(b);
ensures *a == \old(*b) && *b == \old(*a);
*/
void swap(int* a, int* b){
int tmp = *a;
*a = *b;
*b = tmp;
}
int main()
{
int a=13,b=14;
swap(&a,&b);
}
| 10 |
/* run.config
OPT: -wp-no-print -wp-rte
*/
/* run.config_qualif
OPT: -then -wp-rte -wp
*/
/* ************/
/* Solution de TP donné par Julien à L'IFIPS */
/* ************/
#define BOUND 100
/* La fonction [pair(a, len)] prend en entrée un tableau [a] de longueur
[len] ne contenant que des valeurs entre 0 et [BOUND-1] (inclus) et retourne
[-1] si [a] ne contient pas deux éléments de même valeur et retourne un des
indices correspondant à une valeur en double sinon. */
/*
Questions:
1. Définir un prédicat [has_pair(a, len)] qui est valide si et seulement s'il
existe (au moins) deux éléments du tableau [a] de longueur [len] qui sont
égaux.
2. En utilisant des comportements (behaviors), donner une spécification en
ACSL de la fonction [pair].
3. Prouver cette fonction en utilisant le WP et Alt-Ergo. La preuve doit
inclure la terminaison et l'absence d'erreur à l'exécution.
*/
/*@ predicate has_pair(int *a, integer len) =
\exists integer i, j; 0 <= i < j < len && a[i] == a[j]; */
/*@ requires len >= 0;
@ requires \valid(a+(0.. len-1));
@ requires \forall integer i; 0 <= i < len ==> 0 <= a[i] < BOUND;
@ assigns \nothing;
@
@ behavior no_pair:
@ assumes ! has_pair(a, len);
@ ensures \result == -1;
@
@ behavior has_pair:
@ assumes has_pair(a, len);
@ ensures \exists integer i;
@ 0 <= i < len && i != \result && a[\result] == a[i];
@
@ complete behaviors;
@ disjoint behaviors;
@ */
int pair(int *a, int len)
{
char seen[BOUND];
/*@ loop invariant 0 <= i <= BOUND;
@ loop invariant \forall integer j; 0 <= j < i ==> seen[j] == 0;
@
@ loop assigns i, seen[0.. BOUND-1];
@ loop variant BOUND-i; */
for(int i = 0; i < BOUND; i++)
seen[i] = 0;
/*@ loop invariant 0 <= i <= len;
@
@ loop invariant
@ \forall integer v; 0 <= v < BOUND ==> seen[v]
@ ==> \exists integer j; 0 <= j < i && a[j] == v;
@
@ loop invariant
@ \forall integer v; 0 <= v < BOUND ==> ! seen[v]
@ ==> \forall integer j; 0 <= j < i ==> a[j] != v;
@
@ loop invariant !has_pair(a, i);
@
@ loop assigns i, seen[0.. BOUND-1];
@ loop variant len-i; */
for(int i = 0; i < len; i++) {
int v = a[i];
if (seen[v]) return i;
else seen[v] = 1;
}
return -1;
}
| 37 |
#define INT_MIN (-2147483648)
/*@ requires v != INT_MIN;
assigns \nothing;
ensures \result == \abs(v);
*/
int abs(int v)
{
return v >= 0 ? v : -v;
}
| 6 |
#include <stdlib.h>
#include <ctype.h>
#include <stdio.h>
#include <stdbool.h>
#define boxArea(box) (box >= 1 && box <= 9 ? TRUE : FALSE)
#define validCoord(x, y) ((x < 0 || x > N-1 || y < 0 || y > N-1) ? FALSE : TRUE)
#define emptyBox(box) (box == ' ' ? TRUE : FALSE)
#define OTHER(player) (player == playerX ? playerO : playerX)
//#define playerX 'X'
//#define playerO 'O'
#define TRUE 1
#define FALSE 0
// #define open_spot ((char)' ')
#define GAMEWIN 1
#define GAMETIE 0
#define GAMELOSE -1
#define INCOMPLETE 2
#define value_type char
#define N 3
const char playerX = 'X';
const char playerO = 'O';
const char open_spot=' ';
int game_result = -15;
// **Functions**
void initialize(char board[N][N]);
void print_board(char board[N][N]);
int comp_turn(char board[N][N], char player);
int player_turn(char board[N][N], char player);
bool gridTurn(char board[N][N], char player, int grid_var);
int coordTurn(char board[N][N], char player, int x, int y);
int win_check(char board[N][N], char player);
int diag_check(char board[N][N], char player);
int tie_check(char board[N][N]);
int minNum(char board[N][N], char player);
int maxNum(char board[N][N], char player);
void new_board_check(char board[N][N], char new_board[N][N]);
void minimax(char board[N][N], char player);
bool end_game(int play);
/*@
predicate zeroed(char *a, integer numCols) =
\forall int i; 0<=i<numCols ==> a[i] == ' ';
predicate zeroed2d(char (*a)[N], integer numRows) =
\forall int i; 0<=i<numRows ==> zeroed(&a[i][0], N);
*/
// predicate zeroed2d{A}(char **a, integer n, integer m) =
// \forall int i; 0<=i<n ==> zeroed(a[i], m);
/*@
predicate
HasValue(char* a, integer m, integer n, char v) =
\exists integer i; m <= i < n && a[i] == v;
predicate
HasValue(char* a, integer n, char v) =
HasValue(a, 0, n, v);
predicate
HasValue2d(char (*a)[N], integer numRows, char v) =
\exists integer i; 0<=i<numRows && HasValue(&a[i][0], N, v);
*/
/*@
predicate Won(char (*a)[N], char p) =
(\exists integer i; 0<=i<N && \forall integer j; 0<=j<N==>a[i][j]== p) ||
(\exists integer i; 0<=i<N && \forall integer j; 0<=j<N==>a[j][i]== p) ||
(\forall integer i; 0<=i<N==>a[i][i]==p) ||
(a[2][0]==p && a[1][1]==p && a[0][2]);
@*/
int main() {
char board[N][N];
initialize(board);
print_board(board);
while (TRUE) {
if (player_turn(board, playerX) == TRUE)
break;
if (comp_turn(board, playerO) == TRUE)
break;
}
return 0;
}
// Initialize board
/*@
@ requires \valid(board[0..(N-1)]+(0.. (N-1)));
@ assigns board[0.. (N-1) ][0..2];
@ ensures zeroed2d(board,N);
@*/
void initialize(char board[N][N]) {
/*@
@ loop invariant 0<=i<=N;
@ loop invariant zeroed2d(board, i);
@ loop assigns i, board[0.. (N-1) ][0..2];
@ loop variant N-i;
@*/
for (int i = 0; i < N; ++i) {
/*@ loop invariant 0<=i<= N && 0<=j<=N;
@ loop invariant zeroed2d(board, i);
@ loop invariant zeroed(&board[i][0],j);
@ loop assigns j, board[0.. (N-1) ][0..2];
@ loop variant N-j;
@*/
for (int j = 0; j < N; ++j) {
board[i][j] = ' ';
}
}
}
/*@ requires \valid(board[0..(N-1)]+(0.. (N-1)));
@ assigns board[0..(N-1)][0..2];
@*/
void print_board(char board[N][N]) {
//printf("\n");
int i;
/*@ loop invariant 0<=i<=N;
@ loop assigns i, board[0.. (N-1)][0..2];
@ loop variant N-i;
@*/
for (i = 0; i < N; ++i) {
//printf("| %c | %c | %c |\n", board[0][i], board[1][i], board[2][i]);
}
//printf("\n");
}
/*@
@ assigns \nothing;
@ behavior GameWin:
assumes play == GAMEWIN;
ensures \result == TRUE;
@ behavior GameTie:
assumes play == GAMETIE;
ensures \result == TRUE;
@ behavior return_false:
assumes play != GAMEWIN && play != GAMETIE;
ensures \result == FALSE;
@*/
bool end_game(int play) {
if (play == GAMEWIN) {
//printf("\nWinner is: Computer\n");
return TRUE;
} else if (play == GAMETIE) {
//printf("\nTie game\n");
return TRUE;
}
return FALSE;
}
/*@
@ requires \valid(board[0..(N-1)]+(0.. (N-1)));
@ assigns board[0.. (N-1) ][0..2], game_result;
@*/
int comp_turn(char board[N][N], char player) {
//printf("\t\t\tComputer's turn\n");
minimax(board, player);
print_board(board);
int play = win_check(board, player);
return end_game(play);
}
// Player's turn
/*@
@ requires \valid(board[0..(N-1)]+(0.. (N-1)));
@ assigns board[0.. (N-1) ][0..2], game_result;
@*/
int player_turn(char board[N][N], char player) {
int grid_var;
/*@
@ loop assigns grid_var, board[0.. (N-1) ][0..2], game_result;
@*/
while (TRUE) {
//printf("Enter number: "); // Allows the user to pick a spot according to the diagram
//scanf("%d", &grid_var);
//printf("\t\t\tPlayer's turn\n");
if (gridTurn(board, player, grid_var) == 0) // If incorrect location is chosen, make user try again
break;
//printf("Wrong selection, try again\n");
}
print_board(board);
int play = win_check(board, player);
return end_game(play);
}
/*@
@ requires \valid(board[0..(N-1)]+(0.. (N-1)));
@ assigns board[0.. (N-1) ][0..2];
@ behavior box_area:
assumes boxArea(grid_var) == FALSE;
ensures \result == TRUE;
@*/
bool gridTurn(char board[N][N], char player, int grid_var) {
if (boxArea(grid_var) == FALSE) {
return TRUE;
}
//Calculates i, j coordinates on grid
int i, j;
/*@
@ ensures j >= 0;
@ ensures emptyBox(board[i][j]) == FALSE ==> TRUE;
@ ensures grid_var < 4 ==> j == 0;
@ ensures j == 1 ==> grid_var < 7;
@ ensures j == 2 ==> grid_var < 10;
@ assigns i,j, grid_var;
@*/
if (grid_var < 4) {
j = 0;
} else if (grid_var < 7) {
j = 1;
} else {
j = 2;
}
i = grid_var - 1 - (j * N);
/*@
@ ensures i == grid_var-1-(j*N);
@ ensures \forall integer i, j; emptyBox(board[i][j]) == FALSE ==> TRUE;
@*/
if (emptyBox(board[i][j]) == FALSE) {
return TRUE;
}
board[i][j] = player;
return FALSE;
}
/*@
@ behavior validCoord:
assumes validCoord(x,y) == FALSE;
ensures \result == TRUE;
@ behavior emptyBox:
assumes emptyBox(board[x][y]) == FALSE;
ensures \result == TRUE;
@ behavior return_false:
assumes validCoord(x,y) == TRUE && emptyBox(board[x][y]) == TRUE;
ensures board[x][y] == player;
ensures \result == FALSE;
complete behaviors validCoord, emptyBox, return_false;
@*/
int coordTurn(char board[N][N], char player, int x, int y) {
// Check if coordinates are valid
if (validCoord(x, y) == FALSE) {
return TRUE;
}
if (emptyBox(board[x][y]) == FALSE) {
return TRUE;
}
board[x][y] = player;
return FALSE;
}
/*@
@ requires \valid_read(board[0..(N-1)]+(0..2));
@ assigns \nothing;
@ ensures (board[0][0] != open_spot && board[0][0] == board[1][0] && board[1][0] == board[2][0]) && board[0][0] == player ==> GAMEWIN;
@ ensures (board[0][1] != open_spot && board[0][1] == board[1][1] && board[1][1] == board[2][1]) && board[0][1] == player ==> GAMEWIN;
@ ensures (board[0][2] != open_spot && board[0][2] == board[1][2] && board[1][2] == board[2][2]) && board[0][2] == player ==> GAMEWIN;
@ ensures (board[0][0] != open_spot && board[0][0] == board[1][0] && board[1][0] == board[2][0]) && board[0][0] != player ==> GAMELOSE;
@ ensures (board[0][1] != open_spot && board[0][1] == board[1][1] && board[1][1] == board[2][1]) && board[0][1] != player ==> GAMELOSE;
@ ensures (board[0][2] != open_spot && board[0][2] == board[1][2] && board[1][2] == board[2][2]) && board[0][2] != player ==> GAMELOSE;
@ ensures (board[0][0] != open_spot && board[0][0] == board[0][1] && board[0][1] == board[0][2]) && board[0][0] == player ==> GAMEWIN;
@ ensures (board[1][0] != open_spot && board[1][0] == board[1][1] && board[1][1] == board[1][2]) && board[1][0] == player ==> GAMEWIN;
@ ensures (board[2][0] != open_spot && board[2][0] == board[2][1] && board[2][1] == board[2][2]) && board[2][0] == player ==> GAMEWIN;
@ ensures (board[0][0] != open_spot && board[0][0] == board[0][1] && board[0][1] == board[0][2]) && board[0][0] != player ==> GAMELOSE;
@ ensures (board[1][0] != open_spot && board[1][0] == board[1][1] && board[1][1] == board[1][2]) && board[1][0] != player ==> GAMELOSE;
@ ensures (board[2][0] != open_spot && board[2][0] == board[2][1] && board[2][1] == board[2][2]) && board[2][0] != player ==> GAMELOSE;
@ ensures \forall integer diag; diag ==> (diag != FALSE);
@*/
int win_check(char board[N][N], char player) {
int i, j;
// For rows and columns
/*@
@ loop invariant win_check_outerLoop: 0<=i<=N;
@ loop assigns i;
@ loop variant N-i;
@*/
for (i = 0; i < N; ++i) {
// Row
if (board[0][i] != open_spot) {
if (board[0][i] == board[1][i] && board[1][i] == board[2][i]) {
return board[0][i] == player ? GAMEWIN : GAMELOSE;
}
}
// Column
if (board[i][0] != open_spot) {
if (board[i][0] == board[i][1] && board[i][1] == board[i][2]) {
return board[i][0] == player ? GAMEWIN : GAMELOSE;
}
}
}
//check the diagonal
int diag = diag_check(board, player);
if (diag != FALSE){
return diag;
}
// check for a tie
return tie_check(board);
}
/*@
@ requires \valid_read(board[0..(N-1)]+(0.. (N-1)));
@ assigns \nothing;
@ behavior left_true:
assumes board[0][0] != open_spot && board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] == player;
ensures \result == GAMEWIN;
@ behavior right_true:
assumes board[0][0] != open_spot && board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != player;
ensures \result == GAMELOSE;
@ behavior left_false:
assumes board[2][0] != open_spot && board[2][0] == board[1][1] && board[1][1] == board[0][2] && board[2][0] == player;
ensures \result == GAMEWIN;
@ behavior right_false:
assumes board[2][0] != open_spot && board[2][0] == board[1][1] && board[1][1] == board[0][2] && board[2][0] != player;
ensures \result == GAMELOSE;
@*/
int diag_check(char board[N][N], char player){
// Check left diagonal
if (board[0][0] != open_spot && board[0][0] == board[1][1] && board[1][1] == board[2][2]) {
return board[0][0] == player ? GAMEWIN : GAMELOSE;
}
// Check right diagonal
if (board[2][0] != open_spot && board[2][0] == board[1][1] && board[1][1] == board[0][2]) {
return board[2][0] == player ? GAMEWIN : GAMELOSE;
}
return FALSE;
}
/*@
@ requires \valid_read(board[0..(N-1)]+(0.. (N-1)));
@ assigns \nothing;
@ behavior incomplete_game:
assumes HasValue2d(board, N, open_spot);
ensures \result == INCOMPLETE;
@ behavior tie_game:
assumes !HasValue2d(board, N, open_spot);
ensures \result == GAMETIE;
@*/
int tie_check(char board[N][N]){
// Check for a tie
/*@
@ loop invariant outer: 0<=i<=N;
@ loop invariant outer_prev_rows: !HasValue2d(board, i, open_spot);
@ loop assigns i;
@ loop variant N-i;
@*/
for (int i = 0; i < N; ++i) {
/*@
@ loop invariant inner_range: 0<=i<=N && 0<=j<=N;
@ loop invariant inner_prev_rows: !HasValue2d(board, i, open_spot);
@ loop invariant inner_left: !HasValue(&board[i][0], j, open_spot);
@ loop assigns j;
@ loop variant N-j;
@*/
for (int j = 0; j < N; ++j) {
if (board[i][j] == open_spot)
// Incomplete board
return INCOMPLETE;
}
}
return GAMETIE;
}
/*@
@ requires \valid(board[0..(N-1)]+(0.. (N-1)));
@ assigns func_min_assign: game_result, board[0.. (N-1) ][0..2];
@
@ behavior test:
assumes \forall int i, j; 0<=j<=i<=N && board[i][j] != open_spot;
ensures \result == game_result;
@ behavior test2:
assumes \forall int i, j; 0<=j<=i<=N && board[i][j] != open_spot && Won(board,player);
ensures game_result == GAMEWIN && \result == game_result ;
@ behavior test3:
assumes \forall int i, j; 0<=j<=i<=N && board[i][j] != open_spot && Won(board,player);
ensures game_result == GAMELOSE && \result == game_result ;
@ behavior test4:
assumes \forall int i, j; 0<=j<=i<=N && board[i][j] != open_spot && !Won(board,playerX) && !Won(board, playerO);
ensures game_result == GAMETIE && \result == game_result ;
@
@*/
int minNum(char board[N][N], char player) {
game_result = win_check(board, OTHER(player));
if (game_result != INCOMPLETE)
return game_result;
int min = 10;
/*@
@ loop invariant 0<=i<=N;
@ loop assigns i, min, game_result;
@ loop variant N-i;
@*/
for (int i = 0; i < N; ++i) {
/*@
@ loop invariant 0<=i<=N && 0<=j<=N;
@ loop assigns j, min, game_result;
@ loop variant N-j;
@*/
for (int j = 0; j < N; ++j) {
if (board[i][j] != ' ')
continue;
char new_board[N][N];
new_board_check( board, new_board);
new_board[i][j] = player;
int temp = maxNum(new_board, OTHER(player));
if (temp < min)
min = temp;
}
}
return min;
}
/*@
@ requires \valid(board[0..(N-1)]+(0.. (N-1)));
@ assigns funct_assign: game_result, board[0.. (N-1) ][0..2];
@
@ behavior test:
assumes \forall int i, j; 0<=j<=i<=N && board[i][j] != open_spot;
ensures \result == game_result;
@ behavior test2:
assumes \forall int i, j; 0<=j<=i<=N && board[i][j] != open_spot && Won(board,player);
ensures game_result == GAMEWIN && \result == game_result ;
@ behavior test3:
assumes \forall int i, j; 0<=j<=i<=N && board[i][j] != open_spot && Won(board,player);
ensures game_result == GAMELOSE && \result == game_result ;
@ behavior test4:
assumes \forall int i, j; 0<=j<=i<=N && board[i][j] != open_spot && !Won(board,playerX) && !Won(board, playerO);
ensures game_result == GAMETIE && \result == game_result ;
@
@*/
int maxNum(char board[N][N], char player) {
game_result = win_check(board, player);
if (game_result != INCOMPLETE)
return game_result;
int max = -10;
/*@
@ loop invariant outerloop: 0<=i<=N;
@ loop assigns outer_assign: i, max, game_result;
@ loop variant N-i;
@*/
for (int i = 0; i < N; ++i) {
/*@
@ loop invariant inner_loop: 0<=i<=N && 0<=j<=N;
@ loop assigns inner_assign: j, max, game_result;
@ loop variant N-j;
@*/
for (int j = 0; j < N; ++j) {
if (board[i][j] != ' ')
continue;
char new_board[N][N];
new_board_check( board, new_board);
new_board[i][j] = player;
int temp = minNum(new_board, OTHER(player));
if (temp > max)
max = temp;
}
}
return max;
}
/*@
@ requires \valid_read(board[0..(N-1)]+(0..2));
@ requires \valid(new_board[0..(N-1)]+(0..2));
@ assigns new_board[0.. (N-1) ][0..2];
@ ensures \forall int i,j; 0<=i<=N && 0<=j<=N ==> new_board[i][j] == board[i][j];
@*/
void new_board_check(char board[N][N], char new_board[N][N]){
/*@
@ loop invariant 0<=x<=N;
@ loop assigns x, new_board[0.. (N-1) ][0..2];
@ loop variant N-x;
@*/
for (int x = 0; x < N; ++x) {
/*@
@ loop invariant 0<=x<=N && 0<=y<=N;
@ loop assigns y, new_board[0.. (N-1) ][0..2];
@ loop variant N-y;
@*/
for (int y = 0; y < N; ++y) {
new_board[x][y] = board[x][y];
}
}
}
/*@
@ requires \valid(board[0..(N-1)]+(0.. (N-1)));
@ assigns board[0.. (N-1) ][0..2], game_result;
@*/
void minimax(char board[N][N], char player) {
//@ assigns max, mval_i, mval_j;
int max, mval_i, mval_j;
max = -10;
/*@
@ loop invariant minimax_first_loop: 0<=i<=N;
@ loop assigns i, max,mval_i,mval_j, game_result;
@ loop variant N-i;
@*/
for (int i = 0; i < N; ++i) {
/*@
@ loop invariant minimax_second_loop: 0<=i<=N && 0<=j<=N;
@ loop assigns j, max,mval_i,mval_j, game_result;
@ loop variant N-j;
@*/
for (int j = 0; j < N; ++j) {
if (board[i][j] != ' ')
continue;
char new_board[N][N];
new_board_check( board, new_board);
new_board[i][j] = player;
int temp = minNum(new_board, OTHER(player)); // Computer is at top of tree
if (temp > max) { // Finish with the highest outcome of minNum loop
max = temp;
mval_i = i;
mval_j = j;
}
}
}
if (coordTurn(board, player, mval_i, mval_j) == TRUE) {
//printf("Minimax error\n");
exit(0);
}
}
| 6 |
/*@
ensures (('a'<=c && c<='z') || ('A'<=c && c<='Z')) ==> \result==1;
ensures !(('a'<=c && c<='z') || ('A'<=c && c<='Z'))==> \result==0;
*/
int alphabet_letter(char c){
if( ('a'<= c && c <='z') || ('A' <= c && c <='Z') ) return 1;
else return 0;
}
int main(){
int ch ;
ch = alphabet_letter('x') ;
//@ assert ch==1 ;
ch = alphabet_letter('H') ;
//@ assert ch==1 ;
ch = alphabet_letter(' ') ;
//@ assert !ch ;
}
| 9 |
typedef struct _vc {
int n;
char* a;
} vc;
typedef struct _vvc {
int n;
struct _vc* a;
} vvc;
/*@
// Invariant and equality spec for Vector[Char]
predicate spec_Inv_VC(vc v) =
v.n==0 || (v.n>0 && \valid(v.a+(0..v.n-1)));
predicate spec_Eq_VC(vc v1, vc v2) =
(v1.n==v2.n) &&
(\forall int j; (0<=j<v1.n) ==> v1.a[j] == v2.a[j]);
// Invariant and equality spec for Vector[Vector[Char]]
predicate spec_Inv_VVC(vvc v) =
v.n==0 || (v.n>0 && \valid(v.a+(0..v.n-1))) &&
(\forall int j; (0<=j<v.n) ==> spec_Inv_VC(v.a[j]));
predicate spec_Eq_VVC(vvc v1, vvc v2) =
(v1.n==v2.n) &&
(\forall int j; (0<=j<v1.n) ==> spec_Eq_VC(v1.a[j],v2.a[j]));
*/
// Contract and implementation for Vector[Char] equality
/*@ requires spec_Inv_VC(v1) && spec_Inv_VC(v2);
ensures (\result == 1) || (\result == 0);
ensures (\result == 1) <==> spec_Eq_VC(v1, v2);
ensures (\result == 0) <==> !spec_Eq_VC(v1, v2);
assigns \nothing; */
int eq_VC(vc v1, vc v2) {
if (v1.n != v2.n) return 0;
/*@ loop invariant (0 <= i <= v1.n);
loop invariant \forall int j; (0 <= j < i) ==> v1.a[j]==v2.a[j];
loop assigns i;
loop variant (v1.n-i); */
for (int i = 0; i < v1.n; i++) {
if (v1.a[i] != v2.a[i]) return 0;
}
return 1;
}
// Contract and implementation for Vector[Vector[Char]] equality
/*@ requires spec_Inv_VVC(v1) && spec_Inv_VVC(v2);
ensures (\result == 1) || (\result == 0);
ensures (\result == 1) <==> spec_Eq_VVC(v1, v2);
ensures (\result == 0) <==> !spec_Eq_VVC(v1, v2);
assigns \nothing; */
int eq_VVC(vvc v1, vvc v2) {
if (v1.n != v2.n) return 0;
/*@ loop invariant (0 <= i <= v1.n);
loop invariant \forall int j; (0 <= j < i) ==> spec_Eq_VC(v1.a[j],v2.a[j]);
loop assigns i;
loop variant (v1.n-i); */
for (int i = 0; i < v1.n; i++) {
if (eq_VC(v1.a[i],v2.a[i]) != 1) return 0;
}
return 1;
}
| 44 |
#include<assert.h>
/*@
@ ensures \result == 1;
@
*/
int gimmeOne() {
return 1;
}
int main() {
int x = gimmeOne();
assert(x == 1);
}
| 6 |
#include <string.h>
/*@
requires strlen(input)>=0 && \valid(input+(0..strlen(input)));
assigns \nothing;
ensures \result==0 || \result==1;
*/
int dfa_aabany(char* input) {
if (*input == '\0') return 0/*false*/;
int id = 0;
char c;
/*@
loop invariant strlen(input)>0 && \valid(input+(0..strlen(input)));
loop invariant id == 17 || id == 14 || id == 11 || id == 6 || id == 3 || id == 0;
loop assigns id, c, input;
loop variant strlen(input);
*/
while (input[1] != '\0') {
c = *input++;
if (id == 17) {
char x18 = c;
int x19 = x18 == 'A';
int x23;
if (x19) {
return 1/*true*/;
} else {
return 1/*true*/;
}
id = x23;
}
else if (id == 14) {
char x15 = c;
int x16 = x15 == 'A';
int x24;
if (x16) {
return 1/*true*/;
} else {
return 1/*true*/;
}
id = x24;
}
else if (id == 11) {
char x12 = c;
int x13 = x12 == 'A';
int x26;
if (x13) {
return 1/*true*/;
} else {
return 1/*true*/;
}
id = x26;
}
else if (id == 6) {
char x7 = c;
int x8 = x7 == 'A';
int x29;
if (x8) {
x29 = 6;
} else {
int x10 = x7 == 'B';
int x28;
if (x10) {
return 1/*true*/;
} else {
x28 = 0;
}
x29 = x28;
}
id = x29;
}
else if (id == 3) {
char x4 = c;
int x5 = x4 == 'A';
int x30;
if (x5) {
x30 = 6;
} else {
x30 = 0;
}
id = x30;
}
else if (id == 0) {
char x1 = c;
int x2 = x1 == 'A';
int x32;
if (x2) {
x32 = 3;
} else {
x32 = 0;
}
id = x32;
}
else { return -1; /*error: invalid state*/ }
}
c = *input;
if (id == 17) {
char x18 = c;
int x19 = x18 == 'A';
int x23;
if (x19) {
x23 = 1/*true*/;
} else {
x23 = 1/*true*/;
}
id = x23;
}
else if (id == 14) {
char x15 = c;
int x16 = x15 == 'A';
int x24;
if (x16) {
x24 = 1/*true*/;
} else {
x24 = 1/*true*/;
}
id = x24;
}
else if (id == 11) {
char x12 = c;
int x13 = x12 == 'A';
int x26;
if (x13) {
x26 = 1/*true*/;
} else {
x26 = 1/*true*/;
}
id = x26;
}
else if (id == 6) {
char x7 = c;
int x8 = x7 == 'A';
int x29;
if (x8) {
x29 = 0/*false*/;
} else {
int x10 = x7 == 'B';
int x28;
if (x10) {
x28 = 1/*true*/;
} else {
x28 = 0/*false*/;
}
x29 = x28;
}
id = x29;
}
else if (id == 3) {
char x4 = c;
int x5 = x4 == 'A';
int x30;
if (x5) {
x30 = 0/*false*/;
} else {
x30 = 0/*false*/;
}
id = x30;
}
else if (id == 0) {
char x1 = c;
int x2 = x1 == 'A';
int x32;
if (x2) {
x32 = 0/*false*/;
} else {
x32 = 0/*false*/;
}
id = x32;
}
else { return -1; /*error: invalid state */ }
return id;
}
| 58 |
#define value_type unsigned int
/////////////// Base definition
/*@
@ logic integer occurence{L}( value_type* a, integer l, integer h, value_type e ) =
@ l >= h ? 0 : ( a[l] == e ? 1 : 0 ) + occurence( a, l+1, h, e );
@
*/
/////// Axioms with functions as proof
// range
/*@ requires l <= h;
@ assigns \nothing;
@ ensures 0 <= occurence( a, l, h, e ) <= h - l;
*/
void occurence_range_proof( value_type* a, unsigned int l, unsigned int h, value_type e ){
/*@ loop invariant l <= i <= h;
@ loop invariant 0 <= occurence( a, l, i, e ) <= i - l;
@ loop assigns i;
@ loop variant (h - i);
*/
for (unsigned int i = l; i != h; ++i){}
}
/*@
@ axiomatic Occurence_range {
@
@ axiom occurence_n_range: \forall value_type* a, integer l, h, value_type e, integer n;
@ l <= h ==> 0 <= occurence( a, l, h, e ) <= h - l;
@ }
@
*/
// reverse
/*@ requires l < h;
@ assigns \nothing;
@ ensures occurence( a, l, h, e ) == (a[h-1] == e ? 1 : 0) + occurence( a, l, h-1, e);
*/
void occurence_reverse_proof( value_type* a, unsigned int l, unsigned int h, value_type e ){
/*@ loop invariant l <= i < h;
@ loop invariant occurence( a, i, h, e ) == (a[h-1] == e ? 1 : 0) + occurence( a, i, h-1, e);
@ loop assigns i;
@ loop variant (i - l);
*/
for (unsigned int i = h-1; i != l; --i){}
}
/*@
@ axiomatic Occurence_reverse {
@
@ axiom occurence_reverse: \forall value_type* a, integer l, h, value_type e, integer n;
@ l < h ==> occurence( a, l, h, e ) == (a[h-1] == e ? 1 : 0) + occurence( a, l, h-1, e);
@ }
@
*/
// split
/*@ requires l <= cut <= h;
@ assigns \nothing;
@ ensures occurence( a, l, h, e ) == occurence( a, l, cut, e ) + occurence( a, cut, h, e );
*/
void occurence_split_proof( value_type* a, unsigned int l, unsigned int h, value_type e, unsigned int cut ){
/*@ loop invariant cut <= i <= h;
@ loop invariant occurence( a, l, i, e ) == occurence( a, l, cut, e ) + occurence( a, cut, i, e );
@ loop assigns i;
@ loop variant (h - i);
*/
for (unsigned int i = cut; i != h; ++i){}
}
/*@
@ axiomatic Occurence_split{
@
@ axiom occurence_split: \forall value_type* a, integer l, h, value_type e, integer cut;
@ l <= cut <= h ==> occurence( a, l, h, e ) == occurence( a, l, cut, e ) + occurence( a, cut, h, e );
@ }
@
*/
/////// a function computing the occurence
/*@ requires \valid( a+(l..h-1) );
@ requires l < h;
@
@ assigns \nothing;
@
@ ensures \result == occurence( a, l, h, e );
*/
unsigned int occurence( value_type* a, unsigned int l, unsigned int h, value_type e ){
unsigned int result = 0;
/*@ loop invariant occurence_i_range: l <= i <= h;
@ loop invariant always_valid: \valid( a+(l..h-1) );
@ loop invariant occurence_result_prefix: occurence( a, l, h, e ) == result + occurence( a, i, h, e );
@ loop assigns i, result;
@ loop variant (h - i);
*/
for (unsigned int i = l; i != h; ++i){
if (a[i] == e)
result += 1;
}
return result;
}
////// permutation definition
/*@
@ predicate permutation{L1, L2}( value_type* a, integer l, integer h ) =
@ \forall value_type e; occurence{L1}( a, l, h, e ) == occurence{L2}( a, l, h, e );
*/
/// swap
/*@
@ requires l <= i1 < h;
@ requires l <= i2 < h;
@ requires \valid( a+(l..h-1) );
@
@ assigns a[i1], a[i2];
@
@ ensures \at( a[i1], Post ) == \at( a[i2], Pre );
@ ensures \at( a[i2], Post ) == \at( a[i1], Pre );
@ //ensures permutation{ Pre, Post }( a, l, h );
*/
void swap( value_type* a, unsigned int l, unsigned int h, unsigned int i1, unsigned int i2 ){
value_type tmp = a[i2];
// ghost call is like instantiation of quantifier / SMT triggering
/*@ ghost occurence_split_proof( a, l, h, a[i2], i2 ); */
//@assert A1: occurence( a, l, h, a[i2] ) == occurence( a, l, i2, a[i2] ) + occurence( a, i2, h, a[i2] );
//@assert A2: occurence( a, l, h, a[i2] ) == occurence( a, l, i2, a[i2] ) + 1 + occurence( a, i2+1, h, a[i2] );
a[i2] = a[i1];
a[i1] = tmp;
}
/*@ predicate ordered( value_type* a, integer l, integer h ) =
@ \forall integer k1, k2; l <= k1 <= k2 < h ==> a[k1] <= a[k2];
*/
/*@ requires \valid( a+(l..h-1) );
@ requires l < h;
@
@ assigns a[l..h-1];
@
@ ensures l <= \result < h;
@ ensures \forall integer k; l <= k <= \result ==> a[k] <= a[\result];
@ ensures \forall integer k; \result <= k < h ==> a[\result] <= a[k];
@ ensures permutation{Pre, Post}( a, l, h );
*/
unsigned int partition( value_type* a, unsigned int l, unsigned int h ){
const unsigned int pivot_index = l + (h - l)/2;
const value_type pivot_value = a[pivot_index];
swap( a, l, h, pivot_index, h-1 );
unsigned int store_index = l;
/*@ loop invariant i_range: l <= i <= h;
@ loop invariant store_index_rage: l <= store_index <= i;
@ loop invariant lt_pivot: \forall integer k; l <= k < store_index ==> a[k] < pivot_value;
@ loop invariant geq_pivot: \forall integer k; store_index <= k < i ==> a[k] >= pivot_value;
@ loop invariant pivot_value_inv: a[h] == pivot_value;
@ loop invariant is_permut: permutation{Pre, Here}(a, l, h);
@ loop assigns a[l..h-1], store_index, i;
@ loop variant (h - i);
*/
for (unsigned int i = l; i != h; ++i){
if (a[i] < pivot_value){
swap( a, l, h, i, store_index );
++store_index;
}
}
swap( a, l, h, store_index, h-1 );
return store_index;
}
/*@ requires \valid( a+(l..h-1) );
@ requires l < h;
@
@ assigns a[l..h-1];
@
@ ensures ordered( a, l, h );
@ ensures permutation{Pre, Post}( a, l, h );
*/
void qsort( value_type* a, unsigned int l, unsigned int h ){
unsigned int p = partition( a, l, h );
if (l < p)
qsort( a, l, p );
if(p < h-1)
qsort( a, p+1, h );
return;
}
| 58 |
#include <limits.h>
#include <string.h>
/*@ predicate matcher_a_or_b(char * x0) = ((((x0[0]=='\0')) ? (\false) : (((x0[0]=='a') &&
((x0+1)[0]=='\0')))) || (((x0[0]=='\0')) ? (\false) : (((x0[0]=='b') &&
((x0+1)[0]=='\0')))));*/
/*@
requires ((strlen(x0)>=0) &&
\valid(x0+(0..(strlen(x0)+1)-1)));
assigns \nothing;
ensures \result <==> matcher_a_or_b(x0);
*/
int matcher_a_or_b(char * x0) {
char x2 = x0[0];
int x3 = x2 == '\0';
int x9;
if (x3) {
x9 = 0/*false*/;
} else {
int x4 = x2 == 'a';
int x8;
if (x4) {
char *x5 = x0+1;
char x6 = x5[0];
int x7 = x6 == '\0';
x8 = x7;
} else {
x8 = 0/*false*/;
}
x9 = x8;
}
int x12;
if (x3) {
x12 = 0/*false*/;
} else {
int x10 = x2 == 'b';
int x11;
if (x10) {
char *x5 = x0+1;
char x6 = x5[0];
int x7 = x6 == '\0';
x11 = x7;
} else {
x11 = 0/*false*/;
}
x12 = x11;
}
int x13 = x9 || x12;
return x13;
}
| 17 |
/*@ requires \valid(p) && \valid(q);
ensures *p <= *q;
behavior p_minimum:
assumes *p < *q;
ensures *p == \old(*p) && *q == \old(*q);
behavior q_minimum:
assumes *p >= *q;
ensures *p == \old(*q) && *q == \old(*p);
complete behaviors p_minimum, q_minimum;
disjoint behaviors p_minimum, q_minimum;
*/
void max_ptr(int*p, int*q) {
if (*p > *q) {
int tmp = *p;
*p = *q;
*q = tmp;
}
}
| 13 |
#include <limits.h>
#include <string.h>
/*@
requires (((strlen(x0)>=0) &&
\valid(x0+(0..strlen(x0)))) &&
(strlen(x0)<=INT_MAX));
assigns \nothing;
*/
int dfa(char * x0) {
int x2 = 1/*true*/;
int x3 = 0;
//@ ghost int x4 = 0;
char *x5 = x0;
/*@
loop invariant (((((strlen(x0)>=0) &&
\valid(x0+(0..strlen(x0)))) &&
((0<=x4) &&
(x4<=strlen(x0)))) &&
(x5==(x0+x4))) &&
((strlen((x0+x4))>=0) &&
\valid((x0+x4)+(0..strlen((x0+x4))))));
loop invariant ((x5[0]=='\0') ==> (strlen(x0)==x4));
loop invariant ((!(x5[0]=='\0')) ==> (strlen(x0)!=x4));
loop invariant ((x3==2) || ((x3==1) || (x3==0)));
loop assigns x5, x4, x3, x2;
loop variant strlen(x5);
*/
for (;;) {
char *x7 = x5;
char x8 = x7[0];
int x9 = x8 == '\0';
int x13;
if (x9) {
x13 = 0/*false*/;
} else {
int x11 = x2;
x13 = x11;
}
if (!x13) break;
char *x37 = x5;
char *x38 = x37+1;
x5 = x38;
/*@ghost x4 = (x4+1);*/
}
char *x84 = x5;
char x85 = x84[0];
int x86 = x85 == '\0';
int x89;
if (x86) {
int x87 = x2;
x89 = x87;
} else {
x89 = 0/*false*/;
}
int x93;
if (x89) {
int x90 = x3;
int x91 = x90 == 2;
x93 = x91;
} else {
x93 = 0/*false*/;
}
/*@assert ((x5[0]=='\0') || (!x2));*/
return x93;
}
| 26 |
/*@ requires 0 <= p <= r && \valid(A+(p..r));
@*/
int partition (int A[], int p, int r)
{
int x = A[r];
int tmp, j, i = p-1;
/*@ loop invariant p <= j <= r && p-1 <= i < j;
@ loop assigns tmp, i, j, A[p..r];
@ loop variant r-j;
@*/
for(j=p; j<r; j++)
if (A[j] <= x) {
i++;
tmp = A[i];
A[i] = A[j];
A[j] = tmp;
}
tmp = A[i+1];
A[i+1] = A[r];
A[r] = tmp;
return i+1;
}
| 26 |
/*@ ensures \result >= a && \result >= b ;
ensures \result == a || \result == b ; */
int max(int a, int b);
extern int v ;
int main(){
v = 3;
int r = max(4,2);
//@ assert v == 3 ;
}
| 3 |
// TODO : mettre les bonnes annotations...
/*@
requires n >= 0;
requires \valid_read(src+(0..n-1));
requires \valid(dst+(0..n-1));
assigns dst[0..n-1];
ensures dst[0..n-1] == \old(src[0..n-1]);
*/
void array_copy(int *src, int *dst, int n) {
if (src < dst) {
// recopier de droite à gauche
/*@
loop invariant -1 <= i <= n-1;
loop invariant
\forall int k; i < k <= n-1 ==> dst[k] == \at(src[k], Pre);
loop invariant
\forall int k; 0 <= k <= i ==> src[k] == \at(src[k], Pre);
loop assigns i, dst[0..n-1];
loop variant i+1;
*/
for (int i = n-1; -1 < i; i--) {
dst[i] = src[i];
}
} else {
// recopier de gauche à droite
/*@
loop invariant 0 <= i <= n;
loop invariant
\forall int k; 0 <= k < i ==> dst[k] == \at(src[k], Pre);
loop invariant
\forall int k; i <= k < n ==> src[k] == \at(src[k], Pre);
loop assigns i, dst[0..n-1];
loop variant n-i;
*/
for (int i = 0; i < n; i++) {
dst[i] = src[i];
}
}
}
| 33 |
// __out o, __in i
/*@ requires \valid(i) && \valid(o);
@ assigns *o;
@ ensures *o == *i;
*/
void OutAndIn(int *i, int *o) {
*o = *i;
}
void OutAndIn_test()
{
int a = 5;
int b = 0;
OutAndIn(&a, &b);
//@ assert a == b;
}
| 10 |
/* ****************************************************************************
MAXIMUM D'UN TABLEAU
L'énoncé est introduit sous la forme de commentaires C. Les différents
morceaux de programme et de spécification à considérer sont mentionnés en
programmation littéraire :
https://en.wikipedia.org/wiki/Literate_programming
************************************************************************* */
/* ---------------------------------------------------------------------------
Cet exercice est une variation de l'exercice "Maximum d'un tableau" du TD
6. Cet exercice n'a pas été corrigé en cours, mais si vous avez pris le temps
de le faire par vous-même comme je l'avais demandé, cela devrait vous
permettre de gagner un peu de temps pour ce TP noté...
------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------
La fonction [max_idx] est une fonction auxiliaire de la fonction principale
[max_seq], définie juste après. Nous ne donnons ici que sa déclaration. Sa
définition est fournie en fin de fichier.
------------------------------------------------------------------------- */
#include <limits.h>
int max_idx(unsigned int *t, int len);
/* ---------------------------------------------------------------------------
La fonction [max_seq] retourne la valeur maximale contenue dans
le tableau [t] de longueur [len]. Elle retourne -1 si le tableau est vide.
Question 1 : spécifier cette fonction en utilisant des comportements ACSL.
Question 2 : prouver cette fonction, y compris sa terminaison et l'absence
d'erreurs à l'exécution. On prendra garde à ne spécifier que les
préconditions strictement nécessaires pour garantir l'absence d'erreurs à
l'exécution.
Indice : il est autorisé d'inclure un fichier de la bibliothèque standard du
C (déjà utilisé en TD dans des cas similaires).
------------------------------------------------------------------------- */
/*@ requires \valid(t+(0..len-1));
@ requires len >= 0;
@ requires \forall integer n; 0 <= n < len ==> t[n] <= INT_MAX;
@ assigns \nothing;
@ behavior t_vide:
@ assumes len == 0;
@ ensures \result == -1;
@ behavior t_max:
@ assumes len > 0;
@ ensures \forall integer n; 0 <= n < len ==> \result >= t[n];
@ ensures \exists int e; 0 <= e < len && \result == t[e];
@ ensures \result >= 0;
@ complete behaviors;
@ disjoint behaviors;
@ */
int max_seq(unsigned int *t, int len) {
if (len <= 0) return -1;
return t[max_idx(t, len)];
}
/* ---------------------------------------------------------------------------
Ci-après, la définition de la fonction [max_idx].
------------------------------------------------------------------------- */
/*@ requires \valid(t+(0..len-1));
@ requires len > 0;
@ assigns \nothing;
@ ensures len == 0 ==> \result == 0;
@ ensures \forall integer n; 0 <= n < len ==> t[\result] >= t[n];
@ ensures 0 <= \result < len;
@ */
int max_idx(unsigned int *t, int len) {
int max = 0;
/*@loop invariant 1 <= i <= len;
@loop invariant \forall integer n; 0 <= n < i ==> t[max] >= t[n];
@loop invariant 0 <= max < len;
@loop assigns i, max;
@loop variant len - i;
@ */
for(int i = 1; i < len; i++)
if (t[max] < t[i])
max = i;
return max;
}
| 34 |
#include <limits.h>
/*@
requires ((((((((0<x0) &&
(x0<100)) &&
(0<x1)) &&
(x1<100)) &&
(0<=x2)) &&
(0<=x3)) &&
(x2<x0)) &&
(x3<x1));
assigns \nothing;
ensures ((0<=\result) &&
(\result<(x0*x1)));
*/
int index(int x0, int x1, int x2, int x3) {
int x5 = x2 * x1;
int x6 = x5 + x3;
return x6;
}
/*@ predicate inv_matrix_Boolean(int * x26, integer x27, integer x28) = (((((x27<100) &&
(x28<100)) &&
(0<x27)) &&
(0<x28)) &&
(((x27*x28)>0) &&
\valid(x26+(0..(x27*x28)-1))));*/
/*@
requires (((inv_matrix_Boolean(x63,x64,x65) &&
inv_matrix_Boolean(x66,x67,x68)) &&
inv_matrix_Boolean(x69,x70,x71)) &&
((((x64==x67) &&
(x64==x70)) &&
(x65==x68)) &&
(x65==x71)));
ensures ((inv_matrix_Boolean(x63,x64,x65) &&
inv_matrix_Boolean(x66,x67,x68)) &&
inv_matrix_Boolean(x69,x70,x71));
*/
void add(int * x63, int x64, int x65, int * x66, int x67, int x68, int * x69, int x70, int x71) {
/*@
loop invariant 0<=x76<=x70;
loop assigns x76, x69[(0..(x70*x71)-1)];
loop variant x70-x76;
*/
for(int x76=0; x76 < x70; x76++) {
/*@
loop invariant 0<=x78<=x71;
loop assigns x78, x69[(0..(x70*x71)-1)];
loop variant x71-x78;
*/
for(int x78=0; x78 < x71; x78++) {
int x79 = index(x64,x65,x76,x78);
int x80 = x63[x79];
int x81 = index(x67,x68,x76,x78);
int x82 = x66[x81];
int x83 = x80 || x82;
int x84 = index(x70,x71,x76,x78);
x69[x84] = x83;
}
}
}
/*@
requires ((inv_matrix_Boolean(x111,x112,x113) &&
inv_matrix_Boolean(x114,x115,x116)) &&
((x112==x115) &&
(x113==x116)));
ensures (inv_matrix_Boolean(x111,x112,x113) &&
inv_matrix_Boolean(x114,x115,x116));
*/
void scalar_mult(int x110, int * x111, int x112, int x113, int * x114, int x115, int x116) {
/*@
loop invariant 0<=x121<=x115;
loop assigns x121, x114[(0..(x115*x116)-1)];
loop variant x115-x121;
*/
for(int x121=0; x121 < x115; x121++) {
/*@
loop invariant 0<=x123<=x116;
loop assigns x123, x114[(0..(x115*x116)-1)];
loop variant x116-x123;
*/
for(int x123=0; x123 < x116; x123++) {
int x126;
if (x110) {
int x124 = index(x112,x113,x121,x123);
int x125 = x111[x124];
x126 = x125;
} else {
x126 = 0/*false*/;
}
int x127 = index(x115,x116,x121,x123);
x114[x127] = x126;
}
}
}
| 66 |
#include <stdbool.h>
/*@ predicate is_equal(int *a, int n, int *b) =
\forall integer i; 0 <= i < n ==> a[i] == b[i];
*/
/*@ requires n >= 0;
requires \valid(a + (0 .. n-1));
requires \valid(b + (0 .. n-1));
assigns \nothing;
ensures is_equal(a, n, b) ? \result : !\result;
*/
bool equal(int *a, int n, int *b)
{
/*@ loop invariant 0 <= i <= n;
loop invariant is_equal(a, i, b);
loop variant n - i;
*/
for(int i = 0; i < n; ++i) {
if (a[i] != b[i]) {
return false;
}
}
return true;
}
| 66 |
/*@
requires -1000000000<a<1000000000;
requires -1000000000<b<1000000000;
ensures b==\result+a && b>a || b==a-\result && a>=b;
*/
int distance(int a,int b){
if(a < b)
return b - a ;
else
return a - b ;
}
| 7 |
/*@ requires size >= 0;
requires \valid(a+(0..size-1));
requires \valid(res+(0..size-1));
assigns res[0..size-1];
ensures \forall integer i; 0 <= i < size ==> res[i] == a[size - i - 1];
*/
void reverse(int a[], int res[], int size)
{
int i;
/*@ loop invariant -1 <= i < size;
loop invariant \forall integer j; i < j < size ==> res[j] == a[size - j - 1];
loop assigns i, res[0..size-1];
loop variant i;
*/
for(i = size - 1; i >= 0; --i) {
res[i] = a[size - i - 1];
}
}
| 20 |
#include<string.h>
/*@
predicate matchhere(char* r, char* s) =
(r[0]=='\0') ||
(r[0]!='\0' && r[1]=='*' &&
(\exists int i; 0 <= i <= strlen(s) && matchhere(r+2, s+i) &&
(r[0]=='.' || (\forall int j; 0 <= j < i ==> r[0]==s[j])))) ||
(r[0]=='$' && r[1]=='\0' && s[0]=='\0') ||
((s[0]!='\0' && (r[0]=='.' || r[0]==s[0])) &&
matchhere(r+1, s+1));
*/
/*@
requires strlen(r)>=0 && \valid(r+(0..strlen(r)));
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires r[0]=='.' && r[1]=='*' && r[2]=='A' && r[3]=='A' && r[4]=='B' && r[5]=='\0';
requires s[0]=='A' && s[1]=='A' && s[2]=='B' && s[3]=='\0';
ensures matchhere(r, s);
assigns \nothing;
*/
void dfa_spec_aab1(char* r, char* s) {}
/*@
requires strlen(r)>=0 && \valid(r+(0..strlen(r)));
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires r[0]=='.' && r[1]=='*' && r[2]=='A' && r[3]=='A' && r[4]=='B' && r[5]=='\0';
requires s[0]=='A' && s[1]=='A' && s[2]=='A' && s[3]=='B' && s[4]=='\0';
ensures matchhere(r, s);
assigns \nothing;
*/
void dfa_spec_aab1_1(char* r, char* s) {}
/*@
requires strlen(r)>=0 && \valid(r+(0..strlen(r)));
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires r[0]=='.' && r[1]=='*' && r[2]=='A' && r[3]=='A' && r[4]=='B' && r[5]=='\0';
requires s[0]=='A' && s[1]=='A' && s[2]=='X' && s[3]=='\0';
ensures !matchhere(r, s);
assigns \nothing;
*/
void dfa_spec_aab0(char* r, char* s) {}
| 12 |
/*@ ensures \result==0 || \result==1;
assigns \nothing;
*/
int predicate(int v) {
return v % 2 == 0;
}
/*@ requires n > 0;
requires \valid(v+(0..n-1));
requires \valid(o+(0..n-1));
ensures 0 <= \result <= n;
ensures \forall int i; 0 <= i < \result ==> 0 <= o[i] < n;
ensures \forall int i; 0 < i < \result ==> o[i-1] < o[i];
assigns o[0..n-1];
*/
int index_where(int* v, int n, int* o) {
int r = 0;
/*@
loop invariant 0 <= i <= n;
loop invariant 0 <= r <= i;
loop invariant \forall int j; 0 <= j < r ==> 0 <= o[j] < i;
loop invariant \forall int j; 0 < j < r ==> o[j-1] < o[j];
loop assigns i, r, o[0..n-1];
loop variant n-i;
*/
for (int i = 0; i < n; i++) {
if (predicate(v[i])) {
o[r++] = i;
}
}
return r;
}
| 31 |
int m = 0;
int t[10];
int *q = &m;
/*@ requires *p <= 100 && *p >= -100 && \valid(p);
ensures \result == \old(*p)+ 1 ; */
int incr(int *p)
{
q = p;
*p = *p + 1;
return *p;
};
| 7 |
#include <limits.h>
#include <string.h>
/*@
requires (((strlen(x0)>=0) &&
\valid(x0+(0..strlen(x0)))) &&
(strlen(x0)<=INT_MAX));
assigns \nothing;
*/
int dfa(char * x0) {
int x2 = 1/*true*/;
int x3 = 0;
//@ ghost int x4 = 0;
char *x5 = x0;
/*@
loop invariant (((((strlen(x0)>=0) &&
\valid(x0+(0..strlen(x0)))) &&
((0<=x4) &&
(x4<=strlen(x0)))) &&
(x5==(x0+x4))) &&
((strlen((x0+x4))>=0) &&
\valid((x0+x4)+(0..strlen((x0+x4))))));
loop invariant ((x5[0]=='\0') ==> (strlen(x0)==x4));
loop invariant ((!(x5[0]=='\0')) ==> (strlen(x0)!=x4));
loop invariant ((x3==3) || ((x3==2) || ((x3==1) || (x3==0))));
loop assigns x5, x4, x3, x2;
loop variant strlen(x5);
*/
for (;;) {
char *x7 = x5;
char x8 = x7[0];
int x9 = x8 == '\0';
int x13;
if (x9) {
x13 = 0/*false*/;
} else {
int x11 = x2;
x13 = x11;
}
if (!x13) break;
char *x39 = x5;
char *x40 = x39+1;
x5 = x40;
/*@ghost x4 = (x4+1);*/
}
char *x86 = x5;
char x87 = x86[0];
int x88 = x87 == '\0';
int x91;
if (x88) {
int x89 = x2;
x91 = x89;
} else {
x91 = 0/*false*/;
}
int x95;
if (x91) {
int x92 = x3;
int x93 = x92 == 3;
x95 = x93;
} else {
x95 = 0/*false*/;
}
/*@assert ((x5[0]=='\0') || (!x2));*/
return x95;
}
| 26 |
#define INT_MAX 2147483647
/*@ requires (a * 2) <= INT_MAX;
assigns \nothing;
ensures \result == a * 2;
*/
unsigned lshift(unsigned a)
{
return a << 1;
}
| 4 |
struct S {
int t1[2];
int t2[2];
};
struct T {
struct S *t[2];
};
/*@ requires \valid(s) && \valid(s->t[0]);
@*/
void f(struct T *s) {
s->t[0]->t1[0] = 1;
}
int main(struct T s, struct S a) {
s.t[0] = &a;
f(&s);
return 0;
}
/* on veut :
zones globales :
Zone 0: {s.t[0]; };
Zone 1: {a.t1[0]; };
zones locales :
f:
Zone 4: { *s; }
Zone 5: { s->t[0]; }
Appels:
f(..) ligne 25: zone 4 -> zone 0, zone 5 -> zone 1
*/
| 7 |
/*@ requires n>0 && \valid(t+(0..n-1));
ensures \forall integer i; 0<=i<n ==> t[i] == val;
*/
void fill(int t[],int val,int n) {
/*@ loop invariant 0<=i<=n;
loop invariant \forall integer j; 0<=j<i ==> t[j] == val;
loop variant n-i;
*/
for(int i=0;i<n;i++) {
t[i]=val;
}
}
| 21 |
/*@
requires \valid(a) && \valid(b);
requires -10000000<*a<10000000 && -10000000<*b<10000000;
ensures \result==*a && \result>=*b || \result==*b && \result>=*a;
*/
int max_ptr(int* a,int* b){
return(*a > *b) ? *a: *b ;
}
extern int h ;
int main(){
h =42;
int a =24,b =42;
int x= max_ptr(&a,&b);
}
| 11 |
/*@
requires \valid(a) && \valid(b);
assigns *a, *b;
ensures *a == \old(*b);
ensures *b == \old(*a);
*/
void swap(int* a, int* b){
int tmp = *a;
*a = *b;
*b = tmp;
}
int main(){
int a = 42;
int b = 37;
swap(&a, &b);
//@ assert a == 37 && b == 42;
return 0;
}
| 14 |
// adding the assertions help prove preservation of the loop invariant. assert itself only proved by z3.
/*@ axiomatic Predicate_remove_copy {
logic integer predicate_remove_copy{La,Lb}(int* a, int* b, integer i_a, integer i_b, int value);
axiom predicate_remove_copy_empty{La,Lb}:
\forall int* a, int* b, value, integer i_a, i_b;
0 > i_a && 0 > i_b ==> predicate_remove_copy{La,Lb}(a, b, i_a, i_b, value) == 0;
axiom predicate_remove_copy_equal_value{La,Lb}:
\forall int* a, int* b, value, integer i_a, i_b;
0 <= i_a && \at(a[i_a],La) == value ==>
predicate_remove_copy{La,Lb}(a, b, i_a, i_b, value) ==
predicate_remove_copy{La,Lb}(a, b, i_a-1, i_b, value);
axiom predicate_remove_copy_not_equal_value{La,Lb}:
\forall int* a, int* b, value, integer i_a, i_b;
0 <= i_a && 0 <= i_b && (\at(a[i_a],La) != value <==> \at(a[i_a],La) == \at(b[i_b],Lb)) ==>
predicate_remove_copy{La,Lb}(a, b, i_a, i_b, value) ==
predicate_remove_copy{La,Lb}(a, b, i_a-1, i_b-1, value)+1;
axiom predicate_remove_copy_label{La,Lb1,Lb2}:
\forall int* a, int* b, value, integer i_a, i_b;
(\forall integer i; 0<= i <= i_b ==>
\at(b[i],Lb1) == \at(b[i],Lb2)) ==>
predicate_remove_copy{La,Lb1}(a,b,i_a,i_b,value) ==
predicate_remove_copy{La,Lb2}(a,b,i_a,i_b,value);
}
*/
/*@
requires 0 <= length;
requires \valid_range (a, 0, length-1);
requires \valid_range (dest, 0, length-1);
ensures 0 <= \result <= length;
ensures \forall integer k; 0 <= k < \result ==> dest[k] != value;
ensures \result == predicate_remove_copy{Old,Here}(a, dest, length-1, \result-1, value);
*/
int remove_copy_array (int* a, int length, int* dest, int value )
{
int i_a = 0;
int i_dest = 0;
/*@
loop invariant 0 <= i_a <= length;
loop invariant i_dest <= i_a;
loop invariant 0 <= i_dest <= length;
loop invariant \forall integer k; 0 <= k < i_dest ==> dest[k] != value;
loop invariant i_dest == predicate_remove_copy{Pre,Here}(a, dest, i_a-1, i_dest-1, value);
*/
for ( ; i_a != length; ++i_a)
if (a[i_a] != value)
{
dest[i_dest] = a[i_a];
/*@assert
i_dest+1==predicate_remove_copy{Pre,Here}(a,dest,i_a,i_dest,value);
*/
++i_dest;
}
return i_dest;
}
| 14 |
#include <limits.h>
#include <string.h>
char * p_HTTP(char * x1096);
char * p_(char * x1098);
char * p_ContentLength(char * x1100);
/*@
requires ((strlen(x0)>=0) &&
\valid(x0+(0..strlen(x0))));
assigns \nothing;
*/
int p(char * x0) {
int x2 = -1;
char *x3 = p_HTTP(x0);
int x5 = 1/*true*/;
int x6 = 0;
char *x7 = 0/*null*/;
int x8 = 1/*true*/;
int x9 = 0;
char *x10 = 0/*null*/;
int x11 = 1/*true*/;
int x12 = 0;
char *x13 = 0/*null*/;
int x14 = 1/*true*/;
int x15 = 0;
char *x16 = 0/*null*/;
int x17 = 1/*true*/;
char *x19 = 0/*null*/;
int x20 = 1/*true*/;
char *x22 = 0/*null*/;
int x23 = 1/*true*/;
char x24 = '\0';
char *x25 = 0/*null*/;
int x26 = 1/*true*/;
char *x28 = 0/*null*/;
int x29 = 1/*true*/;
char *x31 = 0/*null*/;
int x32 = 0 == x3;
if (x32) {
x31 = x0;
} else {
x29 = 0/*false*/;
x31 = x3;
}
int x40 = x29;
if (x40) {
char *x41 = x31;
x28 = x41;
} else {
char *x45 = x31;
int x52 = 1/*true*/;
char x53 = '\0';
char *x54 = 0/*null*/;
char x46 = x45[0];
int x47 = x46 == '\0';
if (x47) {
x54 = x45;
} else {
int x48 = x46 >= '0';
int x50;
if (x48) {
int x49 = x46 <= '9';
x50 = x49;
} else {
x50 = 0/*false*/;
}
if (x50) {
x52 = 0/*false*/;
x53 = x46;
char *x51 = x45+1;
x54 = x51;
} else {
x54 = x45;
}
}
int x66 = x52;
if (x66) {
char *x67 = x54;
x28 = x67;
} else {
char x70 = x53;
char *x71 = x54;
char *x72 = x71;
int x73 = 1/*true*/;
/*@
loop invariant ((strlen(x72)>=0) &&
\valid(x72+(0..strlen(x72))));
loop assigns x72, x73;
*/
for (;;) {
int x74 = x73;
if (!x74) break;
char *x76 = x72;
char x77 = x76[0];
int x78 = x77 == '\0';
if (x78) {
x73 = 0/*false*/;
} else {
int x79 = x77 >= '0';
int x81;
if (x79) {
int x80 = x77 <= '9';
x81 = x80;
} else {
x81 = 0/*false*/;
}
if (x81) {
char *x82 = x76+1;
x72 = x82;
} else {
x73 = 0/*false*/;
}
}
}
char *x106 = x72;
x26 = 0/*false*/;
x28 = x106;
}
}
int x114 = x26;
if (x114) {
char *x115 = x28;
x25 = x115;
} else {
char *x119 = x28;
char x120 = x119[0];
int x121 = x120 == '\0';
if (x121) {
x25 = x119;
} else {
int x122 = x120 == '.';
if (x122) {
x23 = 0/*false*/;
x24 = x120;
char *x123 = x119+1;
x25 = x123;
} else {
x25 = x119;
}
}
}
int x137 = x23;
if (x137) {
char *x138 = x25;
x22 = x138;
} else {
char x141 = x24;
char *x142 = x25;
int x149 = 1/*true*/;
char x150 = '\0';
char *x151 = 0/*null*/;
char x143 = x142[0];
int x144 = x143 == '\0';
if (x144) {
x151 = x142;
} else {
int x145 = x143 >= '0';
int x147;
if (x145) {
int x146 = x143 <= '9';
x147 = x146;
} else {
x147 = 0/*false*/;
}
if (x147) {
x149 = 0/*false*/;
x150 = x143;
char *x148 = x142+1;
x151 = x148;
} else {
x151 = x142;
}
}
int x163 = x149;
if (x163) {
char *x164 = x151;
x22 = x164;
} else {
char x167 = x150;
char *x168 = x151;
char *x169 = x168;
int x170 = 1/*true*/;
/*@
loop invariant ((strlen(x169)>=0) &&
\valid(x169+(0..strlen(x169))));
loop assigns x169, x170;
*/
for (;;) {
int x171 = x170;
if (!x171) break;
char *x173 = x169;
char x174 = x173[0];
int x175 = x174 == '\0';
if (x175) {
x170 = 0/*false*/;
} else {
int x176 = x174 >= '0';
int x178;
if (x176) {
int x177 = x174 <= '9';
x178 = x177;
} else {
x178 = 0/*false*/;
}
if (x178) {
char *x179 = x173+1;
x169 = x179;
} else {
x170 = 0/*false*/;
}
}
}
char *x203 = x169;
x20 = 0/*false*/;
x22 = x203;
}
}
int x211 = x20;
if (x211) {
char *x212 = x22;
x19 = x212;
} else {
char *x216 = x22;
char *x217 = x216;
int x218 = 1/*true*/;
/*@
loop invariant ((strlen(x217)>=0) &&
\valid(x217+(0..strlen(x217))));
loop assigns x217, x218;
*/
for (;;) {
int x219 = x218;
if (!x219) break;
char *x221 = x217;
char x222 = x221[0];
int x223 = x222 == '\0';
if (x223) {
x218 = 0/*false*/;
} else {
int x224 = x222 == ' ';
if (x224) {
char *x225 = x221+1;
x217 = x225;
} else {
x218 = 0/*false*/;
}
}
}
char *x249 = x217;
x17 = 0/*false*/;
x19 = x249;
}
int x255 = x17;
if (x255) {
char *x256 = x19;
x16 = x256;
} else {
char *x260 = x19;
int x267 = 1/*true*/;
int x268 = 0;
char *x269 = 0/*null*/;
int x270 = 1/*true*/;
char x271 = '\0';
char *x272 = 0/*null*/;
char x261 = x260[0];
int x262 = x261 == '\0';
if (x262) {
x272 = x260;
} else {
int x263 = x261 >= '0';
int x265;
if (x263) {
int x264 = x261 <= '9';
x265 = x264;
} else {
x265 = 0/*false*/;
}
if (x265) {
x270 = 0/*false*/;
x271 = x261;
char *x266 = x260+1;
x272 = x266;
} else {
x272 = x260;
}
}
int x284 = x270;
if (x284) {
char *x285 = x272;
x269 = x285;
} else {
char x288 = x271;
char *x290 = x272;
x267 = 0/*false*/;
char x289 = x288 - '0';
x268 = x289;
x269 = x290;
}
int x296 = x267;
if (x296) {
char *x297 = x269;
x16 = x297;
} else {
int x300 = x268;
char *x301 = x269;
char *x302 = x301;
int x303 = 1/*true*/;
int x304 = x300;
int x337 = INT_MAX;
int x338 = x337 / 10;
int x339 = x338 - 10;
/*@
loop invariant (((strlen(x302)>=0) &&
\valid(x302+(0..strlen(x302)))) &&
((x304==-1) || (0<=x304)));
loop assigns x302, x303, x304;
*/
for (;;) {
int x305 = x303;
if (!x305) break;
char *x307 = x302;
int x314 = 1/*true*/;
char x315 = '\0';
char *x316 = 0/*null*/;
char x308 = x307[0];
int x309 = x308 == '\0';
if (x309) {
x316 = x307;
} else {
int x310 = x308 >= '0';
int x312;
if (x310) {
int x311 = x308 <= '9';
x312 = x311;
} else {
x312 = 0/*false*/;
}
if (x312) {
x314 = 0/*false*/;
x315 = x308;
char *x313 = x307+1;
x316 = x313;
} else {
x316 = x307;
}
}
int x328 = x314;
if (x328) {
char *x329 = x316;
x303 = 0/*false*/;
} else {
char x332 = x315;
char *x334 = x316;
int x335 = x304;
int x336 = x335 < 0;
int x344;
if (x336) {
x344 = x335;
} else {
int x340 = x335 > x339;
int x343;
if (x340) {
x343 = -1;
} else {
char x333 = x332 - '0';
int x341 = x335 * 10;
int x342 = x341 + x333;
x343 = x342;
}
x344 = x343;
}
x304 = x344;
x302 = x334;
}
}
int x370 = x304;
char *x371 = x302;
x14 = 0/*false*/;
x15 = x370;
x16 = x371;
}
}
int x379 = x14;
if (x379) {
char *x380 = x16;
x13 = x380;
} else {
int x383 = x15;
char *x384 = x16;
char *x385 = x384;
int x386 = 1/*true*/;
/*@
loop invariant ((strlen(x385)>=0) &&
\valid(x385+(0..strlen(x385))));
loop assigns x385, x386;
*/
for (;;) {
int x387 = x386;
if (!x387) break;
char *x389 = x385;
char x390 = x389[0];
int x391 = x390 == '\0';
if (x391) {
x386 = 0/*false*/;
} else {
int x396 = x390 == '\r';
if (x396) {
x386 = 0/*false*/;
} else {
char *x393 = x389+1;
x385 = x393;
}
}
}
char *x418 = x385;
int x419 = 1/*true*/;
char *x421 = 0/*null*/;
x419 = 0/*false*/;
x421 = x418;
int x425 = x419;
if (x425) {
char *x426 = x421;
x13 = x426;
} else {
char *x430 = x421;
char *x431 = p_(x430);
int x433 = 1/*true*/;
char *x435 = 0/*null*/;
int x436 = 0 == x431;
if (x436) {
x435 = x430;
} else {
x433 = 0/*false*/;
x435 = x431;
}
int x444 = x433;
if (x444) {
char *x445 = x435;
x13 = x445;
} else {
char *x449 = x435;
x11 = 0/*false*/;
x12 = x383;
x13 = x449;
}
}
}
int x459 = x11;
if (x459) {
char *x460 = x13;
x10 = x460;
} else {
int x463 = x12;
char *x464 = x13;
char *x465 = x464;
int x466 = 1/*true*/;
int x467 = 0;
int x337 = INT_MAX;
int x338 = x337 / 10;
int x339 = x338 - 10;
int x953 = -2 == -2;
/*@
loop invariant ((strlen(x465)>=0) &&
\valid(x465+(0..strlen(x465))));
loop assigns x465, x466, x467;
*/
for (;;) {
int x468 = x466;
if (!x468) break;
char *x470 = x465;
char *x471 = p_ContentLength(x470);
int x473 = 1/*true*/;
int x474 = 0;
char *x475 = 0/*null*/;
int x476 = 1/*true*/;
int x477 = 0;
char *x478 = 0/*null*/;
int x479 = 1/*true*/;
int x480 = 0;
char *x481 = 0/*null*/;
int x482 = 1/*true*/;
int x483 = 0;
char *x484 = 0/*null*/;
int x485 = 1/*true*/;
int x486 = 0;
char *x487 = 0/*null*/;
int x488 = 1/*true*/;
char *x490 = 0/*null*/;
int x491 = 0 == x471;
if (x491) {
x490 = x470;
} else {
x488 = 0/*false*/;
x490 = x471;
}
int x499 = x488;
if (x499) {
char *x500 = x490;
} else {
char *x503 = x490;
x485 = 0/*false*/;
x486 = 1;
x487 = x503;
}
int x509 = x485;
if (x509) {
char *x510 = x470;
int x511 = 1/*true*/;
/*@
loop invariant ((strlen(x510)>=0) &&
\valid(x510+(0..strlen(x510))));
loop assigns x510, x511;
*/
for (;;) {
int x512 = x511;
if (!x512) break;
char *x514 = x510;
char x515 = x514[0];
int x516 = x515 == '\0';
if (x516) {
x511 = 0/*false*/;
} else {
int x518 = x515 == ':';
int x520;
if (x518) {
x520 = 0/*false*/;
} else {
int x519 = x515 != ' ';
x520 = x519;
}
if (x520) {
char *x521 = x514+1;
x510 = x521;
} else {
x511 = 0/*false*/;
}
}
}
char *x545 = x510;
x482 = 0/*false*/;
x483 = 0;
x484 = x545;
} else {
int x550 = x486;
char *x551 = x487;
x482 = 0/*false*/;
x483 = x550;
x484 = x551;
}
int x557 = x482;
if (x557) {
char *x558 = x484;
x481 = x558;
} else {
int x561 = x483;
char *x562 = x484;
char *x563 = x562;
int x564 = 1/*true*/;
/*@
loop invariant ((strlen(x563)>=0) &&
\valid(x563+(0..strlen(x563))));
loop assigns x563, x564;
*/
for (;;) {
int x565 = x564;
if (!x565) break;
char *x567 = x563;
char x568 = x567[0];
int x569 = x568 == '\0';
if (x569) {
x564 = 0/*false*/;
} else {
int x570 = x568 == ' ';
if (x570) {
char *x571 = x567+1;
x563 = x571;
} else {
x564 = 0/*false*/;
}
}
}
char *x595 = x563;
x479 = 0/*false*/;
x480 = x561;
x481 = x595;
}
int x601 = x479;
if (x601) {
char *x602 = x481;
x478 = x602;
} else {
int x605 = x480;
char *x606 = x481;
int x611 = 1/*true*/;
char x612 = '\0';
char *x613 = 0/*null*/;
char x607 = x606[0];
int x608 = x607 == '\0';
if (x608) {
x613 = x606;
} else {
int x609 = x607 == ':';
if (x609) {
x611 = 0/*false*/;
x612 = x607;
char *x610 = x606+1;
x613 = x610;
} else {
x613 = x606;
}
}
int x625 = x611;
if (x625) {
char *x626 = x613;
x478 = x626;
} else {
char x629 = x612;
char *x630 = x613;
x476 = 0/*false*/;
x477 = x605;
x478 = x630;
}
}
int x638 = x476;
if (x638) {
char *x639 = x478;
x475 = x639;
} else {
int x642 = x477;
char *x643 = x478;
char *x644 = x643;
int x645 = 1/*true*/;
/*@
loop invariant ((strlen(x644)>=0) &&
\valid(x644+(0..strlen(x644))));
loop assigns x644, x645;
*/
for (;;) {
int x646 = x645;
if (!x646) break;
char *x648 = x644;
char x649 = x648[0];
int x650 = x649 == '\0';
if (x650) {
x645 = 0/*false*/;
} else {
int x651 = x649 == ' ';
if (x651) {
char *x652 = x648+1;
x644 = x652;
} else {
x645 = 0/*false*/;
}
}
}
char *x676 = x644;
x473 = 0/*false*/;
x474 = x642;
x475 = x676;
}
int x682 = x473;
if (x682) {
char *x683 = x475;
x466 = 0/*false*/;
} else {
int x686 = x474;
char *x687 = x475;
char *x695 = x687;
int x696 = 1/*true*/;
/*@
loop invariant ((strlen(x695)>=0) &&
\valid(x695+(0..strlen(x695))));
loop assigns x695, x696;
*/
for (;;) {
int x697 = x696;
if (!x697) break;
char *x699 = x695;
char x700 = x699[0];
int x701 = x700 == '\0';
if (x701) {
x696 = 0/*false*/;
} else {
int x706 = x700 == '\r';
if (x706) {
x696 = 0/*false*/;
} else {
char *x703 = x699+1;
x695 = x703;
}
}
}
char *x728 = x695;
int x688 = x686 == 1;
if (x688) {
int x729 = 1/*true*/;
int x730 = 0;
char *x731 = 0/*null*/;
int x732 = 1/*true*/;
int x733 = 0;
char *x734 = 0/*null*/;
int x735 = 1/*true*/;
int x736 = 0;
char *x737 = 0/*null*/;
int x738 = 1/*true*/;
char x739 = '\0';
char *x740 = 0/*null*/;
char x689 = x687[0];
int x690 = x689 == '\0';
if (x690) {
x740 = x687;
} else {
int x691 = x689 >= '0';
int x693;
if (x691) {
int x692 = x689 <= '9';
x693 = x692;
} else {
x693 = 0/*false*/;
}
if (x693) {
x738 = 0/*false*/;
x739 = x689;
char *x694 = x687+1;
x740 = x694;
} else {
x740 = x687;
}
}
int x752 = x738;
if (x752) {
char *x753 = x740;
x737 = x753;
} else {
char x756 = x739;
char *x758 = x740;
x735 = 0/*false*/;
char x757 = x756 - '0';
x736 = x757;
x737 = x758;
}
int x764 = x735;
if (x764) {
char *x765 = x737;
x734 = x765;
} else {
int x768 = x736;
char *x769 = x737;
char *x770 = x769;
int x771 = 1/*true*/;
int x772 = x768;
/*@
loop invariant (((strlen(x770)>=0) &&
\valid(x770+(0..strlen(x770)))) &&
((x772==-1) || (0<=x772)));
loop assigns x770, x771, x772;
*/
for (;;) {
int x773 = x771;
if (!x773) break;
char *x775 = x770;
int x782 = 1/*true*/;
char x783 = '\0';
char *x784 = 0/*null*/;
char x776 = x775[0];
int x777 = x776 == '\0';
if (x777) {
x784 = x775;
} else {
int x778 = x776 >= '0';
int x780;
if (x778) {
int x779 = x776 <= '9';
x780 = x779;
} else {
x780 = 0/*false*/;
}
if (x780) {
x782 = 0/*false*/;
x783 = x776;
char *x781 = x775+1;
x784 = x781;
} else {
x784 = x775;
}
}
int x796 = x782;
if (x796) {
char *x797 = x784;
x771 = 0/*false*/;
} else {
char x800 = x783;
char *x802 = x784;
int x803 = x772;
int x804 = x803 < 0;
int x809;
if (x804) {
x809 = x803;
} else {
int x805 = x803 > x339;
int x808;
if (x805) {
x808 = -1;
} else {
char x801 = x800 - '0';
int x806 = x803 * 10;
int x807 = x806 + x801;
x808 = x807;
}
x809 = x808;
}
x772 = x809;
x770 = x802;
}
}
int x835 = x772;
char *x836 = x770;
x732 = 0/*false*/;
x733 = x835;
x734 = x836;
}
int x842 = x732;
if (x842) {
char *x843 = x734;
x731 = x843;
} else {
int x846 = x733;
char *x847 = x734;
char *x848 = x847;
int x849 = 1/*true*/;
/*@
loop invariant ((strlen(x848)>=0) &&
\valid(x848+(0..strlen(x848))));
loop assigns x848, x849;
*/
for (;;) {
int x850 = x849;
if (!x850) break;
char *x852 = x848;
char x853 = x852[0];
int x854 = x853 == '\0';
if (x854) {
x849 = 0/*false*/;
} else {
int x855 = x853 == ' ';
if (x855) {
char *x856 = x852+1;
x848 = x856;
} else {
x849 = 0/*false*/;
}
}
}
char *x880 = x848;
x729 = 0/*false*/;
x730 = x846;
x731 = x880;
}
int x886 = x729;
if (x886) {
char *x887 = x731;
x466 = 0/*false*/;
} else {
int x890 = x730;
char *x891 = x731;
char *x892 = p_(x891);
int x894 = 1/*true*/;
char *x896 = 0/*null*/;
int x897 = 0 == x892;
if (x897) {
x896 = x891;
} else {
x894 = 0/*false*/;
x896 = x892;
}
int x905 = x894;
if (x905) {
char *x906 = x896;
x466 = 0/*false*/;
} else {
char *x910 = x896;
int x911 = x467;
int x912 = x890 == -2;
int x913;
if (x912) {
x913 = x911;
} else {
x913 = x890;
}
x467 = x913;
x465 = x910;
}
}
} else {
int x921 = 1/*true*/;
char *x923 = 0/*null*/;
x921 = 0/*false*/;
x923 = x728;
int x927 = x921;
if (x927) {
char *x928 = x923;
x466 = 0/*false*/;
} else {
char *x932 = x923;
char *x933 = p_(x932);
int x935 = 1/*true*/;
char *x937 = 0/*null*/;
int x938 = 0 == x933;
if (x938) {
x937 = x932;
} else {
x935 = 0/*false*/;
x937 = x933;
}
int x946 = x935;
if (x946) {
char *x947 = x937;
x466 = 0/*false*/;
} else {
char *x951 = x937;
int x952 = x467;
int x954;
if (x953) {
x954 = x952;
} else {
x954 = -2;
}
x467 = x954;
x465 = x951;
}
}
}
}
}
int x981 = x467;
char *x982 = x465;
x8 = 0/*false*/;
x9 = x981;
x10 = x982;
}
int x988 = x8;
if (x988) {
char *x989 = x10;
x7 = x989;
} else {
int x992 = x9;
char *x993 = x10;
char *x994 = p_(x993);
int x996 = 1/*true*/;
char *x998 = 0/*null*/;
int x999 = 0 == x994;
if (x999) {
x998 = x993;
} else {
x996 = 0/*false*/;
x998 = x994;
}
int x1007 = x996;
if (x1007) {
char *x1008 = x998;
x7 = x1008;
} else {
char *x1012 = x998;
x5 = 0/*false*/;
x6 = x992;
x7 = x1012;
}
}
int x1020 = x5;
if (x1020) {
char *x1021 = x7;
} else {
int x1023 = x6;
char *x1024 = x7;
int x1026 = 1/*true*/;
char *x1027 = x1024;
/*@
loop invariant ((0<=x1029) &&
((strlen(x1027)>=0) &&
\valid(x1027+(0..strlen(x1027)))));
loop assigns x1029, x1026, x1027;
loop variant (x6-x1029);
*/
for(int x1029=0; x1029 < x1023; x1029++) {
int x1030 = x1026;
if (x1030) {
char *x1031 = x1027;
char x1032 = x1031[0];
int x1033 = x1032 == '\0';
if (x1033) {
x1026 = 0/*false*/;
} else {
char *x1034 = x1031+1;
x1027 = x1034;
}
} else {
}
}
int x1060 = x1026;
char *x1061 = x1027;
int x1025 = x1023 < 0;
if (x1025) {
} else {
int x1062 = 1/*true*/;
char *x1064 = 0/*null*/;
if (x1060) {
x1062 = 0/*false*/;
x1064 = x1061;
} else {
x1064 = x1024;
}
int x1072 = x1062;
if (x1072) {
char *x1073 = x1064;
} else {
char *x1076 = x1064;
char x1077 = x1076[0];
int x1078 = x1077 == '\0';
if (x1078) {
x2 = x1023;
} else {
}
}
}
}
int x1088 = x2;
return x1088;
}
/*@
requires ((strlen(x1102)>=0) &&
\valid(x1102+(0..strlen(x1102))));
assigns \nothing;
ensures ((0==\result) || ((strlen(\result)>=0) &&
\valid(\result+(0..strlen(\result)))));
*/
char * p_HTTP(char * x1102) {
char *x1104 = x1102;
int x1109 = 1/*true*/;
char x1110 = '\0';
char *x1111 = 0/*null*/;
char x1105 = x1102[0];
int x1106 = x1105 == '\0';
if (x1106) {
x1111 = x1102;
} else {
int x1107 = x1105 == 'H';
if (x1107) {
x1109 = 0/*false*/;
x1110 = x1105;
char *x1108 = x1102+1;
x1111 = x1108;
} else {
x1111 = x1102;
}
}
int x1123 = x1109;
if (x1123) {
char *x1124 = x1111;
x1104 = 0;
} else {
char x1127 = x1110;
char *x1128 = x1111;
int x1133 = 1/*true*/;
char x1134 = '\0';
char *x1135 = 0/*null*/;
char x1129 = x1128[0];
int x1130 = x1129 == '\0';
if (x1130) {
x1135 = x1128;
} else {
int x1131 = x1129 == 'T';
if (x1131) {
x1133 = 0/*false*/;
x1134 = x1129;
char *x1132 = x1128+1;
x1135 = x1132;
} else {
x1135 = x1128;
}
}
int x1147 = x1133;
if (x1147) {
char *x1148 = x1135;
x1104 = 0;
} else {
char x1151 = x1134;
char *x1152 = x1135;
int x1157 = 1/*true*/;
char x1158 = '\0';
char *x1159 = 0/*null*/;
char x1153 = x1152[0];
int x1154 = x1153 == '\0';
if (x1154) {
x1159 = x1152;
} else {
int x1155 = x1153 == 'T';
if (x1155) {
x1157 = 0/*false*/;
x1158 = x1153;
char *x1156 = x1152+1;
x1159 = x1156;
} else {
x1159 = x1152;
}
}
int x1171 = x1157;
if (x1171) {
char *x1172 = x1159;
x1104 = 0;
} else {
char x1175 = x1158;
char *x1176 = x1159;
int x1181 = 1/*true*/;
char x1182 = '\0';
char *x1183 = 0/*null*/;
char x1177 = x1176[0];
int x1178 = x1177 == '\0';
if (x1178) {
x1183 = x1176;
} else {
int x1179 = x1177 == 'P';
if (x1179) {
x1181 = 0/*false*/;
x1182 = x1177;
char *x1180 = x1176+1;
x1183 = x1180;
} else {
x1183 = x1176;
}
}
int x1195 = x1181;
if (x1195) {
char *x1196 = x1183;
x1104 = 0;
} else {
char x1199 = x1182;
char *x1200 = x1183;
int x1205 = 1/*true*/;
char x1206 = '\0';
char *x1207 = 0/*null*/;
char x1201 = x1200[0];
int x1202 = x1201 == '\0';
if (x1202) {
x1207 = x1200;
} else {
int x1203 = x1201 == '/';
if (x1203) {
x1205 = 0/*false*/;
x1206 = x1201;
char *x1204 = x1200+1;
x1207 = x1204;
} else {
x1207 = x1200;
}
}
int x1219 = x1205;
if (x1219) {
char *x1220 = x1207;
x1104 = 0;
} else {
char x1223 = x1206;
char *x1224 = x1207;
x1104 = x1224;
}
}
}
}
}
char *x1236 = x1104;
return x1236;
}
/*@
requires ((strlen(x1252)>=0) &&
\valid(x1252+(0..strlen(x1252))));
assigns \nothing;
ensures ((0==\result) || ((strlen(\result)>=0) &&
\valid(\result+(0..strlen(\result)))));
*/
char * p_(char * x1252) {
char *x1254 = x1252;
int x1259 = 1/*true*/;
char x1260 = '\0';
char *x1261 = 0/*null*/;
char x1255 = x1252[0];
int x1256 = x1255 == '\0';
if (x1256) {
x1261 = x1252;
} else {
int x1257 = x1255 == '\r';
if (x1257) {
x1259 = 0/*false*/;
x1260 = x1255;
char *x1258 = x1252+1;
x1261 = x1258;
} else {
x1261 = x1252;
}
}
int x1273 = x1259;
if (x1273) {
char *x1274 = x1261;
x1254 = 0;
} else {
char x1277 = x1260;
char *x1278 = x1261;
int x1283 = 1/*true*/;
char x1284 = '\0';
char *x1285 = 0/*null*/;
char x1279 = x1278[0];
int x1280 = x1279 == '\0';
if (x1280) {
x1285 = x1278;
} else {
int x1281 = x1279 == '\n';
if (x1281) {
x1283 = 0/*false*/;
x1284 = x1279;
char *x1282 = x1278+1;
x1285 = x1282;
} else {
x1285 = x1278;
}
}
int x1297 = x1283;
if (x1297) {
char *x1298 = x1285;
x1254 = 0;
} else {
char x1301 = x1284;
char *x1302 = x1285;
x1254 = x1302;
}
}
char *x1308 = x1254;
return x1308;
}
/*@
requires ((strlen(x1324)>=0) &&
\valid(x1324+(0..strlen(x1324))));
assigns \nothing;
ensures ((0==\result) || ((strlen(\result)>=0) &&
\valid(\result+(0..strlen(\result)))));
*/
char * p_ContentLength(char * x1324) {
char *x1326 = x1324;
int x1331 = 1/*true*/;
char x1332 = '\0';
char *x1333 = 0/*null*/;
char x1327 = x1324[0];
int x1328 = x1327 == '\0';
if (x1328) {
x1333 = x1324;
} else {
int x1329 = x1327 == 'C';
if (x1329) {
x1331 = 0/*false*/;
x1332 = x1327;
char *x1330 = x1324+1;
x1333 = x1330;
} else {
x1333 = x1324;
}
}
int x1345 = x1331;
if (x1345) {
char *x1346 = x1333;
x1326 = 0;
} else {
char x1349 = x1332;
char *x1350 = x1333;
int x1355 = 1/*true*/;
char x1356 = '\0';
char *x1357 = 0/*null*/;
char x1351 = x1350[0];
int x1352 = x1351 == '\0';
if (x1352) {
x1357 = x1350;
} else {
int x1353 = x1351 == 'o';
if (x1353) {
x1355 = 0/*false*/;
x1356 = x1351;
char *x1354 = x1350+1;
x1357 = x1354;
} else {
x1357 = x1350;
}
}
int x1369 = x1355;
if (x1369) {
char *x1370 = x1357;
x1326 = 0;
} else {
char x1373 = x1356;
char *x1374 = x1357;
int x1379 = 1/*true*/;
char x1380 = '\0';
char *x1381 = 0/*null*/;
char x1375 = x1374[0];
int x1376 = x1375 == '\0';
if (x1376) {
x1381 = x1374;
} else {
int x1377 = x1375 == 'n';
if (x1377) {
x1379 = 0/*false*/;
x1380 = x1375;
char *x1378 = x1374+1;
x1381 = x1378;
} else {
x1381 = x1374;
}
}
int x1393 = x1379;
if (x1393) {
char *x1394 = x1381;
x1326 = 0;
} else {
char x1397 = x1380;
char *x1398 = x1381;
int x1403 = 1/*true*/;
char x1404 = '\0';
char *x1405 = 0/*null*/;
char x1399 = x1398[0];
int x1400 = x1399 == '\0';
if (x1400) {
x1405 = x1398;
} else {
int x1401 = x1399 == 't';
if (x1401) {
x1403 = 0/*false*/;
x1404 = x1399;
char *x1402 = x1398+1;
x1405 = x1402;
} else {
x1405 = x1398;
}
}
int x1417 = x1403;
if (x1417) {
char *x1418 = x1405;
x1326 = 0;
} else {
char x1421 = x1404;
char *x1422 = x1405;
int x1427 = 1/*true*/;
char x1428 = '\0';
char *x1429 = 0/*null*/;
char x1423 = x1422[0];
int x1424 = x1423 == '\0';
if (x1424) {
x1429 = x1422;
} else {
int x1425 = x1423 == 'e';
if (x1425) {
x1427 = 0/*false*/;
x1428 = x1423;
char *x1426 = x1422+1;
x1429 = x1426;
} else {
x1429 = x1422;
}
}
int x1441 = x1427;
if (x1441) {
char *x1442 = x1429;
x1326 = 0;
} else {
char x1445 = x1428;
char *x1446 = x1429;
int x1451 = 1/*true*/;
char x1452 = '\0';
char *x1453 = 0/*null*/;
char x1447 = x1446[0];
int x1448 = x1447 == '\0';
if (x1448) {
x1453 = x1446;
} else {
int x1449 = x1447 == 'n';
if (x1449) {
x1451 = 0/*false*/;
x1452 = x1447;
char *x1450 = x1446+1;
x1453 = x1450;
} else {
x1453 = x1446;
}
}
int x1465 = x1451;
if (x1465) {
char *x1466 = x1453;
x1326 = 0;
} else {
char x1469 = x1452;
char *x1470 = x1453;
int x1475 = 1/*true*/;
char x1476 = '\0';
char *x1477 = 0/*null*/;
char x1471 = x1470[0];
int x1472 = x1471 == '\0';
if (x1472) {
x1477 = x1470;
} else {
int x1473 = x1471 == 't';
if (x1473) {
x1475 = 0/*false*/;
x1476 = x1471;
char *x1474 = x1470+1;
x1477 = x1474;
} else {
x1477 = x1470;
}
}
int x1489 = x1475;
if (x1489) {
char *x1490 = x1477;
x1326 = 0;
} else {
char x1493 = x1476;
char *x1494 = x1477;
int x1499 = 1/*true*/;
char x1500 = '\0';
char *x1501 = 0/*null*/;
char x1495 = x1494[0];
int x1496 = x1495 == '\0';
if (x1496) {
x1501 = x1494;
} else {
int x1497 = x1495 == '-';
if (x1497) {
x1499 = 0/*false*/;
x1500 = x1495;
char *x1498 = x1494+1;
x1501 = x1498;
} else {
x1501 = x1494;
}
}
int x1513 = x1499;
if (x1513) {
char *x1514 = x1501;
x1326 = 0;
} else {
char x1517 = x1500;
char *x1518 = x1501;
int x1523 = 1/*true*/;
char x1524 = '\0';
char *x1525 = 0/*null*/;
char x1519 = x1518[0];
int x1520 = x1519 == '\0';
if (x1520) {
x1525 = x1518;
} else {
int x1521 = x1519 == 'L';
if (x1521) {
x1523 = 0/*false*/;
x1524 = x1519;
char *x1522 = x1518+1;
x1525 = x1522;
} else {
x1525 = x1518;
}
}
int x1537 = x1523;
if (x1537) {
char *x1538 = x1525;
x1326 = 0;
} else {
char x1541 = x1524;
char *x1542 = x1525;
int x1547 = 1/*true*/;
char x1548 = '\0';
char *x1549 = 0/*null*/;
char x1543 = x1542[0];
int x1544 = x1543 == '\0';
if (x1544) {
x1549 = x1542;
} else {
int x1545 = x1543 == 'e';
if (x1545) {
x1547 = 0/*false*/;
x1548 = x1543;
char *x1546 = x1542+1;
x1549 = x1546;
} else {
x1549 = x1542;
}
}
int x1561 = x1547;
if (x1561) {
char *x1562 = x1549;
x1326 = 0;
} else {
char x1565 = x1548;
char *x1566 = x1549;
int x1571 = 1/*true*/;
char x1572 = '\0';
char *x1573 = 0/*null*/;
char x1567 = x1566[0];
int x1568 = x1567 == '\0';
if (x1568) {
x1573 = x1566;
} else {
int x1569 = x1567 == 'n';
if (x1569) {
x1571 = 0/*false*/;
x1572 = x1567;
char *x1570 = x1566+1;
x1573 = x1570;
} else {
x1573 = x1566;
}
}
int x1585 = x1571;
if (x1585) {
char *x1586 = x1573;
x1326 = 0;
} else {
char x1589 = x1572;
char *x1590 = x1573;
int x1595 = 1/*true*/;
char x1596 = '\0';
char *x1597 = 0/*null*/;
char x1591 = x1590[0];
int x1592 = x1591 == '\0';
if (x1592) {
x1597 = x1590;
} else {
int x1593 = x1591 == 'g';
if (x1593) {
x1595 = 0/*false*/;
x1596 = x1591;
char *x1594 = x1590+1;
x1597 = x1594;
} else {
x1597 = x1590;
}
}
int x1609 = x1595;
if (x1609) {
char *x1610 = x1597;
x1326 = 0;
} else {
char x1613 = x1596;
char *x1614 = x1597;
int x1619 = 1/*true*/;
char x1620 = '\0';
char *x1621 = 0/*null*/;
char x1615 = x1614[0];
int x1616 = x1615 == '\0';
if (x1616) {
x1621 = x1614;
} else {
int x1617 = x1615 == 't';
if (x1617) {
x1619 = 0/*false*/;
x1620 = x1615;
char *x1618 = x1614+1;
x1621 = x1618;
} else {
x1621 = x1614;
}
}
int x1633 = x1619;
if (x1633) {
char *x1634 = x1621;
x1326 = 0;
} else {
char x1637 = x1620;
char *x1638 = x1621;
int x1643 = 1/*true*/;
char x1644 = '\0';
char *x1645 = 0/*null*/;
char x1639 = x1638[0];
int x1640 = x1639 == '\0';
if (x1640) {
x1645 = x1638;
} else {
int x1641 = x1639 == 'h';
if (x1641) {
x1643 = 0/*false*/;
x1644 = x1639;
char *x1642 = x1638+1;
x1645 = x1642;
} else {
x1645 = x1638;
}
}
int x1657 = x1643;
if (x1657) {
char *x1658 = x1645;
x1326 = 0;
} else {
char x1661 = x1644;
char *x1662 = x1645;
x1326 = x1662;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
char *x1692 = x1326;
return x1692;
}
| 14 |
/*@ predicate allequ{L}(integer i, int *x, integer res) =
@ \forall integer j; (i <= j <= res+i-1) ==> (\at(x[i], L)==\at(x[j], L));
@*/
//Examines equality between between all elemnts in [i,i+res-1]
/*@ predicate ismax{L}(integer i, int *x, integer res,integer N) =
@ \forall integer j; (0 < j <= N-1 && j!=i) ==> (\forall integer rp; (1 < rp < N && allequ(j,x,rp)) ==> (rp <= res));
@*/
//Examines that res is the max res the you can get in length N
//For every r that satisfies allequ this r must be smaller-equal from res
/*@ predicate cond{L}(integer N, int *x, integer res) =
@ \exists integer i; (0 <= i < N-res) ==> (allequ(i,x,res) && ismax(i,x,res,N));
@*/
//For something to satisfy the given condition there must exist an integer such that for i to
// i+res-1 positions we will have equality and this will be the max length
/*@ requires N > 0;
@ requires \valid(x + (0..N-1));
@ ensures cond(N, x,\result);
@*/
int countSameConsecutive(int N, int x[]) {
int best = 0, i = 0;
// we try to maintain an essence of current best in order to reach total (best)
// for that we replace N <- i+1 (to look until i array positions)
/*@ loop invariant 0 <= i <= N;
@ loop invariant 0 <= best <= N;
@ loop invariant 0 < i <==> 0 < best;
@ loop invariant (0 < best <==> allequ(i,x,best)) || (best == 0 <==> i==0) ;
@ loop invariant (0 < best <==> ismax(i,x,best,i+1)) || (best == 0 <==> i==0);
@ loop invariant ((0 < i < N && 0 < best) <==> cond(i+1,x,best)) || (best == 0 <==> i==0);
@ loop assigns i, best;
@ loop variant N-i;
@*/
while (i < N) {
int j = i+1;
// while we are inside the second loop everything allequ for j-i
// (starting from i) matrix positions is maintained
/*@ loop invariant i+1 <= j <= N;
@ loop invariant (x[j] == x[i]) ==> allequ(i,x,j-i);
@ loop assigns j;
@ loop variant N-j;
@*/
while (j < N && x[j] == x[i]) ++j;
if (j-i > best) best = j-i;
i = j;
}
return best;
}
| 34 |
#include <string.h>
/*@
logic integer d(integer c) = (0 <= c - '0' <= 9) ? c - '0' : -1;
logic integer e(integer i) = (0 <= i <= 9) ? i + '0' : ' ';
*/
/*@
assigns \nothing;
ensures -1<=\result<=9;
ensures d(c)==\result;
*/
int d(char c) {
return ('0' <= c && c <= '9') ? c - '0' : -1;
}
/*@
assigns \nothing;
ensures '0'<=\result<='9' || \result==' ';
ensures e(i)==\result;
*/
char e(int i) {
return (0 <= i && i <= 9) ? i + '0' : ' ';
}
/*@
assigns \nothing;
ensures '0'<=c<='9' ==> \result==c;
ensures c!=\result ==> \result==' ';
ensures e(d(c))==\result;
*/
char ed(char c) {
return e(d(c));
}
/*@
assigns \nothing;
ensures 0<=i<=9 ==> \result==i;
ensures i!=\result ==> \result==-1;
ensures d(e(i))==\result;
*/
int de(int i) {
return d(e(i));
}
/*@
assigns \nothing;
ensures d(e(d(c)))==d(c);
*/
int ded(char c) {
return d(e(d(c)));
}
/*@
assigns \nothing;
ensures e(d(e(i)))==e(i);
*/
char ede(int i) {
return e(d(e(i)));
}
| 57 |
/*@
// Invariant and equality spec for Vector[Char]
predicate spec_Inv_VC(char *a1, int n) =
n==0 || (n>0 && \valid(a1+(0..n-1)));
predicate spec_Eq_VC(char *a1, char *a2, int n1, int n2) =
(n1==n2) &&
(\forall int j; (0<=j<n1) ==> a1[j] == a2[j]);
// Invariant and equality spec for Vector[Vector[Char]]
predicate spec_Inv_VVC(char **a1, int *an1, int n) =
n==0 || (n>0 && \valid(a1+(0..n-1)) && \valid(an1+(0..n-1))) &&
(\forall int j; (0<=j<n) ==> spec_Inv_VC(a1[j],an1[j]));
predicate spec_Eq_VVC(char **a1, char **a2, int *an1, int *an2, int n1, int n2) =
(n1==n2) &&
(\forall int j; (0<=j<n1) ==> spec_Eq_VC(a1[j],a2[j],an1[j],an2[j]));
*/
// Contract and implementation for Vector[Char] equality
/*@ requires spec_Inv_VC(a1,n1) && spec_Inv_VC(a2,n2);
ensures (\result == 1) || (\result == 0);
ensures (\result == 1) <==> spec_Eq_VC(a1,a2,n1,n2);
ensures (\result == 0) <==> !spec_Eq_VC(a1,a2,n1,n2);
assigns \nothing; */
int eq_VC(char *a1, char *a2, int n1, int n2) {
if (n1 != n2) return 0;
/*@ loop invariant (0 <= i <= n1);
loop invariant \forall int j; (0 <= j < i) ==> a1[j]==a2[j];
loop assigns i;
loop variant (n1-i); */
for (int i = 0; i < n1; i++) {
if (a1[i] != a2[i]) return 0;
}
return 1;
}
// Contract and implementation for Vector[Vector[Char]] equality
/*@ requires spec_Inv_VVC(a1,an1,n1) && spec_Inv_VVC(a2,an2,n2);
ensures (\result == 1) || (\result == 0);
ensures (\result == 1) <==> spec_Eq_VVC(a1,a2,an1,an2,n1,n2);
ensures (\result == 0) <==> !spec_Eq_VVC(a1,a2,an1,an2,n1,n2);
assigns \nothing; */
int eq_VVC(char **a1, char **a2, int *an1, int *an2, int n1, int n2) {
if (n1 != n2) return 0;
/*@ loop invariant (0 <= i <= n1);
loop invariant \forall int j; (0 <= j < i) ==> spec_Eq_VC(a1[j],a2[j],an1[j],an2[j]);
loop assigns i;
loop variant (n1-i); */
for (int i = 0; i < n1; i++) {
if (eq_VC(a1[i],a2[i],an1[i],an2[i]) != 1) return 0;
}
return 1;
}
| 46 |
#include <limits.h>
/*@ predicate inv_vec_Int(int * x0, int x1) = ((x1==0) || ((x1>0) &&
\valid(x0+(0..x1-1))));*/
/*@ predicate eq_vec_Int(int * x16, int x17, int * x18, int x19) = ((x17==x19) &&
(\forall int x23; (0<=x23<x17) ==> (x16[x23]==x18[x23])));*/
/*@
requires (inv_vec_Int(x16,x17) &&
inv_vec_Int(x18,x19));
assigns \nothing;
ensures (inv_vec_Int(x16,x17) &&
inv_vec_Int(x18,x19));
ensures \result <==> eq_vec_Int(x16, x17, x18, x19);
*/
int eq_vec_Int(int * x16, int x17, int * x18, int x19) {
int x21 = x17 == x19;
int x33;
if (x21) {
int x32 = 1;
/*@ loop invariant (0 <= x24 <= x17);
loop invariant \forall int x23; (0 <= x23 < x24) ==> (x16[x23]==x18[x23]);
loop assigns x24;
loop variant (x17-x24); */
for (int x24 = 0; x24 < x17; x24++) {
int x29 = x16[x24];
int x30 = x18[x24];
int x31 = x29 == x30;
if (!x31) { x32 = 0; break; }
}
x33 = x32;
} else {
x33 = 0/*false*/;
}
return x33;
}
/*@ predicate inv_vec_vec_Int(int * * x37, int * x38, int x39) = (((x39==0) || ((x39>0) &&
(\valid(x37+(0..x39-1)) &&
\valid(x38+(0..x39-1))))) &&
(\forall int x49; (0<=x49<x39) ==> inv_vec_Int(x37[x49],x38[x49])));*/
/*@ predicate eq_vec_vec_Int(int * * x61, int * x62, int x63, int * * x64, int * x65, int x66) = ((x63==x66) &&
(\forall int x70; (0<=x70<x63) ==> eq_vec_Int(x61[x70],x62[x70],x64[x70],x65[x70])));*/
/*@
requires (inv_vec_vec_Int(x61,x62,x63) &&
inv_vec_vec_Int(x64,x65,x66));
assigns \nothing;
ensures (inv_vec_vec_Int(x61,x62,x63) &&
inv_vec_vec_Int(x64,x65,x66));
ensures \result <==> eq_vec_vec_Int(x61, x62, x63, x64, x65, x66);
*/
int eq_vec_vec_Int(int * * x61, int * x62, int x63, int * * x64, int * x65, int x66) {
int x68 = x63 == x66;
int x84;
if (x68) {
int x83 = 1;
/*@ loop invariant (0 <= x71 <= x63);
loop invariant \forall int x70; (0 <= x70 < x71) ==> eq_vec_Int(x61[x70],x62[x70],x64[x70],x65[x70]);
loop assigns x71;
loop variant (x63-x71); */
for (int x71 = 0; x71 < x63; x71++) {
int *x78 = x61[x71];
int x79 = x62[x71];
int *x80 = x64[x71];
int x81 = x65[x71];
int x82 = eq_vec_Int(x78,x79,x80,x81);
if (!x82) { x83 = 0; break; }
}
x84 = x83;
} else {
x84 = 0/*false*/;
}
return x84;
}
| 44 |
#include<limits.h>
#include<string.h>
/*@
predicate star_A(char* s, integer i, integer j) =
i==j || (j>i && (s[i]=='A' && star_A(s, i+1, j)));
predicate match_aapb(char* s, integer i, integer j) =
s[i]=='A' && \exists integer m; i<m<j && star_A(s,i+1,m) && s[m]=='B' && s[m+1]=='\0' && m+1==j;
predicate bwd0(char* s, integer i, integer j) = i>=j;
predicate bwd1(char* s, integer i, integer j) = s[i]=='A' && \exists integer m; i<m<=j && star_A(s,i+1,m) && m>=j;
predicate bwd2(char* s, integer i, integer j) =
s[i]=='A' && \exists integer m; i<m<j && star_A(s,i+1,m) && s[m]=='B' && m+1>=j;
*/
/*@
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires strlen(s)<=INT_MAX;
requires 0<=i<=j<=strlen(s);
requires star_A(s, i, j);
ensures \forall integer m; 0<=i<=m<j ==> s[m]=='A';
assigns \nothing;
*/
void lemma_star_A_all(char* s, int i, int j) {
int x = i;
/*@
loop invariant 0 <= i <= x <= j <= strlen(s);
loop invariant star_A(s, x, j);
loop invariant \forall integer m; i<=m<x ==> s[m]=='A';
loop assigns x;
loop variant j-x;
*/
while (x < j) {
x++;
}
}
/*@
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires strlen(s)<=INT_MAX;
requires 0<=i<=j<=strlen(s);
requires \forall integer m; 0<=i<=m<j ==> s[m]=='A';
ensures star_A(s, i, j);
assigns \nothing;
*/
void lemma_all_star_A(char* s, int i, int j) {
int x = j;
/*@
loop invariant 0 <= i <= x <= j <= strlen(s);
loop invariant star_A(s, x, j);
loop invariant \forall integer m; 0<=i<=m<j ==> s[m]=='A';
loop assigns x;
loop variant x;
*/
while (i < x) {
x--;
}
}
/*@
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires strlen(s)<=INT_MAX;
requires 0<=i<=m<j<=strlen(s);
requires s[m]!='A';
ensures !star_A(s, i, j);
assigns \nothing;
*/
void lemma_star_A_not(char* s, int i, int m, int j) {
int x = m;
/*@
loop invariant 0<=i<=x<=m<j;
loop invariant !star_A(s, x, j);
loop assigns x;
loop variant x;
*/
while (i < x) {
x--;
}
}
/*@
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires strlen(s)<=INT_MAX;
requires 0<=i<=strlen(s);
requires 0<=j<=strlen(s);
requires i<j;
requires star_A(s, i, j);
ensures star_A(s, i, j-1);
assigns \nothing;
*/
void lemma_star_A_dec(char* s, int i, int j) {
//@ghost lemma_star_A_all(s, i, j);
//@ghost lemma_all_star_A(s, i, j-1);
}
/*@
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires strlen(s)<=INT_MAX;
requires 0<=i<=j<=n<=strlen(s);
requires star_A(s, i, j);
requires star_A(s, j, n);
ensures star_A(s, i, n);
assigns \nothing;
*/
void lemma_star_A(char* s, int i, int j, int n) {
int x = j;
/*@
loop invariant 0 <= i <= x <= j <= n <= strlen(s);
loop invariant star_A(s, x, n);
loop invariant star_A(s, i, x);
loop assigns x;
loop variant x;
*/
while (i < x) {
//@ghost lemma_star_A_dec(s, i, x);
//@assert i<x;
//@ghost lemma_star_A_all(s, i, x);
//@assert s[x-1]=='A';
//@assert star_A(s, x, n);
//@assert star_A(s, x-1, n);
x--;
}
}
/*@
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires strlen(s)<=INT_MAX;
requires 0<=i<=strlen(s);
requires 0<=j<=strlen(s);
requires i<=j;
requires bwd0(s, 0, j);
requires s[j]=='A';
ensures bwd1(s, 0, j+1);
assigns \nothing;
*/
void lemma01(char* s, int i, int j) {
//@assert j==0;
//@assert star_A(s, j+1, j+1);
}
/*@
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires strlen(s)<=INT_MAX;
requires 0<=i<=strlen(s);
requires 0<=j<=strlen(s);
requires i<=j;
requires bwd1(s, 0, j);
requires s[j]=='A';
ensures bwd1(s, 0, j+1);
assigns \nothing;
*/
void lemma11(char* s, int i, int j) {
//@assert s[0]=='A';
//@assert star_A(s, 1, j);
//@assert s[j]=='A';
//@assert star_A(s, j+1, j+1);
//@ghost lemma_star_A(s, 1, j, j+1);
//@assert star_A(s, 1, j+1);
}
/*@
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires strlen(s)<=INT_MAX;
requires 0<=i<=strlen(s);
requires 0<=j<=strlen(s);
requires bwd1(s, i, j);
requires s[j]=='B';
ensures bwd2(s, i, j+1);
assigns \nothing;
*/
void lemma12(char* s, int i, int j) {
//@assert bwd1(s, i, j);
//@assert s[i]=='A';
//@assert star_A(s, i+1, j);
//@assert s[j]=='B';
//@assert bwd2(s, i, j+1);
}
/*@
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires strlen(s)<=INT_MAX;
requires 0<=i<=strlen(s);
requires 0<=j<=strlen(s);
requires bwd2(s, i, j);
ensures s[j]=='\0' ==> match_aapb(s, i, j);
assigns \nothing;
*/
void lemma2f(char* s, int i, int j) {
//@assert bwd2(s, i, j);
//@assert s[i]=='A';
//@assert star_A(s, i+1, j-1);
//@assert s[j-1]=='B';
//@assert s[j]=='\0' ==> match_aapb(s, i, j);
}
/*@
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires strlen(s)<=INT_MAX;
ensures match_aapb(s, 0, strlen(s)) ==> \result==1;
ensures \result==1 ==> match_aapb(s, 0, strlen(s));
assigns \nothing;
*/
int m_aapb(char* s) {
char* cur = s;
int id = 0;
int m = 1;
//@ghost int i = 0;
/*@
loop invariant strlen(s)>=0 && \valid(s+(0..strlen(s)));
loop invariant strlen(cur)>=0 && \valid(cur+(0..strlen(cur)));
loop invariant 0<=i<=strlen(s);
loop invariant (id == 0) && m ==> bwd0(s, 0, i);
loop invariant (id == 1) && m ==> bwd1(s, 0, i);
loop invariant (id == 2) && m ==> bwd2(s, 0, i);
loop invariant (m == 0) ==> !bwd0(s, 0, i) && !bwd1(s, 0, i) && !bwd2(s, 0, i);
loop invariant (id == 0) && !m ==> s[0]!='A';
loop invariant (id == 1) && !m ==> s[i-1]!='A' && s[i-1]!='B';
loop invariant (id == 2) && !m ==> s[i-2]=='B';
loop invariant (id == 0) && !m ==> bwd0(s, 0, i-1);
loop invariant (id == 1) && !m ==> bwd1(s, 0, i-1);
loop invariant (id == 2) && !m ==> bwd2(s, 0, i-1);
loop invariant (id == 2) && cur[0]=='\0' && m ==> match_aapb(s, 0, i);
loop invariant (id != 2) || cur[0]!='\0' || !m ==> !match_aapb(s, 0, i);
loop invariant (id == 0) || (id == 1) || (id == 2);
loop invariant cur==s+i;
loop invariant cur[0]==s[i];
loop assigns cur, id, i, m;
loop variant strlen(cur);
*/
while (cur[0]!='\0' && m) {
m = 0;
if (id == 0) {
//@assert (id == 0) ==> bwd0(s, 0, i);
//@assert bwd0(s, 0, i);
//@assert i==0;
if (cur[0] == 'A') {
id = 1;
//@ghost lemma01(s, 0, i);
//@assert bwd1(s, 0, i+1);
m = 1;
} else {
//@assert !bwd0(s, 0, i+1) && !bwd1(s, 0, i+1) && !bwd2(s, 0, i+1);
}
} else if (id == 1) {
//@assert (id == 1) ==> bwd1(s, 0, i);
//@assert bwd1(s, 0, i);
if (cur[0] == 'A') {
//@ghost lemma11(s, 0, i);
id = 1;
//@assert bwd1(s, 0, i+1);
m = 1;
} else if (cur[0] == 'B') {
//@ghost lemma12(s, 0, i);
id = 2;
//@assert bwd2(s, 0, i+1);
//@ghost lemma2f(s, 0, i+1);
m = 1;
} else {
//@assert !bwd0(s, 0, i+1);
//@assert s[i]!='A';
//@ghost lemma_star_A_not(s, 1, i, i+1);
//@assert !bwd1(s, 0, i+1);
//@assert !bwd2(s, 0, i+1);
}
} else if (id == 2) {
//@assert (id == 2) ==> bwd2(s, 0, i);
//@assert bwd2(s, 0, i);
//@assert !bwd0(s, 0, i+1);
//@assert s[i-1]!='A';
//@ghost lemma_star_A_not(s, 1, i-1, i+1);
//@assert !star_A(s, 1, i+1);
//@assert !bwd1(s, 0, i+1);
//@ghost lemma_star_A_not(s, 1, i-1, i);
//@assert !star_A(s, 1, i);
//@assert !bwd2(s, 0, i+1);
} else {
//@assert \false;
}
cur++;
//@ghost i++;
}
int res = id==2 && cur[0]=='\0' && m;
/*@ghost
if (!res) {
if (!m) {
//@assert i>=1;
//@assert !match_aapb(s, 0, i);
//@assert !bwd2(s, 0, i);
int x = i;
int j = strlen(s);
if (id==0) {
//@assert s[0]!='A';
//@assert !bwd2(s, 0, j);
} else if (id==1) {
//@assert s[i-1]!='A' && s[i-1]!='B';
//@assert s[i-1]!='A';
if (i-1<j-1) {
//@ghost lemma_star_A_not(s, 1, i-1, j-1);
} else {
//@assert i==j;
}
//@assert !bwd2(s, 0, j);
} else if (id==2) {
//@assert s[i-2]=='B';
//@assert s[i-2]!='A';
//@ghost lemma_star_A_not(s, 1, i-2, j-1);
//@assert !bwd2(s, 0, j);
}
//@assert !bwd2(s, 0, strlen(s));
//@assert !match_aapb(s, 0, strlen(s));
}
}
*/
return res;
}
| 283 |
#include <limits.h>
#include <string.h>
char * p_chunked(char * x1637);
char * p_(char * x1639);
char * p_TransferEncoding(char * x1641);
char * p_ContentLength(char * x1643);
char * p_HTTP(char * x1645);
/*@
requires ((strlen(x0)>=0) &&
\valid(x0+(0..(strlen(x0)+1)-1)));
assigns \nothing;
*/
int p(char * x0) {
int x2 = -1;
char *x3 = p_HTTP(x0);
int x5 = 1/*true*/;
int x6 = 0;
char *x7 = 0/*null*/;
int x8 = 1/*true*/;
int x9 = 0;
char *x10 = 0/*null*/;
int x11 = 1/*true*/;
int x12 = 0;
char *x13 = 0/*null*/;
int x14 = 1/*true*/;
int x15 = 0;
char *x16 = 0/*null*/;
int x17 = 1/*true*/;
char *x19 = 0/*null*/;
int x20 = 1/*true*/;
char *x22 = 0/*null*/;
int x23 = 1/*true*/;
char x24 = '\0';
char *x25 = 0/*null*/;
int x26 = 1/*true*/;
char *x28 = 0/*null*/;
int x29 = 1/*true*/;
char *x31 = 0/*null*/;
int x32 = 0 == x3;
if (x32) {
x31 = x0;
} else {
x29 = 0/*false*/;
x31 = x3;
}
int x40 = x29;
if (x40) {
char *x41 = x31;
x28 = x41;
} else {
char *x45 = x31;
int x52 = 1/*true*/;
char x53 = '\0';
char *x54 = 0/*null*/;
char x46 = x45[0];
int x47 = x46 == '\0';
if (x47) {
x54 = x45;
} else {
int x48 = x46 >= '0';
int x50;
if (x48) {
int x49 = x46 <= '9';
x50 = x49;
} else {
x50 = 0/*false*/;
}
if (x50) {
x52 = 0/*false*/;
x53 = x46;
char *x51 = x45+1;
x54 = x51;
} else {
x54 = x45;
}
}
int x66 = x52;
if (x66) {
char *x67 = x54;
x28 = x67;
} else {
char x70 = x53;
char *x71 = x54;
char *x72 = x71;
int x73 = 1/*true*/;
/*@
loop invariant ((strlen(x72)>=0) &&
\valid(x72+(0..(strlen(x72)+1)-1)));
loop assigns x72, x73;
*/
for (;;) {
int x74 = x73;
if (!x74) break;
char *x76 = x72;
char x77 = x76[0];
int x78 = x77 == '\0';
if (x78) {
x73 = 0/*false*/;
} else {
int x79 = x77 >= '0';
int x81;
if (x79) {
int x80 = x77 <= '9';
x81 = x80;
} else {
x81 = 0/*false*/;
}
if (x81) {
char *x82 = x76+1;
x72 = x82;
} else {
x73 = 0/*false*/;
}
}
}
char *x108 = x72;
x26 = 0/*false*/;
x28 = x108;
}
}
int x116 = x26;
if (x116) {
char *x117 = x28;
x25 = x117;
} else {
char *x121 = x28;
char x122 = x121[0];
int x123 = x122 == '\0';
if (x123) {
x25 = x121;
} else {
int x124 = x122 == '.';
if (x124) {
x23 = 0/*false*/;
x24 = x122;
char *x125 = x121+1;
x25 = x125;
} else {
x25 = x121;
}
}
}
int x139 = x23;
if (x139) {
char *x140 = x25;
x22 = x140;
} else {
char x143 = x24;
char *x144 = x25;
int x151 = 1/*true*/;
char x152 = '\0';
char *x153 = 0/*null*/;
char x145 = x144[0];
int x146 = x145 == '\0';
if (x146) {
x153 = x144;
} else {
int x147 = x145 >= '0';
int x149;
if (x147) {
int x148 = x145 <= '9';
x149 = x148;
} else {
x149 = 0/*false*/;
}
if (x149) {
x151 = 0/*false*/;
x152 = x145;
char *x150 = x144+1;
x153 = x150;
} else {
x153 = x144;
}
}
int x165 = x151;
if (x165) {
char *x166 = x153;
x22 = x166;
} else {
char x169 = x152;
char *x170 = x153;
char *x171 = x170;
int x172 = 1/*true*/;
/*@
loop invariant ((strlen(x171)>=0) &&
\valid(x171+(0..(strlen(x171)+1)-1)));
loop assigns x171, x172;
*/
for (;;) {
int x173 = x172;
if (!x173) break;
char *x175 = x171;
char x176 = x175[0];
int x177 = x176 == '\0';
if (x177) {
x172 = 0/*false*/;
} else {
int x178 = x176 >= '0';
int x180;
if (x178) {
int x179 = x176 <= '9';
x180 = x179;
} else {
x180 = 0/*false*/;
}
if (x180) {
char *x181 = x175+1;
x171 = x181;
} else {
x172 = 0/*false*/;
}
}
}
char *x207 = x171;
x20 = 0/*false*/;
x22 = x207;
}
}
int x215 = x20;
if (x215) {
char *x216 = x22;
x19 = x216;
} else {
char *x220 = x22;
char *x221 = x220;
int x222 = 1/*true*/;
/*@
loop invariant ((strlen(x221)>=0) &&
\valid(x221+(0..(strlen(x221)+1)-1)));
loop assigns x221, x222;
*/
for (;;) {
int x223 = x222;
if (!x223) break;
char *x225 = x221;
char x226 = x225[0];
int x227 = x226 == '\0';
if (x227) {
x222 = 0/*false*/;
} else {
int x228 = x226 == ' ';
if (x228) {
char *x229 = x225+1;
x221 = x229;
} else {
x222 = 0/*false*/;
}
}
}
char *x255 = x221;
x17 = 0/*false*/;
x19 = x255;
}
int x261 = x17;
if (x261) {
char *x262 = x19;
x16 = x262;
} else {
char *x266 = x19;
int x273 = 1/*true*/;
int x274 = 0;
char *x275 = 0/*null*/;
int x276 = 1/*true*/;
char x277 = '\0';
char *x278 = 0/*null*/;
char x267 = x266[0];
int x268 = x267 == '\0';
if (x268) {
x278 = x266;
} else {
int x269 = x267 >= '0';
int x271;
if (x269) {
int x270 = x267 <= '9';
x271 = x270;
} else {
x271 = 0/*false*/;
}
if (x271) {
x276 = 0/*false*/;
x277 = x267;
char *x272 = x266+1;
x278 = x272;
} else {
x278 = x266;
}
}
int x290 = x276;
if (x290) {
char *x291 = x278;
x275 = x291;
} else {
char x294 = x277;
char *x296 = x278;
x273 = 0/*false*/;
char x295 = x294 - '0';
x274 = x295;
x275 = x296;
}
int x302 = x273;
if (x302) {
char *x303 = x275;
x16 = x303;
} else {
int x306 = x274;
char *x307 = x275;
char *x308 = x307;
int x309 = 1/*true*/;
int x310 = x306;
int x343 = INT_MAX;
int x344 = x343 / 10;
int x345 = x344 - 10;
/*@
loop invariant (((strlen(x308)>=0) &&
\valid(x308+(0..(strlen(x308)+1)-1))) &&
((x310==-1) || (0<=x310)));
loop assigns x308, x309, x310;
*/
for (;;) {
int x311 = x309;
if (!x311) break;
char *x313 = x308;
int x320 = 1/*true*/;
char x321 = '\0';
char *x322 = 0/*null*/;
char x314 = x313[0];
int x315 = x314 == '\0';
if (x315) {
x322 = x313;
} else {
int x316 = x314 >= '0';
int x318;
if (x316) {
int x317 = x314 <= '9';
x318 = x317;
} else {
x318 = 0/*false*/;
}
if (x318) {
x320 = 0/*false*/;
x321 = x314;
char *x319 = x313+1;
x322 = x319;
} else {
x322 = x313;
}
}
int x334 = x320;
if (x334) {
char *x335 = x322;
x309 = 0/*false*/;
} else {
char x338 = x321;
char *x340 = x322;
int x341 = x310;
int x342 = x341 < 0;
int x350;
if (x342) {
x350 = x341;
} else {
int x346 = x341 > x345;
int x349;
if (x346) {
x349 = -1;
} else {
char x339 = x338 - '0';
int x347 = x341 * 10;
int x348 = x347 + x339;
x349 = x348;
}
x350 = x349;
}
x310 = x350;
x308 = x340;
}
}
int x378 = x310;
char *x379 = x308;
x14 = 0/*false*/;
x15 = x378;
x16 = x379;
}
}
int x387 = x14;
if (x387) {
char *x388 = x16;
x13 = x388;
} else {
int x391 = x15;
char *x392 = x16;
char *x393 = x392;
int x394 = 1/*true*/;
/*@
loop invariant ((strlen(x393)>=0) &&
\valid(x393+(0..(strlen(x393)+1)-1)));
loop assigns x393, x394;
*/
for (;;) {
int x395 = x394;
if (!x395) break;
char *x397 = x393;
char x398 = x397[0];
int x399 = x398 == '\0';
if (x399) {
x394 = 0/*false*/;
} else {
int x404 = x398 == '\r';
if (x404) {
x394 = 0/*false*/;
} else {
char *x401 = x397+1;
x393 = x401;
}
}
}
char *x428 = x393;
int x429 = 1/*true*/;
char *x431 = 0/*null*/;
x429 = 0/*false*/;
x431 = x428;
int x435 = x429;
if (x435) {
char *x436 = x431;
x13 = x436;
} else {
char *x440 = x431;
char *x441 = p_(x440);
int x443 = 1/*true*/;
char *x445 = 0/*null*/;
int x446 = 0 == x441;
if (x446) {
x445 = x440;
} else {
x443 = 0/*false*/;
x445 = x441;
}
int x454 = x443;
if (x454) {
char *x455 = x445;
x13 = x455;
} else {
char *x459 = x445;
x11 = 0/*false*/;
x12 = x391;
x13 = x459;
}
}
}
int x469 = x11;
if (x469) {
char *x470 = x13;
x10 = x470;
} else {
int x473 = x12;
char *x474 = x13;
char *x475 = x474;
int x476 = 1/*true*/;
int x477 = 0;
int x343 = INT_MAX;
int x344 = x343 / 10;
int x345 = x344 - 10;
int x1122 = -2 == -2;
/*@
loop invariant ((strlen(x475)>=0) &&
\valid(x475+(0..(strlen(x475)+1)-1)));
loop assigns x475, x476, x477;
*/
for (;;) {
int x478 = x476;
if (!x478) break;
char *x480 = x475;
char *x481 = p_ContentLength(x480);
int x483 = 1/*true*/;
int x484 = 0;
char *x485 = 0/*null*/;
int x486 = 1/*true*/;
int x487 = 0;
char *x488 = 0/*null*/;
int x489 = 1/*true*/;
int x490 = 0;
char *x491 = 0/*null*/;
int x492 = 1/*true*/;
int x493 = 0;
char *x494 = 0/*null*/;
int x495 = 1/*true*/;
int x496 = 0;
char *x497 = 0/*null*/;
int x498 = 1/*true*/;
int x499 = 0;
char *x500 = 0/*null*/;
int x501 = 1/*true*/;
char *x503 = 0/*null*/;
int x504 = 0 == x481;
if (x504) {
x503 = x480;
} else {
x501 = 0/*false*/;
x503 = x481;
}
int x512 = x501;
if (x512) {
char *x513 = x503;
} else {
char *x516 = x503;
x498 = 0/*false*/;
x499 = 1;
x500 = x516;
}
int x522 = x498;
if (x522) {
char *x523 = p_TransferEncoding(x480);
int x525 = 1/*true*/;
char *x527 = 0/*null*/;
int x528 = 0 == x523;
if (x528) {
x527 = x480;
} else {
x525 = 0/*false*/;
x527 = x523;
}
int x536 = x525;
if (x536) {
char *x537 = x527;
} else {
char *x540 = x527;
x495 = 0/*false*/;
x496 = 2;
x497 = x540;
}
} else {
int x547 = x499;
char *x548 = x500;
x495 = 0/*false*/;
x496 = x547;
x497 = x548;
}
int x554 = x495;
if (x554) {
char *x555 = x480;
int x556 = 1/*true*/;
/*@
loop invariant ((strlen(x555)>=0) &&
\valid(x555+(0..(strlen(x555)+1)-1)));
loop assigns x555, x556;
*/
for (;;) {
int x557 = x556;
if (!x557) break;
char *x559 = x555;
char x560 = x559[0];
int x561 = x560 == '\0';
if (x561) {
x556 = 0/*false*/;
} else {
int x563 = x560 == ':';
int x565;
if (x563) {
x565 = 0/*false*/;
} else {
int x564 = x560 != ' ';
x565 = x564;
}
if (x565) {
char *x566 = x559+1;
x555 = x566;
} else {
x556 = 0/*false*/;
}
}
}
char *x592 = x555;
x492 = 0/*false*/;
x493 = 0;
x494 = x592;
} else {
int x597 = x496;
char *x598 = x497;
x492 = 0/*false*/;
x493 = x597;
x494 = x598;
}
int x604 = x492;
if (x604) {
char *x605 = x494;
x491 = x605;
} else {
int x608 = x493;
char *x609 = x494;
char *x610 = x609;
int x611 = 1/*true*/;
/*@
loop invariant ((strlen(x610)>=0) &&
\valid(x610+(0..(strlen(x610)+1)-1)));
loop assigns x610, x611;
*/
for (;;) {
int x612 = x611;
if (!x612) break;
char *x614 = x610;
char x615 = x614[0];
int x616 = x615 == '\0';
if (x616) {
x611 = 0/*false*/;
} else {
int x617 = x615 == ' ';
if (x617) {
char *x618 = x614+1;
x610 = x618;
} else {
x611 = 0/*false*/;
}
}
}
char *x644 = x610;
x489 = 0/*false*/;
x490 = x608;
x491 = x644;
}
int x650 = x489;
if (x650) {
char *x651 = x491;
x488 = x651;
} else {
int x654 = x490;
char *x655 = x491;
int x660 = 1/*true*/;
char x661 = '\0';
char *x662 = 0/*null*/;
char x656 = x655[0];
int x657 = x656 == '\0';
if (x657) {
x662 = x655;
} else {
int x658 = x656 == ':';
if (x658) {
x660 = 0/*false*/;
x661 = x656;
char *x659 = x655+1;
x662 = x659;
} else {
x662 = x655;
}
}
int x674 = x660;
if (x674) {
char *x675 = x662;
x488 = x675;
} else {
char x678 = x661;
char *x679 = x662;
x486 = 0/*false*/;
x487 = x654;
x488 = x679;
}
}
int x687 = x486;
if (x687) {
char *x688 = x488;
x485 = x688;
} else {
int x691 = x487;
char *x692 = x488;
char *x693 = x692;
int x694 = 1/*true*/;
/*@
loop invariant ((strlen(x693)>=0) &&
\valid(x693+(0..(strlen(x693)+1)-1)));
loop assigns x693, x694;
*/
for (;;) {
int x695 = x694;
if (!x695) break;
char *x697 = x693;
char x698 = x697[0];
int x699 = x698 == '\0';
if (x699) {
x694 = 0/*false*/;
} else {
int x700 = x698 == ' ';
if (x700) {
char *x701 = x697+1;
x693 = x701;
} else {
x694 = 0/*false*/;
}
}
}
char *x727 = x693;
x483 = 0/*false*/;
x484 = x691;
x485 = x727;
}
int x733 = x483;
if (x733) {
char *x734 = x485;
x476 = 0/*false*/;
} else {
int x737 = x484;
char *x738 = x485;
char *x740 = p_chunked(x738);
char *x749 = x738;
int x750 = 1/*true*/;
/*@
loop invariant ((strlen(x749)>=0) &&
\valid(x749+(0..(strlen(x749)+1)-1)));
loop assigns x749, x750;
*/
for (;;) {
int x751 = x750;
if (!x751) break;
char *x753 = x749;
char x754 = x753[0];
int x755 = x754 == '\0';
if (x755) {
x750 = 0/*false*/;
} else {
int x760 = x754 == '\r';
if (x760) {
x750 = 0/*false*/;
} else {
char *x757 = x753+1;
x749 = x757;
}
}
}
char *x784 = x749;
int x739 = x737 == 2;
if (x739) {
int x785 = 1/*true*/;
int x786 = 0;
char *x787 = 0/*null*/;
int x788 = 1/*true*/;
int x789 = 0;
char *x790 = 0/*null*/;
int x791 = 1/*true*/;
char *x793 = 0/*null*/;
int x794 = 0 == x740;
if (x794) {
x793 = x738;
} else {
x791 = 0/*false*/;
x793 = x740;
}
int x802 = x791;
if (x802) {
char *x803 = x793;
x790 = x803;
} else {
char *x807 = x793;
x788 = 0/*false*/;
x789 = -3;
x790 = x807;
}
int x813 = x788;
if (x813) {
char *x814 = x790;
x787 = x814;
} else {
int x817 = x789;
char *x818 = x790;
char *x819 = x818;
int x820 = 1/*true*/;
/*@
loop invariant ((strlen(x819)>=0) &&
\valid(x819+(0..(strlen(x819)+1)-1)));
loop assigns x819, x820;
*/
for (;;) {
int x821 = x820;
if (!x821) break;
char *x823 = x819;
char x824 = x823[0];
int x825 = x824 == '\0';
if (x825) {
x820 = 0/*false*/;
} else {
int x826 = x824 == ' ';
if (x826) {
char *x827 = x823+1;
x819 = x827;
} else {
x820 = 0/*false*/;
}
}
}
char *x853 = x819;
x785 = 0/*false*/;
x786 = x817;
x787 = x853;
}
int x859 = x785;
if (x859) {
char *x860 = x787;
x476 = 0/*false*/;
} else {
int x863 = x786;
char *x864 = x787;
char *x865 = p_(x864);
int x867 = 1/*true*/;
char *x869 = 0/*null*/;
int x870 = 0 == x865;
if (x870) {
x869 = x864;
} else {
x867 = 0/*false*/;
x869 = x865;
}
int x878 = x867;
if (x878) {
char *x879 = x869;
x476 = 0/*false*/;
} else {
char *x883 = x869;
int x884 = x477;
int x885 = x863 == -2;
int x886;
if (x885) {
x886 = x884;
} else {
x886 = x863;
}
x477 = x886;
x475 = x883;
}
}
} else {
int x742 = x737 == 1;
if (x742) {
int x894 = 1/*true*/;
int x895 = 0;
char *x896 = 0/*null*/;
int x897 = 1/*true*/;
int x898 = 0;
char *x899 = 0/*null*/;
int x900 = 1/*true*/;
int x901 = 0;
char *x902 = 0/*null*/;
int x903 = 1/*true*/;
char x904 = '\0';
char *x905 = 0/*null*/;
char x743 = x738[0];
int x744 = x743 == '\0';
if (x744) {
x905 = x738;
} else {
int x745 = x743 >= '0';
int x747;
if (x745) {
int x746 = x743 <= '9';
x747 = x746;
} else {
x747 = 0/*false*/;
}
if (x747) {
x903 = 0/*false*/;
x904 = x743;
char *x748 = x738+1;
x905 = x748;
} else {
x905 = x738;
}
}
int x917 = x903;
if (x917) {
char *x918 = x905;
x902 = x918;
} else {
char x921 = x904;
char *x923 = x905;
x900 = 0/*false*/;
char x922 = x921 - '0';
x901 = x922;
x902 = x923;
}
int x929 = x900;
if (x929) {
char *x930 = x902;
x899 = x930;
} else {
int x933 = x901;
char *x934 = x902;
char *x935 = x934;
int x936 = 1/*true*/;
int x937 = x933;
/*@
loop invariant (((strlen(x935)>=0) &&
\valid(x935+(0..(strlen(x935)+1)-1))) &&
((x937==-1) || (0<=x937)));
loop assigns x935, x936, x937;
*/
for (;;) {
int x938 = x936;
if (!x938) break;
char *x940 = x935;
int x947 = 1/*true*/;
char x948 = '\0';
char *x949 = 0/*null*/;
char x941 = x940[0];
int x942 = x941 == '\0';
if (x942) {
x949 = x940;
} else {
int x943 = x941 >= '0';
int x945;
if (x943) {
int x944 = x941 <= '9';
x945 = x944;
} else {
x945 = 0/*false*/;
}
if (x945) {
x947 = 0/*false*/;
x948 = x941;
char *x946 = x940+1;
x949 = x946;
} else {
x949 = x940;
}
}
int x961 = x947;
if (x961) {
char *x962 = x949;
x936 = 0/*false*/;
} else {
char x965 = x948;
char *x967 = x949;
int x968 = x937;
int x969 = x968 < 0;
int x974;
if (x969) {
x974 = x968;
} else {
int x970 = x968 > x345;
int x973;
if (x970) {
x973 = -1;
} else {
char x966 = x965 - '0';
int x971 = x968 * 10;
int x972 = x971 + x966;
x973 = x972;
}
x974 = x973;
}
x937 = x974;
x935 = x967;
}
}
int x1002 = x937;
char *x1003 = x935;
x897 = 0/*false*/;
x898 = x1002;
x899 = x1003;
}
int x1009 = x897;
if (x1009) {
char *x1010 = x899;
x896 = x1010;
} else {
int x1013 = x898;
char *x1014 = x899;
char *x1015 = x1014;
int x1016 = 1/*true*/;
/*@
loop invariant ((strlen(x1015)>=0) &&
\valid(x1015+(0..(strlen(x1015)+1)-1)));
loop assigns x1015, x1016;
*/
for (;;) {
int x1017 = x1016;
if (!x1017) break;
char *x1019 = x1015;
char x1020 = x1019[0];
int x1021 = x1020 == '\0';
if (x1021) {
x1016 = 0/*false*/;
} else {
int x1022 = x1020 == ' ';
if (x1022) {
char *x1023 = x1019+1;
x1015 = x1023;
} else {
x1016 = 0/*false*/;
}
}
}
char *x1049 = x1015;
x894 = 0/*false*/;
x895 = x1013;
x896 = x1049;
}
int x1055 = x894;
if (x1055) {
char *x1056 = x896;
x476 = 0/*false*/;
} else {
int x1059 = x895;
char *x1060 = x896;
char *x1061 = p_(x1060);
int x1063 = 1/*true*/;
char *x1065 = 0/*null*/;
int x1066 = 0 == x1061;
if (x1066) {
x1065 = x1060;
} else {
x1063 = 0/*false*/;
x1065 = x1061;
}
int x1074 = x1063;
if (x1074) {
char *x1075 = x1065;
x476 = 0/*false*/;
} else {
char *x1079 = x1065;
int x1080 = x477;
int x1081 = x1059 == -2;
int x1082;
if (x1081) {
x1082 = x1080;
} else {
x1082 = x1059;
}
x477 = x1082;
x475 = x1079;
}
}
} else {
int x1090 = 1/*true*/;
char *x1092 = 0/*null*/;
x1090 = 0/*false*/;
x1092 = x784;
int x1096 = x1090;
if (x1096) {
char *x1097 = x1092;
x476 = 0/*false*/;
} else {
char *x1101 = x1092;
char *x1102 = p_(x1101);
int x1104 = 1/*true*/;
char *x1106 = 0/*null*/;
int x1107 = 0 == x1102;
if (x1107) {
x1106 = x1101;
} else {
x1104 = 0/*false*/;
x1106 = x1102;
}
int x1115 = x1104;
if (x1115) {
char *x1116 = x1106;
x476 = 0/*false*/;
} else {
char *x1120 = x1106;
int x1121 = x477;
int x1123;
if (x1122) {
x1123 = x1121;
} else {
x1123 = -2;
}
x477 = x1123;
x475 = x1120;
}
}
}
}
}
}
int x1154 = x477;
char *x1155 = x475;
x8 = 0/*false*/;
x9 = x1154;
x10 = x1155;
}
int x1161 = x8;
if (x1161) {
char *x1162 = x10;
x7 = x1162;
} else {
int x1165 = x9;
char *x1166 = x10;
char *x1167 = p_(x1166);
int x1169 = 1/*true*/;
char *x1171 = 0/*null*/;
int x1172 = 0 == x1167;
if (x1172) {
x1171 = x1166;
} else {
x1169 = 0/*false*/;
x1171 = x1167;
}
int x1180 = x1169;
if (x1180) {
char *x1181 = x1171;
x7 = x1181;
} else {
char *x1185 = x1171;
x5 = 0/*false*/;
x6 = x1165;
x7 = x1185;
}
}
int x1193 = x5;
if (x1193) {
char *x1194 = x7;
} else {
int x1196 = x6;
char *x1197 = x7;
char *x1199 = x1197;
int x1200 = 1/*true*/;
int x1201 = 0;
int x343 = INT_MAX;
int x1361 = x343 / 16;
int x1362 = x1361 - 16;
/*@
loop invariant (((strlen(x1199)>=0) &&
\valid(x1199+(0..(strlen(x1199)+1)-1))) &&
((x1201==-1) || (0<=x1201)));
loop assigns x1199, x1200, x1201;
*/
for (;;) {
int x1202 = x1200;
if (!x1202) break;
char *x1204 = x1199;
int x1211 = 1/*true*/;
int x1212 = 0;
char *x1213 = 0/*null*/;
int x1214 = 1/*true*/;
int x1215 = 0;
char *x1216 = 0/*null*/;
int x1217 = 1/*true*/;
int x1218 = 0;
char *x1219 = 0/*null*/;
int x1220 = 1/*true*/;
int x1221 = 0;
char *x1222 = 0/*null*/;
int x1223 = 1/*true*/;
char x1224 = '\0';
char *x1225 = 0/*null*/;
char x1205 = x1204[0];
int x1206 = x1205 == '\0';
if (x1206) {
x1225 = x1204;
} else {
int x1207 = x1205 >= '0';
int x1209;
if (x1207) {
int x1208 = x1205 <= '9';
x1209 = x1208;
} else {
x1209 = 0/*false*/;
}
if (x1209) {
x1223 = 0/*false*/;
x1224 = x1205;
char *x1210 = x1204+1;
x1225 = x1210;
} else {
x1225 = x1204;
}
}
int x1237 = x1223;
if (x1237) {
char *x1238 = x1225;
} else {
char x1240 = x1224;
char *x1242 = x1225;
x1220 = 0/*false*/;
char x1241 = x1240 - '0';
x1221 = x1241;
x1222 = x1242;
}
int x1248 = x1220;
if (x1248) {
int x1252 = 1/*true*/;
char x1253 = '\0';
char *x1254 = 0/*null*/;
if (x1206) {
x1254 = x1204;
} else {
int x1249 = x1205 >= 'a';
int x1251;
if (x1249) {
int x1250 = x1205 <= 'f';
x1251 = x1250;
} else {
x1251 = 0/*false*/;
}
if (x1251) {
x1252 = 0/*false*/;
x1253 = x1205;
char *x1210 = x1204+1;
x1254 = x1210;
} else {
x1254 = x1204;
}
}
int x1266 = x1252;
if (x1266) {
char *x1267 = x1254;
x1219 = x1267;
} else {
char x1270 = x1253;
char *x1273 = x1254;
x1217 = 0/*false*/;
char x1271 = x1270 - 'a';
int x1272 = 10 + x1271;
x1218 = x1272;
x1219 = x1273;
}
} else {
int x1280 = x1221;
char *x1281 = x1222;
x1217 = 0/*false*/;
x1218 = x1280;
x1219 = x1281;
}
int x1287 = x1217;
if (x1287) {
char *x1288 = x1219;
x1216 = x1288;
} else {
int x1291 = x1218;
char *x1292 = x1219;
char *x1293 = x1292;
int x1294 = 1/*true*/;
int x1295 = x1291;
/*@
loop invariant (((strlen(x1293)>=0) &&
\valid(x1293+(0..(strlen(x1293)+1)-1))) &&
((x1295==-1) || (0<=x1295)));
loop assigns x1293, x1294, x1295;
*/
for (;;) {
int x1296 = x1294;
if (!x1296) break;
char *x1298 = x1293;
int x1305 = 1/*true*/;
int x1306 = 0;
char *x1307 = 0/*null*/;
int x1308 = 1/*true*/;
char x1309 = '\0';
char *x1310 = 0/*null*/;
char x1299 = x1298[0];
int x1300 = x1299 == '\0';
if (x1300) {
x1310 = x1298;
} else {
int x1301 = x1299 >= '0';
int x1303;
if (x1301) {
int x1302 = x1299 <= '9';
x1303 = x1302;
} else {
x1303 = 0/*false*/;
}
if (x1303) {
x1308 = 0/*false*/;
x1309 = x1299;
char *x1304 = x1298+1;
x1310 = x1304;
} else {
x1310 = x1298;
}
}
int x1322 = x1308;
if (x1322) {
char *x1323 = x1310;
} else {
char x1325 = x1309;
char *x1327 = x1310;
x1305 = 0/*false*/;
char x1326 = x1325 - '0';
x1306 = x1326;
x1307 = x1327;
}
int x1333 = x1305;
if (x1333) {
int x1337 = 1/*true*/;
char x1338 = '\0';
char *x1339 = 0/*null*/;
if (x1300) {
x1339 = x1298;
} else {
int x1334 = x1299 >= 'a';
int x1336;
if (x1334) {
int x1335 = x1299 <= 'f';
x1336 = x1335;
} else {
x1336 = 0/*false*/;
}
if (x1336) {
x1337 = 0/*false*/;
x1338 = x1299;
char *x1304 = x1298+1;
x1339 = x1304;
} else {
x1339 = x1298;
}
}
int x1351 = x1337;
if (x1351) {
char *x1352 = x1339;
x1294 = 0/*false*/;
} else {
char x1355 = x1338;
char *x1358 = x1339;
int x1359 = x1295;
int x1360 = x1359 < 0;
int x1367;
if (x1360) {
x1367 = x1359;
} else {
int x1363 = x1359 > x1362;
int x1366;
if (x1363) {
x1366 = -1;
} else {
char x1356 = x1355 - 'a';
int x1357 = 10 + x1356;
int x1364 = x1359 * 16;
int x1365 = x1364 + x1357;
x1366 = x1365;
}
x1367 = x1366;
}
x1295 = x1367;
x1293 = x1358;
}
} else {
int x1373 = x1306;
char *x1374 = x1307;
int x1375 = x1295;
int x1376 = x1375 < 0;
int x1381;
if (x1376) {
x1381 = x1375;
} else {
int x1377 = x1375 > x1362;
int x1380;
if (x1377) {
x1380 = -1;
} else {
int x1378 = x1375 * 16;
int x1379 = x1378 + x1373;
x1380 = x1379;
}
x1381 = x1380;
}
x1295 = x1381;
x1293 = x1374;
}
}
int x1409 = x1295;
char *x1410 = x1293;
x1214 = 0/*false*/;
x1215 = x1409;
x1216 = x1410;
}
int x1416 = x1214;
if (x1416) {
char *x1417 = x1216;
x1213 = x1417;
} else {
int x1420 = x1215;
char *x1421 = x1216;
char *x1422 = p_(x1421);
int x1424 = 1/*true*/;
char *x1426 = 0/*null*/;
int x1427 = 0 == x1422;
if (x1427) {
x1426 = x1421;
} else {
x1424 = 0/*false*/;
x1426 = x1422;
}
int x1435 = x1424;
if (x1435) {
char *x1436 = x1426;
x1213 = x1436;
} else {
char *x1440 = x1426;
x1211 = 0/*false*/;
x1212 = x1420;
x1213 = x1440;
}
}
int x1448 = x1211;
if (x1448) {
char *x1449 = x1213;
x1200 = 0/*false*/;
} else {
int x1452 = x1212;
char *x1453 = x1213;
int x1455 = 1/*true*/;
char *x1456 = x1453;
/*@
loop invariant ((0<=x1458) &&
((strlen(x1456)>=0) &&
\valid(x1456+(0..(strlen(x1456)+1)-1))));
loop assigns x1458, x1455, x1456;
loop variant (x1452-x1458);
*/
for(int x1458=0; x1458 < x1452; x1458++) {
int x1459 = x1455;
if (x1459) {
char *x1460 = x1456;
char x1461 = x1460[0];
int x1462 = x1461 == '\0';
if (x1462) {
x1455 = 0/*false*/;
} else {
char *x1463 = x1460+1;
x1456 = x1463;
}
} else {
}
}
int x1492 = x1455;
char *x1493 = x1456;
int x1454 = x1452 < 0;
if (x1454) {
x1200 = 0/*false*/;
} else {
int x1496 = 1/*true*/;
char *x1498 = 0/*null*/;
if (x1492) {
x1496 = 0/*false*/;
x1498 = x1493;
} else {
x1498 = x1453;
}
int x1506 = x1496;
if (x1506) {
char *x1507 = x1498;
x1200 = 0/*false*/;
} else {
char *x1511 = x1498;
int x1512 = x1201;
int x1513 = x1512 < 0;
int x1518;
if (x1513) {
x1518 = x1512;
} else {
int x1514 = x343 - x1452;
int x1515 = x1512 > x1514;
int x1517;
if (x1515) {
x1517 = -1;
} else {
int x1516 = x1512 + x1452;
x1517 = x1516;
}
x1518 = x1517;
}
x1201 = x1518;
x1199 = x1511;
}
}
}
}
int x1550 = x1201;
char *x1551 = x1199;
int x1553 = 1/*true*/;
char *x1554 = x1197;
/*@
loop invariant ((0<=x1556) &&
((strlen(x1554)>=0) &&
\valid(x1554+(0..(strlen(x1554)+1)-1))));
loop assigns x1556, x1553, x1554;
loop variant (x1196-x1556);
*/
for(int x1556=0; x1556 < x1196; x1556++) {
int x1557 = x1553;
if (x1557) {
char *x1558 = x1554;
char x1559 = x1558[0];
int x1560 = x1559 == '\0';
if (x1560) {
x1553 = 0/*false*/;
} else {
char *x1561 = x1558+1;
x1554 = x1561;
}
} else {
}
}
int x1590 = x1553;
char *x1591 = x1554;
int x1198 = x1196 == -3;
if (x1198) {
char x1592 = x1551[0];
int x1593 = x1592 == '\0';
if (x1593) {
x2 = x1550;
} else {
}
} else {
int x1552 = x1196 < 0;
if (x1552) {
} else {
int x1598 = 1/*true*/;
char *x1600 = 0/*null*/;
if (x1590) {
x1598 = 0/*false*/;
x1600 = x1591;
} else {
x1600 = x1197;
}
int x1608 = x1598;
if (x1608) {
char *x1609 = x1600;
} else {
char *x1612 = x1600;
char x1613 = x1612[0];
int x1614 = x1613 == '\0';
if (x1614) {
x2 = x1196;
} else {
}
}
}
}
}
int x1626 = x2;
return x1626;
}
/*@
requires ((strlen(x1647)>=0) &&
\valid(x1647+(0..(strlen(x1647)+1)-1)));
assigns \nothing;
ensures ((0==\result) || ((strlen(\result)>=0) &&
\valid(\result+(0..(strlen(\result)+1)-1))));
*/
char * p_HTTP(char * x1647) {
char *x1649 = x1647;
int x1654 = 1/*true*/;
char x1655 = '\0';
char *x1656 = 0/*null*/;
char x1650 = x1647[0];
int x1651 = x1650 == '\0';
if (x1651) {
x1656 = x1647;
} else {
int x1652 = x1650 == 'H';
if (x1652) {
x1654 = 0/*false*/;
x1655 = x1650;
char *x1653 = x1647+1;
x1656 = x1653;
} else {
x1656 = x1647;
}
}
int x1668 = x1654;
if (x1668) {
char *x1669 = x1656;
x1649 = 0;
} else {
char x1672 = x1655;
char *x1673 = x1656;
int x1678 = 1/*true*/;
char x1679 = '\0';
char *x1680 = 0/*null*/;
char x1674 = x1673[0];
int x1675 = x1674 == '\0';
if (x1675) {
x1680 = x1673;
} else {
int x1676 = x1674 == 'T';
if (x1676) {
x1678 = 0/*false*/;
x1679 = x1674;
char *x1677 = x1673+1;
x1680 = x1677;
} else {
x1680 = x1673;
}
}
int x1692 = x1678;
if (x1692) {
char *x1693 = x1680;
x1649 = 0;
} else {
char x1696 = x1679;
char *x1697 = x1680;
int x1702 = 1/*true*/;
char x1703 = '\0';
char *x1704 = 0/*null*/;
char x1698 = x1697[0];
int x1699 = x1698 == '\0';
if (x1699) {
x1704 = x1697;
} else {
int x1700 = x1698 == 'T';
if (x1700) {
x1702 = 0/*false*/;
x1703 = x1698;
char *x1701 = x1697+1;
x1704 = x1701;
} else {
x1704 = x1697;
}
}
int x1716 = x1702;
if (x1716) {
char *x1717 = x1704;
x1649 = 0;
} else {
char x1720 = x1703;
char *x1721 = x1704;
int x1726 = 1/*true*/;
char x1727 = '\0';
char *x1728 = 0/*null*/;
char x1722 = x1721[0];
int x1723 = x1722 == '\0';
if (x1723) {
x1728 = x1721;
} else {
int x1724 = x1722 == 'P';
if (x1724) {
x1726 = 0/*false*/;
x1727 = x1722;
char *x1725 = x1721+1;
x1728 = x1725;
} else {
x1728 = x1721;
}
}
int x1740 = x1726;
if (x1740) {
char *x1741 = x1728;
x1649 = 0;
} else {
char x1744 = x1727;
char *x1745 = x1728;
int x1750 = 1/*true*/;
char x1751 = '\0';
char *x1752 = 0/*null*/;
char x1746 = x1745[0];
int x1747 = x1746 == '\0';
if (x1747) {
x1752 = x1745;
} else {
int x1748 = x1746 == '/';
if (x1748) {
x1750 = 0/*false*/;
x1751 = x1746;
char *x1749 = x1745+1;
x1752 = x1749;
} else {
x1752 = x1745;
}
}
int x1764 = x1750;
if (x1764) {
char *x1765 = x1752;
x1649 = 0;
} else {
char x1768 = x1751;
char *x1769 = x1752;
x1649 = x1769;
}
}
}
}
}
char *x1781 = x1649;
return x1781;
}
/*@
requires ((strlen(x1803)>=0) &&
\valid(x1803+(0..(strlen(x1803)+1)-1)));
assigns \nothing;
ensures ((0==\result) || ((strlen(\result)>=0) &&
\valid(\result+(0..(strlen(\result)+1)-1))));
*/
char * p_(char * x1803) {
char *x1805 = x1803;
int x1810 = 1/*true*/;
char x1811 = '\0';
char *x1812 = 0/*null*/;
char x1806 = x1803[0];
int x1807 = x1806 == '\0';
if (x1807) {
x1812 = x1803;
} else {
int x1808 = x1806 == '\r';
if (x1808) {
x1810 = 0/*false*/;
x1811 = x1806;
char *x1809 = x1803+1;
x1812 = x1809;
} else {
x1812 = x1803;
}
}
int x1824 = x1810;
if (x1824) {
char *x1825 = x1812;
x1805 = 0;
} else {
char x1828 = x1811;
char *x1829 = x1812;
int x1834 = 1/*true*/;
char x1835 = '\0';
char *x1836 = 0/*null*/;
char x1830 = x1829[0];
int x1831 = x1830 == '\0';
if (x1831) {
x1836 = x1829;
} else {
int x1832 = x1830 == '\n';
if (x1832) {
x1834 = 0/*false*/;
x1835 = x1830;
char *x1833 = x1829+1;
x1836 = x1833;
} else {
x1836 = x1829;
}
}
int x1848 = x1834;
if (x1848) {
char *x1849 = x1836;
x1805 = 0;
} else {
char x1852 = x1835;
char *x1853 = x1836;
x1805 = x1853;
}
}
char *x1859 = x1805;
return x1859;
}
/*@
requires ((strlen(x1881)>=0) &&
\valid(x1881+(0..(strlen(x1881)+1)-1)));
assigns \nothing;
ensures ((0==\result) || ((strlen(\result)>=0) &&
\valid(\result+(0..(strlen(\result)+1)-1))));
*/
char * p_ContentLength(char * x1881) {
char *x1883 = x1881;
int x1888 = 1/*true*/;
char x1889 = '\0';
char *x1890 = 0/*null*/;
char x1884 = x1881[0];
int x1885 = x1884 == '\0';
if (x1885) {
x1890 = x1881;
} else {
int x1886 = x1884 == 'C';
if (x1886) {
x1888 = 0/*false*/;
x1889 = x1884;
char *x1887 = x1881+1;
x1890 = x1887;
} else {
x1890 = x1881;
}
}
int x1902 = x1888;
if (x1902) {
char *x1903 = x1890;
x1883 = 0;
} else {
char x1906 = x1889;
char *x1907 = x1890;
int x1912 = 1/*true*/;
char x1913 = '\0';
char *x1914 = 0/*null*/;
char x1908 = x1907[0];
int x1909 = x1908 == '\0';
if (x1909) {
x1914 = x1907;
} else {
int x1910 = x1908 == 'o';
if (x1910) {
x1912 = 0/*false*/;
x1913 = x1908;
char *x1911 = x1907+1;
x1914 = x1911;
} else {
x1914 = x1907;
}
}
int x1926 = x1912;
if (x1926) {
char *x1927 = x1914;
x1883 = 0;
} else {
char x1930 = x1913;
char *x1931 = x1914;
int x1936 = 1/*true*/;
char x1937 = '\0';
char *x1938 = 0/*null*/;
char x1932 = x1931[0];
int x1933 = x1932 == '\0';
if (x1933) {
x1938 = x1931;
} else {
int x1934 = x1932 == 'n';
if (x1934) {
x1936 = 0/*false*/;
x1937 = x1932;
char *x1935 = x1931+1;
x1938 = x1935;
} else {
x1938 = x1931;
}
}
int x1950 = x1936;
if (x1950) {
char *x1951 = x1938;
x1883 = 0;
} else {
char x1954 = x1937;
char *x1955 = x1938;
int x1960 = 1/*true*/;
char x1961 = '\0';
char *x1962 = 0/*null*/;
char x1956 = x1955[0];
int x1957 = x1956 == '\0';
if (x1957) {
x1962 = x1955;
} else {
int x1958 = x1956 == 't';
if (x1958) {
x1960 = 0/*false*/;
x1961 = x1956;
char *x1959 = x1955+1;
x1962 = x1959;
} else {
x1962 = x1955;
}
}
int x1974 = x1960;
if (x1974) {
char *x1975 = x1962;
x1883 = 0;
} else {
char x1978 = x1961;
char *x1979 = x1962;
int x1984 = 1/*true*/;
char x1985 = '\0';
char *x1986 = 0/*null*/;
char x1980 = x1979[0];
int x1981 = x1980 == '\0';
if (x1981) {
x1986 = x1979;
} else {
int x1982 = x1980 == 'e';
if (x1982) {
x1984 = 0/*false*/;
x1985 = x1980;
char *x1983 = x1979+1;
x1986 = x1983;
} else {
x1986 = x1979;
}
}
int x1998 = x1984;
if (x1998) {
char *x1999 = x1986;
x1883 = 0;
} else {
char x2002 = x1985;
char *x2003 = x1986;
int x2008 = 1/*true*/;
char x2009 = '\0';
char *x2010 = 0/*null*/;
char x2004 = x2003[0];
int x2005 = x2004 == '\0';
if (x2005) {
x2010 = x2003;
} else {
int x2006 = x2004 == 'n';
if (x2006) {
x2008 = 0/*false*/;
x2009 = x2004;
char *x2007 = x2003+1;
x2010 = x2007;
} else {
x2010 = x2003;
}
}
int x2022 = x2008;
if (x2022) {
char *x2023 = x2010;
x1883 = 0;
} else {
char x2026 = x2009;
char *x2027 = x2010;
int x2032 = 1/*true*/;
char x2033 = '\0';
char *x2034 = 0/*null*/;
char x2028 = x2027[0];
int x2029 = x2028 == '\0';
if (x2029) {
x2034 = x2027;
} else {
int x2030 = x2028 == 't';
if (x2030) {
x2032 = 0/*false*/;
x2033 = x2028;
char *x2031 = x2027+1;
x2034 = x2031;
} else {
x2034 = x2027;
}
}
int x2046 = x2032;
if (x2046) {
char *x2047 = x2034;
x1883 = 0;
} else {
char x2050 = x2033;
char *x2051 = x2034;
int x2056 = 1/*true*/;
char x2057 = '\0';
char *x2058 = 0/*null*/;
char x2052 = x2051[0];
int x2053 = x2052 == '\0';
if (x2053) {
x2058 = x2051;
} else {
int x2054 = x2052 == '-';
if (x2054) {
x2056 = 0/*false*/;
x2057 = x2052;
char *x2055 = x2051+1;
x2058 = x2055;
} else {
x2058 = x2051;
}
}
int x2070 = x2056;
if (x2070) {
char *x2071 = x2058;
x1883 = 0;
} else {
char x2074 = x2057;
char *x2075 = x2058;
int x2080 = 1/*true*/;
char x2081 = '\0';
char *x2082 = 0/*null*/;
char x2076 = x2075[0];
int x2077 = x2076 == '\0';
if (x2077) {
x2082 = x2075;
} else {
int x2078 = x2076 == 'L';
if (x2078) {
x2080 = 0/*false*/;
x2081 = x2076;
char *x2079 = x2075+1;
x2082 = x2079;
} else {
x2082 = x2075;
}
}
int x2094 = x2080;
if (x2094) {
char *x2095 = x2082;
x1883 = 0;
} else {
char x2098 = x2081;
char *x2099 = x2082;
int x2104 = 1/*true*/;
char x2105 = '\0';
char *x2106 = 0/*null*/;
char x2100 = x2099[0];
int x2101 = x2100 == '\0';
if (x2101) {
x2106 = x2099;
} else {
int x2102 = x2100 == 'e';
if (x2102) {
x2104 = 0/*false*/;
x2105 = x2100;
char *x2103 = x2099+1;
x2106 = x2103;
} else {
x2106 = x2099;
}
}
int x2118 = x2104;
if (x2118) {
char *x2119 = x2106;
x1883 = 0;
} else {
char x2122 = x2105;
char *x2123 = x2106;
int x2128 = 1/*true*/;
char x2129 = '\0';
char *x2130 = 0/*null*/;
char x2124 = x2123[0];
int x2125 = x2124 == '\0';
if (x2125) {
x2130 = x2123;
} else {
int x2126 = x2124 == 'n';
if (x2126) {
x2128 = 0/*false*/;
x2129 = x2124;
char *x2127 = x2123+1;
x2130 = x2127;
} else {
x2130 = x2123;
}
}
int x2142 = x2128;
if (x2142) {
char *x2143 = x2130;
x1883 = 0;
} else {
char x2146 = x2129;
char *x2147 = x2130;
int x2152 = 1/*true*/;
char x2153 = '\0';
char *x2154 = 0/*null*/;
char x2148 = x2147[0];
int x2149 = x2148 == '\0';
if (x2149) {
x2154 = x2147;
} else {
int x2150 = x2148 == 'g';
if (x2150) {
x2152 = 0/*false*/;
x2153 = x2148;
char *x2151 = x2147+1;
x2154 = x2151;
} else {
x2154 = x2147;
}
}
int x2166 = x2152;
if (x2166) {
char *x2167 = x2154;
x1883 = 0;
} else {
char x2170 = x2153;
char *x2171 = x2154;
int x2176 = 1/*true*/;
char x2177 = '\0';
char *x2178 = 0/*null*/;
char x2172 = x2171[0];
int x2173 = x2172 == '\0';
if (x2173) {
x2178 = x2171;
} else {
int x2174 = x2172 == 't';
if (x2174) {
x2176 = 0/*false*/;
x2177 = x2172;
char *x2175 = x2171+1;
x2178 = x2175;
} else {
x2178 = x2171;
}
}
int x2190 = x2176;
if (x2190) {
char *x2191 = x2178;
x1883 = 0;
} else {
char x2194 = x2177;
char *x2195 = x2178;
int x2200 = 1/*true*/;
char x2201 = '\0';
char *x2202 = 0/*null*/;
char x2196 = x2195[0];
int x2197 = x2196 == '\0';
if (x2197) {
x2202 = x2195;
} else {
int x2198 = x2196 == 'h';
if (x2198) {
x2200 = 0/*false*/;
x2201 = x2196;
char *x2199 = x2195+1;
x2202 = x2199;
} else {
x2202 = x2195;
}
}
int x2214 = x2200;
if (x2214) {
char *x2215 = x2202;
x1883 = 0;
} else {
char x2218 = x2201;
char *x2219 = x2202;
x1883 = x2219;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
char *x2249 = x1883;
return x2249;
}
/*@
requires ((strlen(x2271)>=0) &&
\valid(x2271+(0..(strlen(x2271)+1)-1)));
assigns \nothing;
ensures ((0==\result) || ((strlen(\result)>=0) &&
\valid(\result+(0..(strlen(\result)+1)-1))));
*/
char * p_TransferEncoding(char * x2271) {
char *x2273 = x2271;
int x2278 = 1/*true*/;
char x2279 = '\0';
char *x2280 = 0/*null*/;
char x2274 = x2271[0];
int x2275 = x2274 == '\0';
if (x2275) {
x2280 = x2271;
} else {
int x2276 = x2274 == 'T';
if (x2276) {
x2278 = 0/*false*/;
x2279 = x2274;
char *x2277 = x2271+1;
x2280 = x2277;
} else {
x2280 = x2271;
}
}
int x2292 = x2278;
if (x2292) {
char *x2293 = x2280;
x2273 = 0;
} else {
char x2296 = x2279;
char *x2297 = x2280;
int x2302 = 1/*true*/;
char x2303 = '\0';
char *x2304 = 0/*null*/;
char x2298 = x2297[0];
int x2299 = x2298 == '\0';
if (x2299) {
x2304 = x2297;
} else {
int x2300 = x2298 == 'r';
if (x2300) {
x2302 = 0/*false*/;
x2303 = x2298;
char *x2301 = x2297+1;
x2304 = x2301;
} else {
x2304 = x2297;
}
}
int x2316 = x2302;
if (x2316) {
char *x2317 = x2304;
x2273 = 0;
} else {
char x2320 = x2303;
char *x2321 = x2304;
int x2326 = 1/*true*/;
char x2327 = '\0';
char *x2328 = 0/*null*/;
char x2322 = x2321[0];
int x2323 = x2322 == '\0';
if (x2323) {
x2328 = x2321;
} else {
int x2324 = x2322 == 'a';
if (x2324) {
x2326 = 0/*false*/;
x2327 = x2322;
char *x2325 = x2321+1;
x2328 = x2325;
} else {
x2328 = x2321;
}
}
int x2340 = x2326;
if (x2340) {
char *x2341 = x2328;
x2273 = 0;
} else {
char x2344 = x2327;
char *x2345 = x2328;
int x2350 = 1/*true*/;
char x2351 = '\0';
char *x2352 = 0/*null*/;
char x2346 = x2345[0];
int x2347 = x2346 == '\0';
if (x2347) {
x2352 = x2345;
} else {
int x2348 = x2346 == 'n';
if (x2348) {
x2350 = 0/*false*/;
x2351 = x2346;
char *x2349 = x2345+1;
x2352 = x2349;
} else {
x2352 = x2345;
}
}
int x2364 = x2350;
if (x2364) {
char *x2365 = x2352;
x2273 = 0;
} else {
char x2368 = x2351;
char *x2369 = x2352;
int x2374 = 1/*true*/;
char x2375 = '\0';
char *x2376 = 0/*null*/;
char x2370 = x2369[0];
int x2371 = x2370 == '\0';
if (x2371) {
x2376 = x2369;
} else {
int x2372 = x2370 == 's';
if (x2372) {
x2374 = 0/*false*/;
x2375 = x2370;
char *x2373 = x2369+1;
x2376 = x2373;
} else {
x2376 = x2369;
}
}
int x2388 = x2374;
if (x2388) {
char *x2389 = x2376;
x2273 = 0;
} else {
char x2392 = x2375;
char *x2393 = x2376;
int x2398 = 1/*true*/;
char x2399 = '\0';
char *x2400 = 0/*null*/;
char x2394 = x2393[0];
int x2395 = x2394 == '\0';
if (x2395) {
x2400 = x2393;
} else {
int x2396 = x2394 == 'f';
if (x2396) {
x2398 = 0/*false*/;
x2399 = x2394;
char *x2397 = x2393+1;
x2400 = x2397;
} else {
x2400 = x2393;
}
}
int x2412 = x2398;
if (x2412) {
char *x2413 = x2400;
x2273 = 0;
} else {
char x2416 = x2399;
char *x2417 = x2400;
int x2422 = 1/*true*/;
char x2423 = '\0';
char *x2424 = 0/*null*/;
char x2418 = x2417[0];
int x2419 = x2418 == '\0';
if (x2419) {
x2424 = x2417;
} else {
int x2420 = x2418 == 'e';
if (x2420) {
x2422 = 0/*false*/;
x2423 = x2418;
char *x2421 = x2417+1;
x2424 = x2421;
} else {
x2424 = x2417;
}
}
int x2436 = x2422;
if (x2436) {
char *x2437 = x2424;
x2273 = 0;
} else {
char x2440 = x2423;
char *x2441 = x2424;
int x2446 = 1/*true*/;
char x2447 = '\0';
char *x2448 = 0/*null*/;
char x2442 = x2441[0];
int x2443 = x2442 == '\0';
if (x2443) {
x2448 = x2441;
} else {
int x2444 = x2442 == 'r';
if (x2444) {
x2446 = 0/*false*/;
x2447 = x2442;
char *x2445 = x2441+1;
x2448 = x2445;
} else {
x2448 = x2441;
}
}
int x2460 = x2446;
if (x2460) {
char *x2461 = x2448;
x2273 = 0;
} else {
char x2464 = x2447;
char *x2465 = x2448;
int x2470 = 1/*true*/;
char x2471 = '\0';
char *x2472 = 0/*null*/;
char x2466 = x2465[0];
int x2467 = x2466 == '\0';
if (x2467) {
x2472 = x2465;
} else {
int x2468 = x2466 == '-';
if (x2468) {
x2470 = 0/*false*/;
x2471 = x2466;
char *x2469 = x2465+1;
x2472 = x2469;
} else {
x2472 = x2465;
}
}
int x2484 = x2470;
if (x2484) {
char *x2485 = x2472;
x2273 = 0;
} else {
char x2488 = x2471;
char *x2489 = x2472;
int x2494 = 1/*true*/;
char x2495 = '\0';
char *x2496 = 0/*null*/;
char x2490 = x2489[0];
int x2491 = x2490 == '\0';
if (x2491) {
x2496 = x2489;
} else {
int x2492 = x2490 == 'E';
if (x2492) {
x2494 = 0/*false*/;
x2495 = x2490;
char *x2493 = x2489+1;
x2496 = x2493;
} else {
x2496 = x2489;
}
}
int x2508 = x2494;
if (x2508) {
char *x2509 = x2496;
x2273 = 0;
} else {
char x2512 = x2495;
char *x2513 = x2496;
int x2518 = 1/*true*/;
char x2519 = '\0';
char *x2520 = 0/*null*/;
char x2514 = x2513[0];
int x2515 = x2514 == '\0';
if (x2515) {
x2520 = x2513;
} else {
int x2516 = x2514 == 'n';
if (x2516) {
x2518 = 0/*false*/;
x2519 = x2514;
char *x2517 = x2513+1;
x2520 = x2517;
} else {
x2520 = x2513;
}
}
int x2532 = x2518;
if (x2532) {
char *x2533 = x2520;
x2273 = 0;
} else {
char x2536 = x2519;
char *x2537 = x2520;
int x2542 = 1/*true*/;
char x2543 = '\0';
char *x2544 = 0/*null*/;
char x2538 = x2537[0];
int x2539 = x2538 == '\0';
if (x2539) {
x2544 = x2537;
} else {
int x2540 = x2538 == 'c';
if (x2540) {
x2542 = 0/*false*/;
x2543 = x2538;
char *x2541 = x2537+1;
x2544 = x2541;
} else {
x2544 = x2537;
}
}
int x2556 = x2542;
if (x2556) {
char *x2557 = x2544;
x2273 = 0;
} else {
char x2560 = x2543;
char *x2561 = x2544;
int x2566 = 1/*true*/;
char x2567 = '\0';
char *x2568 = 0/*null*/;
char x2562 = x2561[0];
int x2563 = x2562 == '\0';
if (x2563) {
x2568 = x2561;
} else {
int x2564 = x2562 == 'o';
if (x2564) {
x2566 = 0/*false*/;
x2567 = x2562;
char *x2565 = x2561+1;
x2568 = x2565;
} else {
x2568 = x2561;
}
}
int x2580 = x2566;
if (x2580) {
char *x2581 = x2568;
x2273 = 0;
} else {
char x2584 = x2567;
char *x2585 = x2568;
int x2590 = 1/*true*/;
char x2591 = '\0';
char *x2592 = 0/*null*/;
char x2586 = x2585[0];
int x2587 = x2586 == '\0';
if (x2587) {
x2592 = x2585;
} else {
int x2588 = x2586 == 'd';
if (x2588) {
x2590 = 0/*false*/;
x2591 = x2586;
char *x2589 = x2585+1;
x2592 = x2589;
} else {
x2592 = x2585;
}
}
int x2604 = x2590;
if (x2604) {
char *x2605 = x2592;
x2273 = 0;
} else {
char x2608 = x2591;
char *x2609 = x2592;
int x2614 = 1/*true*/;
char x2615 = '\0';
char *x2616 = 0/*null*/;
char x2610 = x2609[0];
int x2611 = x2610 == '\0';
if (x2611) {
x2616 = x2609;
} else {
int x2612 = x2610 == 'i';
if (x2612) {
x2614 = 0/*false*/;
x2615 = x2610;
char *x2613 = x2609+1;
x2616 = x2613;
} else {
x2616 = x2609;
}
}
int x2628 = x2614;
if (x2628) {
char *x2629 = x2616;
x2273 = 0;
} else {
char x2632 = x2615;
char *x2633 = x2616;
int x2638 = 1/*true*/;
char x2639 = '\0';
char *x2640 = 0/*null*/;
char x2634 = x2633[0];
int x2635 = x2634 == '\0';
if (x2635) {
x2640 = x2633;
} else {
int x2636 = x2634 == 'n';
if (x2636) {
x2638 = 0/*false*/;
x2639 = x2634;
char *x2637 = x2633+1;
x2640 = x2637;
} else {
x2640 = x2633;
}
}
int x2652 = x2638;
if (x2652) {
char *x2653 = x2640;
x2273 = 0;
} else {
char x2656 = x2639;
char *x2657 = x2640;
int x2662 = 1/*true*/;
char x2663 = '\0';
char *x2664 = 0/*null*/;
char x2658 = x2657[0];
int x2659 = x2658 == '\0';
if (x2659) {
x2664 = x2657;
} else {
int x2660 = x2658 == 'g';
if (x2660) {
x2662 = 0/*false*/;
x2663 = x2658;
char *x2661 = x2657+1;
x2664 = x2661;
} else {
x2664 = x2657;
}
}
int x2676 = x2662;
if (x2676) {
char *x2677 = x2664;
x2273 = 0;
} else {
char x2680 = x2663;
char *x2681 = x2664;
x2273 = x2681;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
char *x2717 = x2273;
return x2717;
}
/*@
requires ((strlen(x2739)>=0) &&
\valid(x2739+(0..(strlen(x2739)+1)-1)));
assigns \nothing;
ensures ((0==\result) || ((strlen(\result)>=0) &&
\valid(\result+(0..(strlen(\result)+1)-1))));
*/
char * p_chunked(char * x2739) {
char *x2741 = x2739;
int x2746 = 1/*true*/;
char x2747 = '\0';
char *x2748 = 0/*null*/;
char x2742 = x2739[0];
int x2743 = x2742 == '\0';
if (x2743) {
x2748 = x2739;
} else {
int x2744 = x2742 == 'c';
if (x2744) {
x2746 = 0/*false*/;
x2747 = x2742;
char *x2745 = x2739+1;
x2748 = x2745;
} else {
x2748 = x2739;
}
}
int x2760 = x2746;
if (x2760) {
char *x2761 = x2748;
x2741 = 0;
} else {
char x2764 = x2747;
char *x2765 = x2748;
int x2770 = 1/*true*/;
char x2771 = '\0';
char *x2772 = 0/*null*/;
char x2766 = x2765[0];
int x2767 = x2766 == '\0';
if (x2767) {
x2772 = x2765;
} else {
int x2768 = x2766 == 'h';
if (x2768) {
x2770 = 0/*false*/;
x2771 = x2766;
char *x2769 = x2765+1;
x2772 = x2769;
} else {
x2772 = x2765;
}
}
int x2784 = x2770;
if (x2784) {
char *x2785 = x2772;
x2741 = 0;
} else {
char x2788 = x2771;
char *x2789 = x2772;
int x2794 = 1/*true*/;
char x2795 = '\0';
char *x2796 = 0/*null*/;
char x2790 = x2789[0];
int x2791 = x2790 == '\0';
if (x2791) {
x2796 = x2789;
} else {
int x2792 = x2790 == 'u';
if (x2792) {
x2794 = 0/*false*/;
x2795 = x2790;
char *x2793 = x2789+1;
x2796 = x2793;
} else {
x2796 = x2789;
}
}
int x2808 = x2794;
if (x2808) {
char *x2809 = x2796;
x2741 = 0;
} else {
char x2812 = x2795;
char *x2813 = x2796;
int x2818 = 1/*true*/;
char x2819 = '\0';
char *x2820 = 0/*null*/;
char x2814 = x2813[0];
int x2815 = x2814 == '\0';
if (x2815) {
x2820 = x2813;
} else {
int x2816 = x2814 == 'n';
if (x2816) {
x2818 = 0/*false*/;
x2819 = x2814;
char *x2817 = x2813+1;
x2820 = x2817;
} else {
x2820 = x2813;
}
}
int x2832 = x2818;
if (x2832) {
char *x2833 = x2820;
x2741 = 0;
} else {
char x2836 = x2819;
char *x2837 = x2820;
int x2842 = 1/*true*/;
char x2843 = '\0';
char *x2844 = 0/*null*/;
char x2838 = x2837[0];
int x2839 = x2838 == '\0';
if (x2839) {
x2844 = x2837;
} else {
int x2840 = x2838 == 'k';
if (x2840) {
x2842 = 0/*false*/;
x2843 = x2838;
char *x2841 = x2837+1;
x2844 = x2841;
} else {
x2844 = x2837;
}
}
int x2856 = x2842;
if (x2856) {
char *x2857 = x2844;
x2741 = 0;
} else {
char x2860 = x2843;
char *x2861 = x2844;
int x2866 = 1/*true*/;
char x2867 = '\0';
char *x2868 = 0/*null*/;
char x2862 = x2861[0];
int x2863 = x2862 == '\0';
if (x2863) {
x2868 = x2861;
} else {
int x2864 = x2862 == 'e';
if (x2864) {
x2866 = 0/*false*/;
x2867 = x2862;
char *x2865 = x2861+1;
x2868 = x2865;
} else {
x2868 = x2861;
}
}
int x2880 = x2866;
if (x2880) {
char *x2881 = x2868;
x2741 = 0;
} else {
char x2884 = x2867;
char *x2885 = x2868;
int x2890 = 1/*true*/;
char x2891 = '\0';
char *x2892 = 0/*null*/;
char x2886 = x2885[0];
int x2887 = x2886 == '\0';
if (x2887) {
x2892 = x2885;
} else {
int x2888 = x2886 == 'd';
if (x2888) {
x2890 = 0/*false*/;
x2891 = x2886;
char *x2889 = x2885+1;
x2892 = x2889;
} else {
x2892 = x2885;
}
}
int x2904 = x2890;
if (x2904) {
char *x2905 = x2892;
x2741 = 0;
} else {
char x2908 = x2891;
char *x2909 = x2892;
x2741 = x2909;
}
}
}
}
}
}
}
char *x2925 = x2741;
return x2925;
}
| 283 |
/*@
requires \valid(m+(0..3));
requires \valid(v+(0..1));
requires \valid(o+(0..1));
requires \forall int i; \forall int j;
0 <= i < 4 && 0 <= j < 2 ==> \separated(m+i,o+j);
requires \forall int i; \forall int j;
0 <= i < 2 && 0 <= j < 2 ==> \separated(v+i,o+j);
assigns o[0..1];
ensures o[0] == (m[0] && v[0]) || (m[1] && v[1]);
ensures o[1] == (m[2] && v[0]) || (m[3] && v[1]);
*/
void mv_mult2_bool(int *m, int *v, int *o) {
o[0] = (m[0] && v[0]) || (m[1] && v[1]);
o[1] = (m[2] && v[0]) || (m[3] && v[1]);
}
/*@
requires \valid(m+(0..3));
requires \valid(v+(0..1));
requires \valid(o+(0..1));
requires \forall int i; \forall int j;
0 <= i < 4 && 0 <= j < 2 ==> \separated(m+i,o+j);
requires \forall int i; \forall int j;
0 <= i < 2 && 0 <= j < 2 ==> \separated(v+i,o+j);
requires \forall int i; 0 <= i < 4 ==> 0 <= m[i] <= 1;
requires \forall int i; 0 <= i < 2 ==> 0 <= v[i] <= 1;
assigns o[0..1];
ensures o[0] == m[0]*v[0]+m[1]*v[1];
ensures o[1] == m[2]*v[0]+m[3]*v[1];
*/
void mv_mult2(int *m, int *v, int *o) {
o[0] = m[0]*v[0]+m[1]*v[1];
o[1] = m[2]*v[0]+m[3]*v[1];
}
/*@
requires n==2;
requires \valid(m+(0..n*n-1));
requires \valid(v+(0..n-1));
requires \valid(o+(0..n-1));
requires \forall int i; \forall int j;
0 <= i < n*n && 0 <= j < n ==> \separated(m+i,o+j);
requires \forall int i; \forall int j;
0 <= i < n && 0 <= j < n ==> \separated(v+i,o+j);
assigns o[0..n-1];
ensures \forall int i; 0 <= i < n ==> o[i] == (m[n*i+0] && v[0]) || (m[n*i+1] && v[1]);
*/
void mv_mult2r_bool(int n, int *m, int *v, int *o) {
/*@
loop invariant 0 <= r <= n;
loop invariant \forall int i; 0 <= i < r ==> o[i] == (m[n*i+0] && v[0]) || (m[n*i+1] && v[1]);
loop assigns r, o[0..n-1];
loop variant n-r;
*/
for (int r = 0; r < n; r++) {
int t = 0;
/*@
loop invariant 0 <= c <= n;
loop invariant t == ((c==0) ? 0 : ((m[n*r+0] && v[0]) || ((c==1)? 0 : (m[n*r+1] && v[1]))));
loop assigns c, t;
loop variant n-c;
*/
for (int c = 0; c < n; c++) {
t = t || (m[n*r+c] && v[c]);
}
o[r] = t;
}
}
/*@
requires n==2;
requires \valid(m+(0..n*n-1));
requires \valid(v+(0..n-1));
requires \valid(o+(0..n-1));
requires \forall int i; \forall int j;
0 <= i < n*n && 0 <= j < n ==> \separated(m+i,o+j);
requires \forall int i; \forall int j;
0 <= i < n && 0 <= j < n ==> \separated(v+i,o+j);
requires m[0]==1;
requires m[1]==1;
requires m[2]==0;
requires m[3]==0;
assigns o[0..n-1];
ensures \forall int i; 0 <= i < n ==> o[i] == (m[n*i+0] && v[0]) || (m[n*i+1] && v[1]);
*/
void mv_mult2s_bool(int n, int *m, int *v, int *o) {
int r = 0;
int t = 0;
/*@
loop invariant 0 <= c <= n;
loop invariant t == ((c==0) ? 0 : ((m[n*r+0] && v[0]) || ((c==1)? 0 : (m[n*r+1] && v[1]))));
loop assigns c, t;
loop variant n-c;
*/
for (int c = 0; c < n; c++) {
t = t || (m[n*r+c] && v[c]);
}
o[r] = t;
o[1] = 0;
}
| 112 |
/*@ ensures \result<=a && \result<=b && (\result==a || \result==b);
*/
int min(int a, int b) {
return (a<b)?a:b;
}
| 3 |
/*@
ensures \result==a || \result==b;
*/
int max(int a,int b)
{
if(a==b) return a;
return a>b?a:b;
}
| 3 |
/*@ requires b != 0;
requires b != -1;
assigns \nothing;
ensures \result == a;
*/
int divmult(int a, int b)
{
return (a / b) * b + (a % b);
}
| 12 |
/*@ predicate sorted{L}(int* a, int length) =
\forall integer i,j; 0<=i<=j<length ==> a[i]<=a[j];
*/
/*@ requires \valid(a+(0..length-1));
requires sorted(a,length);
requires length >=0;
assigns \nothing;
behavior exists:
assumes \exists integer i; 0<=i<length && a[i] == key;
ensures 0<=\result<length && a[\result] == key;
behavior not_exists:
assumes \forall integer i; 0<=i<length ==> a[i] != key;
ensures \result == -1;
complete behaviors;
disjoint behaviors;
*/
int binary_search(int* a, int length, int key) {
int low = 0, high = length - 1;
/*@ loop invariant 0<=low<=high+1;
loop invariant high<length;
loop assigns low,high;
loop invariant \forall integer k; 0<=k<low ==> a[k] < key;
loop invariant \forall integer k; high<k<length ==> a[k] > key;
loop variant high-low;
*/
while (low<=high) {
int mid = low+(high-low)/2;
if (a[mid] == key) return mid;
if (a[mid] < key) { low = mid+1; }
else { high = mid - 1; }
}
return -1;
}
| 29 |
struct Point
{
int x;
int y;
int z;
};
typedef struct Point Point;
/*@
requires \valid(p);
assigns p->x;
assigns p->y;
assigns p->z;
ensures p->x == 0;
ensures p->y == 0;
ensures p->z == 0;
*/
void init(Point* p)
{
p->x = 0;
p->y = 0;
p->z = 0;
}
/*@
requires \valid(p);
assigns *p;
ensures p->x == 0;
ensures p->y == 0;
ensures p->z == 0;
*/
void set_zero(Point* p)
{
p->x = 0;
p->y = 0;
p->z = 0;
}
| 22 |
#include<string.h>
/*@
predicate star_A(char* s, integer i, integer n) =
n==0 || (n>0 && (s[i+n-1]=='A' && star_A(s, i, n-1)));
predicate match_aapb(char* s) =
strlen(s)>=2 && s[0]=='A' && star_A(s,1,strlen(s)-2) && s[strlen(s)-1]=='B';
*/
/*@
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires 0 <= i;
requires strlen(s)-i>=stop;
requires 0 <= n <= stop;
requires !star_A(s, i, n);
ensures !star_A(s, i, stop);
assigns \nothing;
*/
int lemma_not_star_A(char* s, int i, int n, int stop) {
int j = n;
/*@
loop invariant 0 <= j <= stop;
loop invariant !star_A(s, i, j);
loop assigns j;
loop variant stop-j;
*/
while (j!=stop) {
j++;
}
return 0;
}
/*@
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires strlen(s)<=INT_MAX;
ensures match_aapb(s) ==> \result==1;
ensures \result==1 ==> match_aapb(s);
assigns \nothing;
*/
int m_aapb(char* s) {
if (strlen(s)<2) {
//@assert !match_aapb(s);
return 0;
}
//@assert strlen(s)>=2;
int n = 0;
if (s[n]!='A') {
//@assert !match_aapb(s);
return 0;
}
//@assert s[n]=='A';
/*@
loop invariant 0 <= n <= strlen(s)-2;
loop invariant star_A(s, 1, n);
loop assigns n;
loop variant strlen(s)-2-n;
*/
while (n!=strlen(s)-2 && s[1+n]=='A') {
n++;
}
if (n!=strlen(s)-2) {
//@assert n < strlen(s)-2;
//@assert s[1+n]!='A';
//@assert star_A(s, 1, n);
//@assert !star_A(s, 1, n+1);
//@ghost lemma_not_star_A(s, 1, n+1, strlen(s)-2);
//@assert !star_A(s, 1, strlen(s)-2);
//@assert !match_aapb(s);
return 0;
}
//@assert star_A(s, 1, strlen(s)-2);
n++;
if (s[n]!='B') {
//@assert !match_aapb(s);
return 0;
}
//@assert s[n]=='B';
n++;
//@assert s[n]=='\0';
//@assert match_aapb(s);
return s[n]=='\0';
}
| 77 |
#include <limits.h>
#include <string.h>
/*@ predicate match_w(char * x0) = ((x0[0]=='a') &&
(x0[1]=='a'));*/
/*@
assigns \nothing;
ensures \result <==> match_w(x0);
*/
int match_w(char * x0) {
char x2 = x0[0];
int x3 = x2 == 'a';
int x7;
if (x3) {
char x4 = x0[1];
int x5 = x4 == 'a';
int x6;
if (x5) {
x6 = 1/*true*/;
} else {
x6 = 0/*false*/;
}
x7 = x6;
} else {
x7 = 0/*false*/;
}
return x7;
}
/*@ predicate match_any_w(char * x8) = (\exists integer x10; (((0<=x10) &&
(x10<strlen(x8))) &&
match_w((x8+x10))));*/
/*@
requires ((strlen(x22)>=0) &&
\valid(x22+(0..(strlen(x22)+1)-1)));
assigns \nothing;
ensures ((((\result ==> match_any_w(x22)) &&
(match_any_w(x22) ==> \result)) &&
((!\result) ==> (!match_any_w(x22)))) &&
((!match_any_w(x22)) ==> (!\result)));
*/
int matcher(char * x22) {
int x24 = 0;
int x25 = 0;
/*@
loop invariant (((((((0<=x25) &&
(x25<=strlen(x22))) &&
(0<=x24)) &&
(x24<=2)) &&
((strlen(x22)>=0) &&
\valid(x22+(0..(strlen(x22)+1)-1)))) &&
(\forall int x89; (((0<=x89) &&
(x89<(x25-x24))) ==> (!match_w((x22+x89)))))) &&
(((x24==1) ==> ((x25>=1) &&
(x22[(x25-1)]=='a'))) &&
((x24==2) ==> ((x25>=2) &&
((x22[(x25-2)]=='a') &&
(x22[(x25-1)]=='a'))))));
loop assigns x24, x25;
loop variant ((((strlen(x22)*2)-(2*x25))+2)-x24);
*/
for (;;) {
int x26 = x25;
char x27 = x22[x26];
int x29 = x27 == '\0';
int x33;
if (x29) {
x33 = 0/*false*/;
} else {
int x30 = x24;
int x31 = x30 < 2;
x33 = x31;
}
if (!x33) break;
int x35 = x24;
int x36 = x35 == 0;
if (x36) {
int x37 = x25;
char x38 = x22[x37];
int x39 = 'a' == x38;
if (x39) {
x24 += 1;
x25 += 1;
} else {
x24 = 0;
x25 += 1;
}
} else {
int x48 = x35 == 1;
if (x48) {
int x49 = x25;
char x50 = x22[x49];
int x51 = 'a' == x50;
if (x51) {
x24 += 1;
x25 += 1;
} else {
x24 = 0;
}
} else {
}
}
}
int x153 = x24;
int x154 = x153 == 2;
return x154;
}
| 77 |
/* This example contains errors:
* For "add" function, x is suppose to be a valid pointer.
*
* For "incr" function, y should be freed before return.
*/
#include <stdlib.h>
/*@
@ requires val >= 0;
@ ensures \result == val + 1;
@
*/
int add(int * x, int val)
{
*x = val + 1;
return *x;
}
/*@ requires *x >= 0;
@ requires \valid(x);
@ ensures *x == \result - 1;
@ ensures \valid(x);
@*/
int incr(int * x)
{
int * y;
int ret;
y = (int*)malloc(sizeof(int));
*y = *x;
ret = add(x, *y);
return ret;
}
int main() {
incr((void *)-1);
return 0;
}
| 77 |
/*@
requires n>0;
requires \valid(a + (0..n-1));
ensures \forall integer i;
0<= i<n ==>a[n-1]>= a[i];
*/
void selectioninnerloop(int a[], int n)
{
int max_idx = 0;
/*@
loop invariant \forall integer i;0<=i<j ==>a[max_idx]>= a[i];
loop invariant 0<=j<=n;
loop assigns max_idx,j;
loop variant n-j;
*/
for (int j = 0; j < n; j++)
{
if (a[j] > a[max_idx])
{
max_idx = j;
}
}
int temp = a[n - 1];
a[n - 1] = a[max_idx];
a[max_idx] = temp;
}
| 77 |
/*@ requires \valid(arr + (0..size-1));
requires \forall integer i; 0 <= i < size ==> 0 <= arr[i] < size;
requires 0 <= addr < size;
assigns arr[0..size-1];
ensures arr[\at(arr[addr],Pre)] == 0;
*/
void indaddr(unsigned size, int arr[size], unsigned addr)
{
arr[arr[addr]] = 0;
}
| 6 |
/*@ requires n >= 0 && 0 <= n1 < n && 0 <= n2 < n;
requires \valid(a+(0..n-1));
ensures (a[n1] == \old(a[n2]) && a[n2] == \old(a[n1]));
*/
void array_swap(int n, int a[], int n1, int n2)
{
int tmp;
tmp = a[n1]; a[n1] = a[n2]; a[n2] = tmp;
}
| 7 |
#include <limits.h>
/*@
requires ((((((((0<x0) &&
(x0<100)) &&
(0<x1)) &&
(x1<100)) &&
(0<=x2)) &&
(0<=x3)) &&
(x2<x0)) &&
(x3<x1));
assigns \nothing;
ensures ((0<=\result) &&
(\result<(x0*x1)));
*/
int index(int x0, int x1, int x2, int x3) {
int x5 = x2 * x1;
int x6 = x5 + x3;
return x6;
}
/*@ predicate inv_matrix_Boolean(int * x26, integer x27, integer x28) = (((((x27<100) &&
(x28<100)) &&
(0<x27)) &&
(0<x28)) &&
(((x27*x28)>0) &&
\valid(x26+(0..(x27*x28)-1))));*/
/*@
requires (((inv_matrix_Boolean(x63,x64,x65) &&
inv_matrix_Boolean(x66,x67,x68)) &&
inv_matrix_Boolean(x69,x70,x71)) &&
(((x65==x67) &&
(x64==x70)) &&
(x68==x71)));
ensures ((inv_matrix_Boolean(x63,x64,x65) &&
inv_matrix_Boolean(x66,x67,x68)) &&
inv_matrix_Boolean(x69,x70,x71));
*/
void mult(int * x63, int x64, int x65, int * x66, int x67, int x68, int * x69, int x70, int x71) {
/*@
loop invariant 0<=x76<=x64;
loop assigns x76, x69[(0..(x70*x71)-1)];
loop variant x64-x76;
*/
for(int x76=0; x76 < x64; x76++) {
/*@
loop invariant 0<=x78<=x68;
loop assigns x78, x69[(0..(x70*x71)-1)];
loop variant x68-x78;
*/
for(int x78=0; x78 < x68; x78++) {
int x79 = index(x70,x71,x76,x78);
x69[x79] = 0/*false*/;
/*@
loop invariant 0<=x82<=x65;
loop assigns x82, x69[(0..(x70*x71)-1)];
loop variant x65-x82;
*/
for(int x82=0; x82 < x65; x82++) {
int x83 = x69[x79];
int x84 = index(x64,x65,x76,x82);
int x85 = x63[x84];
int x88;
if (x85) {
int x86 = index(x67,x68,x82,x78);
int x87 = x66[x86];
x88 = x87;
} else {
x88 = 0/*false*/;
}
int x89 = x83 || x88;
x69[x79] = x89;
}
}
}
}
| 52 |
/*@ requires n>0 && \valid(p+(0..n-1));
ensures \result==-1 ==> !(\exists int i; 0<=i<n && p[i]==v);
ensures \result!=-1 ==> 0 <= \result < n && p[\result]==v;
assigns \nothing;
*/
int member(int* p, int n, int v) {
/*@
loop invariant (0 <= i <= n);
loop invariant !(\exists int j; 0 <= j < i && p[j]==v);
loop assigns i;
loop variant n-i;
*/
for (int i=0; i<n; i++) {
if (p[i]==v) return i;
}
return -1;
}
/*@ requires n>0 && \valid(p+(0..n-1));
ensures \result==-1 ==> !(\exists int i; 0<=i<n && p[i]==v);
ensures \result!=-1 ==> 0 <= \result < n && p[\result]==v;
assigns \nothing;
*/
int member_noreturn(int* p, int n, int v) {
int r = -1;
/*@
loop invariant (0 <= i <= n);
loop invariant r==-1 ==> !(\exists int j; 0 <= j < i && p[j]==v);
loop invariant r!=-1 ==> 0 <= r < n && p[r]==v;
loop assigns i, r;
loop variant n-i;
*/
for (int i=0; i<n; i++) {
if (r==-1 && p[i]==v) {
r = i;
}
}
return r;
}
| 32 |
/*@
behavior first_case:
behavior first1_case:
assumes num1>num2;
assumes num1>num3;
ensures \result == num1;
behavior first2_case:
assumes num1>num2;
assumes num1<=num3;
ensures \result == num3;
behavior second_case:
behavior second1_case:
assumes num1<=num2;
assumes num2>num3;
ensures \result == num2;
behavior second2_case:
assumes num1<=num2;
assumes num2<=num3;
ensures \result == num3;
*/
int max3(int num1, int num2, int num3){
if(num1 > num2){
if(num1 > num3)
return num1;
else
return num3;
}
else
{
if(num2 > num3)
return num2;
else
return num3;
}
}
| 6 |
/* run.config_ci
COMMENT: test option -e-acsl-instrument; cannot run Eva on this example
LOG: gen_@[email protected]
STDOPT:#"-e-acsl-instrument='@@all,-uninstrument1,-uninstrument2'"
*/
#include <stdarg.h>
int uninstrument1(int *p) {
*p = 0;
return 0;
}
/*@ requires \valid(p); */
int uninstrument2(int *p) {
{ int *q = p;
*p = 0;
goto L;
}
L:
return 0;
}
int instrument1(int *p) {
*p = 0;
return 0;
}
/*@ requires \valid(p); */
int instrument2(int *p) {
{ int *q = p;
*p = 0;
goto L;
}
L:
return 0;
}
/* test combination of -e-acsl-instrument and -variadic-no-translation;
see gitlab's issue #88 */
int vol(int n, ...) {
va_list vl;
va_start(vl, n);
int r = va_arg(vl, int);
va_end(vl);
return 1;
}
int main(void) {
int x;
int y = 0;
instrument1(&x);
uninstrument1(&x);
instrument2(&x);
uninstrument2(&x);
/*@ assert \initialized(&x); */
/*@ assert \initialized(&y); */
return vol(6, 1);
}
| 6 |
/*@ ensures (\result >= x && \result >=y) ; */
int maxint (int x, int y) {
return (x > y) ? x : y;
}
| 3 |
#include <string.h>
/*@
predicate match_aab(char* s) =
s[0]=='a' && s[1]=='a' && s[2]=='b';
predicate match_anyaab(char* s) =
\exists int i; 0 <= i < strlen(s) && match_aab(s+i);
*/
/*@
requires strlen(s)>=0 && \valid(s+(0..strlen(s)));
requires strlen(s)*2+3 <= INT_MAX;
assigns \nothing;
ensures \result==0 || \result==1;
ensures match_anyaab(s) <==> \result==1;
ensures !match_anyaab(s) <==> \result==0;
*/
int match(char *s) {
int j = 0;
int k = 0;
/*@
loop invariant (0 <= k <= strlen(s));
loop invariant (0 <= j <= 3);
loop invariant strlen(s)>=0 && \valid(s+(0..strlen(s)));
loop invariant (\forall int i; 0 <= i < k-j ==> !match_aab(s+i));
loop invariant (j==1 ==> k>=1 && s[k-1]=='a');
loop invariant (j==2 ==> k>=2 && s[k-2]=='a' && s[k-1]=='a');
loop invariant (j==3 ==> k>=3 && s[k-3]=='a' && s[k-2]=='a' && s[k-1]=='b');
loop assigns j, k;
loop variant strlen(s)*2 - k*2 + j;
*/
while (s[k] != '\0' && j < 3) {
if (j == 0) {
if (s[k] == 'a') {
j += 1;
k += 1;
} else {
j = 0;
k += 1;
}
} else if (j == 1) {
if (s[k] == 'a') {
j += 1;
k += 1;
} else {
j = 0;
}
} else if (j == 2) {
if (s[k] == 'b') {
j += 1;
k += 1;
} else {
j = 1;
}
} else {
return -1;
}
}
return j==3;
}
| 36 |
/*@ ensures \result >= a && \result >= b;
ensures \result == a || \result == b ;
*/
int max ( int a, int b ) {
if ( a >= b )
return a ;
return b ;
}
| 4 |
#include <limits.h>
/*@
requires ((((((((0<x0) &&
(x0<100)) &&
(0<x1)) &&
(x1<100)) &&
(0<=x2)) &&
(0<=x3)) &&
(x2<x0)) &&
(x3<x1));
assigns \nothing;
ensures ((0<=\result) &&
(\result<(x0*x1)));
*/
int index(int x0, int x1, int x2, int x3) {
int x5 = x2 * x1;
int x6 = x5 + x3;
return x6;
}
/*@ predicate inv_matrix_Boolean(int * x36, int x37, int x38) = (((((x37<100) &&
(x38<100)) &&
(0<x37)) &&
(0<x38)) &&
(((x37*x38)>0) &&
\valid(x36+(0..(x37*x38)-1))));*/
/*@
requires (((((inv_matrix_Boolean(x79,x80,x81) &&
inv_matrix_Boolean(x82,x83,x84)) &&
inv_matrix_Boolean(x85,x86,x87)) &&
((x86==x80) &&
(x87==x81))) &&
((x86==x83) &&
(x87==x84))) &&
((\forall int x141; (\forall int x142; ((((0<=x141) &&
(x141<(x86*x87))) &&
((0<=x142) &&
(x142<(x80*x81)))) ==> \separated(x85+x141,x79+x142)))) &&
(\forall int x161; (\forall int x162; ((((0<=x161) &&
(x161<(x86*x87))) &&
((0<=x162) &&
(x162<(x83*x84)))) ==> \separated(x85+x161,x82+x162))))));
ensures (((inv_matrix_Boolean(x79,x80,x81) &&
inv_matrix_Boolean(x82,x83,x84)) &&
inv_matrix_Boolean(x85,x86,x87)) &&
(\forall int x188; (((0<=x188) &&
(x188<(x86*x87))) ==> (x85[x188]==(x79[x188] || x82[x188])))));
*/
void add(int * x79, int x80, int x81, int * x82, int x83, int x84, int * x85, int x86, int x87) {
/*@assert \separated(x85+0,x79+0);*/
/*@assert \separated(x85+0,x82+0);*/
int x89 = x86 * x87;
/*@
loop invariant 0<=x97<=x89;
loop invariant (\forall int x98; (((0<=x98) &&
(x98<x97)) ==> (x85[x98]==(x79[x98] || x82[x98]))));
loop assigns x97, x85[(0..x89-1)];
loop variant x89-x97;
*/
for(int x97=0; x97 < x89; x97++) {
int x112 = x79[x97];
int x113 = x82[x97];
int x114 = x112 || x113;
x85[x97] = x114;
/*@assert \separated(x85+x97,x79+x97);*/
/*@assert \separated(x85+x97,x82+x97);*/
}
}
/*@
requires (((inv_matrix_Boolean(x204,x205,x206) &&
inv_matrix_Boolean(x207,x208,x209)) &&
((x208==x205) &&
(x209==x206))) &&
(\forall int x248; (\forall int x249; ((((0<=x248) &&
(x248<(x208*x209))) &&
((0<=x249) &&
(x249<(x205*x206)))) ==> \separated(x207+x248,x204+x249)))));
ensures (((inv_matrix_Boolean(x204,x205,x206) &&
inv_matrix_Boolean(x207,x208,x209)) &&
(\forall int x274; (((0<=x274) &&
(x274<(x208*x209))) ==> (x207[x274]==(x203 &&
x204[x274]))))) &&
((x203==\false) ==> (\forall int x289; (0<=x289<x208) ==> (\forall int x292; (0<=x292<x209) ==> (x207[((x289*x209)+x292)]==\false)))));
*/
void scalar_mult(int x203, int * x204, int x205, int x206, int * x207, int x208, int x209) {
/*@assert \separated(x207+0,x204+0);*/
int x211 = x208 * x209;
/*@
loop invariant 0<=x216<=x211;
loop invariant (\forall int x217; (((0<=x217) &&
(x217<x216)) ==> (x207[x217]==(x203 &&
x204[x217]))));
loop assigns x216, x207[(0..x211-1)];
loop variant x211-x216;
*/
for(int x216=0; x216 < x211; x216++) {
int x231;
if (x203) {
int x230 = x204[x216];
x231 = x230;
} else {
x231 = 0/*false*/;
}
x207[x216] = x231;
/*@assert \separated(x207+x216,x204+x216);*/
}
}
| 54 |
#include <limits.h>
#include <string.h>
/*@ logic integer cypher(int x0) = (((x0==26)) ? (0) : ((x0+1)));*/
/*@
requires ((0<=x0) &&
(x0<=26));
assigns \nothing;
ensures ((0<=\result) &&
(\result<=26));
ensures \result == cypher(x0);
*/
int cypher(int x0) {
int x2 = x0 == 26;
int x4;
if (x2) {
x4 = 0;
} else {
int x3 = x0 + 1;
x4 = x3;
}
return x4;
}
/*@ logic integer decypher(int x15) = (((x15==0)) ? (26) : ((x15-1)));*/
/*@
requires ((0<=x15) &&
(x15<=26));
assigns \nothing;
ensures ((0<=\result) &&
(\result<=26));
ensures \result == decypher(x15);
*/
int decypher(int x15) {
int x17 = x15 == 0;
int x19;
if (x17) {
x19 = 26;
} else {
int x18 = x15 - 1;
x19 = x18;
}
return x19;
}
/*@
requires ((((((x33>0) &&
\valid(x30+(0..x33-1))) &&
\valid(x31+(0..x33-1))) &&
\valid(x32+(0..x33-1))) &&
(\forall int x116; (((0<=x116) &&
(x116<x33)) ==> (\forall int x121; (((0<=x121) &&
(x121<x33)) ==> (\forall int x126; (((0<=x126) &&
(x126<x33)) ==> ((\separated(x30+x116,x31+x121) &&
\separated(x30+x116,x32+x126)) &&
\separated(x31+x121,x32+x126))))))))) &&
(\forall int x148; (((0<=x148) &&
(x148<x33)) ==> ((0<=x30[x148]) &&
(x30[x148]<=26)))));
ensures ((((\forall int x163; (((0<=x163) &&
(x163<x33)) ==> (x31[x163]==cypher(x30[x163])))) &&
(\forall int x175; (((0<=x175) &&
(x175<x33)) ==> ((0<=x31[x175]) &&
(x31[x175]<=26))))) &&
(\forall int x189; (((0<=x189) &&
(x189<x33)) ==> (\old(x30[x189])==x30[x189])))) &&
(\forall int x202; (((0<=x202) &&
(x202<x33)) ==> (\old(x32[x202])==x32[x202]))));
assigns x31[(0..x33-1)];
*/
void encode(int * x30, int * x31, int * x32, int x33) {
/*@
loop invariant 0<=x36<=x33;
loop invariant (\forall int x37; (((0<=x37) &&
(x37<x33)) ==> ((0<=x30[x37]) &&
(x30[x37]<=26))));
loop invariant (\forall int x51; (((0<=x51) &&
(x51<x33)) ==> (\at(x30[x51],Pre)==x30[x51])));
loop invariant (\forall int x64; (((0<=x64) &&
(x64<x33)) ==> (\at(x32[x64],Pre)==x32[x64])));
loop invariant (\forall int x77; (((0<=x77) &&
(x77<x36)) ==> (x31[x77]==cypher(x30[x77]))));
loop assigns x36, x31[(0..x33-1)];
loop variant x33-x36;
*/
for(int x36=0; x36 < x33; x36++) {
int x94 = x30[x36];
int x95 = cypher(x94);
x31[x36] = x95;
/*@assert (x31[x36]==cypher(x30[x36]));*/
}
}
/*@
requires ((((((x219>0) &&
\valid(x216+(0..x219-1))) &&
\valid(x217+(0..x219-1))) &&
\valid(x218+(0..x219-1))) &&
(\forall int x302; (((0<=x302) &&
(x302<x219)) ==> (\forall int x307; (((0<=x307) &&
(x307<x219)) ==> (\forall int x312; (((0<=x312) &&
(x312<x219)) ==> ((\separated(x216+x302,x217+x307) &&
\separated(x216+x302,x218+x312)) &&
\separated(x217+x307,x218+x312))))))))) &&
(\forall int x334; (((0<=x334) &&
(x334<x219)) ==> ((0<=x216[x334]) &&
(x216[x334]<=26)))));
ensures ((((\forall int x349; (((0<=x349) &&
(x349<x219)) ==> (x217[x349]==decypher(x216[x349])))) &&
(\forall int x361; (((0<=x361) &&
(x361<x219)) ==> ((0<=x217[x361]) &&
(x217[x361]<=26))))) &&
(\forall int x375; (((0<=x375) &&
(x375<x219)) ==> (\old(x216[x375])==x216[x375])))) &&
(\forall int x388; (((0<=x388) &&
(x388<x219)) ==> (\old(x218[x388])==x218[x388]))));
assigns x217[(0..x219-1)];
*/
void decode(int * x216, int * x217, int * x218, int x219) {
/*@
loop invariant 0<=x222<=x219;
loop invariant (\forall int x223; (((0<=x223) &&
(x223<x219)) ==> ((0<=x216[x223]) &&
(x216[x223]<=26))));
loop invariant (\forall int x237; (((0<=x237) &&
(x237<x219)) ==> (\at(x216[x237],Pre)==x216[x237])));
loop invariant (\forall int x250; (((0<=x250) &&
(x250<x219)) ==> (\at(x218[x250],Pre)==x218[x250])));
loop invariant (\forall int x263; (((0<=x263) &&
(x263<x222)) ==> (x217[x263]==decypher(x216[x263]))));
loop assigns x222, x217[(0..x219-1)];
loop variant x219-x222;
*/
for(int x222=0; x222 < x219; x222++) {
int x280 = x216[x222];
int x281 = decypher(x280);
x217[x222] = x281;
/*@assert (x217[x222]==decypher(x216[x222]));*/
}
}
/*@
requires ((((((x405>0) &&
\valid(x402+(0..x405-1))) &&
\valid(x403+(0..x405-1))) &&
\valid(x404+(0..x405-1))) &&
(\forall int x421; (((0<=x421) &&
(x421<x405)) ==> (\forall int x426; (((0<=x426) &&
(x426<x405)) ==> (\forall int x431; (((0<=x431) &&
(x431<x405)) ==> ((\separated(x402+x421,x403+x426) &&
\separated(x402+x421,x404+x431)) &&
\separated(x403+x426,x404+x431))))))))) &&
(\forall int x453; (((0<=x453) &&
(x453<x405)) ==> ((0<=x402[x453]) &&
(x402[x453]<=26)))));
ensures ((\forall int x468; (((0<=x468) &&
(x468<x405)) ==> (x404[x468]==x402[x468]))) &&
(\forall int x479; (((0<=x479) &&
(x479<x405)) ==> (\old(x402[x479])==x402[x479]))));
assigns x403[(0..x405-1)], x404[(0..x405-1)];
*/
void autoencode(int * x402, int * x403, int * x404, int x405) {
encode(x402,x403,x404,x405);
decode(x403,x404,x402,x405);
}
| 77 |
//check if every element is equal to index
/*@
requires n>0;
requires \valid_read(arr+(0..n-1));
behavior one:
assumes \forall integer j;
0<=j<n ==> arr[j]==j;
ensures \result == 1;
behavior two:
assumes \exists integer j;
0<=j<n && arr[j]!=j;
ensures \result == 0;
complete behaviors;
disjoint behaviors;
*/
int checkIndex(int arr[], int n){
/*@
loop invariant 0<=i<=n;
loop invariant \forall integer k;
0<=k<i ==> arr[k]==k;
loop assigns i;
loop variant n-i;
*/
for (int i = 0; i < n; i++)
{
if(arr[i]!=i){
return 0;
}
}
return 1;
}
| 15 |
/*@ terminates \true;
@ assigns \nothing;
@ ensures \false;
@ exits \exit_status == status;
@*/
void exit(int status);
int status;
/*@ terminates \true;
@ assigns status;
@ exits !cond && \exit_status == 1 && status == val;
@ ensures cond && status == \old(status);
@*/
void may_exit(int cond, int val) {
if (! cond) {
status = val;
exit(1);
}
}
| 5 |
/*@ axiomatic Factorial {
logic integer factorial(integer i);
axiom nil:
factorial(0) == 1;
axiom step:
\forall integer i; i >= 0 ==>
factorial(i) == factorial(i - 1) * i;
lemma non_negative:
\forall integer i; i >= 0 ==>
factorial(i) > 0;
}
*/
#define SPEC_ULONG_MAX 18446744073709551615UL
/*@ requires factorial(i) <= SPEC_ULONG_MAX;
assigns \nothing;
ensures \result == factorial(i);
*/
unsigned long factorial(unsigned i)
{
unsigned long f = 1;
/*@ loop invariant 0 <= i;
loop assigns f, i;
loop variant i;
*/
while (i) {
f *= i--;
}
return f;
}
#ifdef OUT_OF_TASK
#include <stdio.h>
int main(void)
{
printf("res: %lu\n", factorial(10));
printf("res: %lu\n", factorial(20));
return 0;
}
#endif
| 11 |
/*@ assigns \nothing;
ensures \result == 0 || \result == 1 || \result == -1;
behavior positive:
assumes x > 0;
ensures \result == 1;
behavior zero:
assumes x == 0;
ensures \result == 0;
behavior negative:
assumes x < 0;
ensures \result == -1;
complete behaviors;
disjoint behaviors;
*/
int spec_sign(int x)
{
return (x > 0) - (x < 0);
}
/* assigns \nothing;
ensures \result == 0 || \result == 1 || \result == -1;
behavior positive:
assumes x > 0;
ensures \result == 1;
behavior zero:
assumes x == 0;
ensures \result == 0;
behavior negative:
assumes x < 0;
ensures \result == -1;
complete behaviors;
disjoint behaviors;
*/
/*int sign2(int x)
{
// assumes 32-bit int and 2s complement signed shifts work (implementation defined by C spec)
return (x>>31) | ((unsigned)-x >> 31);
}*/
#ifdef OUT_OF_TASK
#include <stdio.h>
int main(void)
{
printf("res: %d\n", spec_sign(-10));
return 0;
}
#endif
| 11 |
/*@requires\valid(a) &&\valid(b);
ensures *a ==\old(*b) && *b ==\old(*a);*/
int swap(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
return 0;
}
| 7 |
#include<stdbool.h>
#define round(X) (double) (X)
/*@
axiomatic fp_funs {
logic double Dadd(double X, double Y) = round(X+Y);
logic double Dsub(double X, double Y) = round(X-Y);
logic double Dmul(double X, double Y) = round(X*Y);
logic double Dneg(double X) = round(0-X);
logic double Dabs(double X) = round(X); //TODO define correctly
logic double Ddiv(double X, double Y) =
X;
// (Y != 0.0 ? round(X/Y) : 0.0) ;
// }
// axiomatic int_funs {
logic integer Iadd(integer X, integer Y) = X+Y;
logic integer Isub(integer X, integer Y) = X-Y;
logic integer Imul(integer X, integer Y) = X*Y;
logic integer Ineg(integer X) = 0-X;
// logic integer Idiv(integer X, integer Y) = (Y != 0 ? X/Y : 0) ;
// }
// axiomatic error_bounds {
logic real ulp_dp(real X) = \round_double(\Up,X)-\round_double(\Down,X);
logic real errAdd_dp(real X, real E_X, real Y, real E_Y)
= E_X + E_Y + ulp_dp(\abs(X + Y) + E_X + E_Y)/2;
logic real errSub_dp(real X, real E_X, real Y, real E_Y)
= E_X + E_Y + ulp_dp(\abs(X - Y) + E_X + E_Y)/2;
logic real errMul_dp(real X, real E_X, real Y, real E_Y)
= \abs(X)*E_Y+\abs(Y)*E_X+E_X*E_Y + ulp_dp(\abs(X)*\abs(Y) + \abs(X)*E_Y + E_X*\abs(Y) + E_X*E_Y)/2;
logic real errDiv_dp(real X, real E_X, real Y, real E_Y)
= ( ((Y*Y - E_Y*\abs(Y)) != 0 && (\abs(Y) - E_Y) !=0)?
(\abs(Y)*E_X + \abs(X)*E_Y) / (Y*Y - E_Y*\abs(Y)) + ulp_dp((\abs(X) + E_X) / (\abs(Y) - E_Y)) / 2
: 0 );
logic real errNeg_dp(real X, real E_X)
= E_X;
logic real errAdd_i(integer X, real E_X, integer Y, real E_Y)
= E_X + E_Y;
logic real errSub_i(integer X, real E_X, integer Y, real E_Y)
= E_X + E_Y;
}
*/
struct maybeInt {
bool isValid;
int value;
};
/*@ assigns \nothing;
ensures ! \result.isValid;
*/
struct maybeInt none () {
struct maybeInt result = { false, 0 };
return result;
}
/*@ assigns \nothing;
ensures \result.isValid;
ensures \result.value == val;
*/
struct maybeInt some (int val) {
struct maybeInt result = { true, val };
return result;
}
struct maybeFloat {
bool isValid;
float value;
};
/*@ assigns \nothing;
ensures ! \result.isValid;
*/
struct maybeFloat noneFloat () {
struct maybeFloat result = { false, 0 };
return result;
}
/*@ assigns \nothing;
ensures \result.isValid;
ensures \result.value == val;
*/
struct maybeFloat someFloat (float val) {
struct maybeFloat result = { true, val };
return result;
}
struct maybeDouble {
bool isValid;
double value;
};
/*@ assigns \nothing;
ensures ! \result.isValid;
*/
struct maybeDouble noneDouble () {
struct maybeDouble result = { false, 0 };
return result;
}
/*@ assigns \nothing;
ensures \result.isValid;
ensures \result.value == val;
*/
struct maybeDouble someDouble (double val) {
struct maybeDouble result = { true, val };
return result;
}
struct maybeBool {
bool isValid;
bool value;
};
/*@ assigns \nothing;
ensures ! \result.isValid;
*/
struct maybeBool noneBool () {
struct maybeBool result = { false, false };
return result;
}
/*@ assigns \nothing;
ensures \result.isValid;
ensures \result.value == val;
*/
struct maybeBool someBool (bool val) {
struct maybeBool result = { true, val };
return result;
}
| 36 |
/**
*
* Frama-C Version: Frama-C Silicon-20161101
* Alt-Ergo Version: 1.30
*
* Run the following:
* frama-c -wp -wp-rte -wp-prover alt-ergo -wp-timeout 10 countSameConsecutiveFinal.c -then -report
*
**/
/*@ predicate all_equal_in_range{L}(int *x, integer minidx, integer maxidx) =
@ \forall integer k; minidx <= k < minidx + maxidx ==> \at(x[minidx], L) == \at(x[k], L)
@ ;
*/
/*@ predicate all_smaller_than_best{L}(int *x, integer i, integer maxidx, integer best) =
@ \forall integer k1;
@ (
@ i <= k1 < maxidx
@ && k1 + best < maxidx
@ && (0 < k1 < maxidx ==> \at(x[k1],L) != \at(x[k1-1],L)
@ )
@ && all_equal_in_range{L}(x, k1, best))
@ ==> \at(x[k1],L) != \at(x[k1+best],L);
@*/
/*@ requires 1 <= N <= 1000000;
@ requires \valid(x + (0..N-1));
@ ensures \exists integer k1; 0 <= k1 < N && all_equal_in_range(x, k1, \result);
@ ensures all_smaller_than_best(x, 0, N, \result);
*/
int countSameConsecutive(int N, int x[]) {
int best = 0, i = 0;
/*@ loop invariant 0 <= i <= N;
@ loop invariant i == 0 ==> best == 0;
@ loop invariant i > 0 ==> 1 <= best <= N;
@ loop invariant i > 0 ==> \exists integer k1; 0 <= k1 < i && all_equal_in_range(x, k1, best);
@ loop invariant 0 < i < N ==> x[i] != x[i-1];
@ loop invariant i > 0 ==> all_smaller_than_best(x, 0, i, best);
@ loop assigns i, best;
@ loop variant N - i;
*/
while (i < N) {
int j = i+1;
/*@ loop invariant i < j <= N;
@ loop invariant all_equal_in_range(x, i, j-i);
@ loop assigns j;
@ loop variant N - j;
*/
while (j < N && x[j] == x[i]) ++j;
if (j-i > best) best = j-i;
i = j;
}
return best;
}
| 35 |
/*@
ensures \result>=a && \result>=b && \result>=c;
ensures \result==a || \result==b || \result==c;
ensures a>=b && a>=c ==> \result==a;
ensures b>=a && b>=c ==> \result==b;
ensures c>=a && c>=b ==> \result==c;
*/
int max3(int a,int b,int c) {
int max;
if((a >= b) && (a >= c)) {
max = a;
}
else if((b >= a) && (b >= c)) {
max = b;
}
else if((c >= a) && (c >= b)) {
max = c;
}
return max;
}
| 7 |
#include <limits.h>
/*@
requires (x0>0);
assigns \nothing;
ensures ((0<=\result) &&
(\result<x0));
*/
int pick_index(int x0) {
return 0;
}
/*@
requires ((x10>0) &&
\valid(x9+(0..x10-1)));
assigns \nothing;
*/
int pick_element(int * x9, int x10) {
int x12 = pick_index(x10);
int x13 = x9[x12];
return x13;
}
/*@
requires \valid(x20);
assigns \nothing;
ensures (\result==x20[0]);
*/
int pick_first(int * x20) {
int x22 = x20[0];
return x22;
}
| 16 |
#include <stdio.h>
#include <stdlib.h>
int n, at, x;
int t[1000];
//@ predicate ord{L}(int direc_var) = \forall integer i; 0 <= i <= n-2 ==> (direc_var ? t[i] < t[i+1] : t[i] > t[i+1]);
//@ predicate noin{L} = \forall integer i; 0 <= i < n ==> t[i] != x;
/*@
axiomatic zalozenia_zadania {
axiom n_in_range{L}: 2 <= n <= 1000;
axiom all_in_range{L}:
\forall integer i; 0 <= i < n ==> -100000 <= t[i] <= 100000;
axiom x_in_range{L}: -100000 <= x <= 100000;
axiom strong_order_one_way_or_another{L}:
ord((int)0) || ord((int)1);
}
*/
/*@
assigns at;
ensures at==-1 && noin || t[at]==x;
*/
void bins() {
int from = 0;
int to = n-1;
//@ assert from<to;
int direc = t[0]<=t[1];
//@ assert ord(direc);
/*@
loop assigns at, to, from;
loop invariant from<=to;
loop invariant from==to && at==-1 && noin ||
at==from-1 && (direc? t[at]<x : t[at]>x) ||
at==to+1 && (direc? t[at]>x : t[at]<x) ||
from <= at && at <= to;
loop variant to-from;
*/
while(1) {
//@ assert from>=0;
//@ assert from<to;
at = (from+to)/2;
//@ assert from <= at && at <= to;
//@ assert to==from+1 ==> at==from && at==to-1;
//@ assert to==from+2 ==> at==from+1 && at==to-1;
if(direc? t[at]<x : t[at]>x) {
//nope: @ assert from < at;
//@ ghost int old_to = to;
to = at-1;
//@ assert old_to > to;
//@ assert from <= to;
} else if(direc? t[at]>x : t[at]<x) {
//@ assert at < to;
//@ ghost int old_from = from;
from = at+1;
//@ assert from > old_from;
//@ assert from <= to;
} else {
//@ assert t[at]==x;
break;
}
if(from==to) {
//@ assert t[from]!=x;
//@ assert noin;
at = -1;
break;
}
}
}
int main() {
scanf("%d", &n);
for(int i=0;i<n;i++)
scanf("%d", &t[i]);
scanf("%d", &x);
bins();
printf("%d\n", at);
return 0;
}
| 61 |
/*@
logic boolean row_col_bool(integer c, int r, int n, int* m, int* v) =
(0 < c <= n) ? ((row_col_bool(c-1, r, n, m, v)) || (m[n*r+(c-1)] && v[(c-1)])) : 0;
*/
/*@
requires n>0;
requires n<3;
requires \valid(m+(0..n*n-1));
requires \valid(v+(0..n-1));
requires \valid(o+(0..n-1));
requires \separated(m+(0..n*n-1), v+(0..n-1), o+(0..n-1));
assigns o[0..n-1];
ensures \forall int i; 0 <= i < n ==>
o[i] == row_col_bool(n, i, n, m, v);
*/
void mv_mult_bool(int n, int *m, int *v, int *o) {
/*@
loop invariant 0 <= r <= n;
loop invariant \forall int i; 0 <= i < r ==> o[i] == row_col_bool(n, i, n, m, v);
loop assigns r, o[0..n-1];
loop variant n-r;
*/
for (int r = 0; r < n; r++) {
o[r] = 0;
/*@
loop invariant 0 <= c <= n;
loop invariant 0 <= r < n;
loop invariant \forall int i; 0 <= i < r ==> o[i] == row_col_bool(n, i, n, m, v);
loop invariant o[r] == row_col_bool(c, r, n, m, v);
loop assigns c, o[r];
loop variant n-c;
*/
for (int c = 0; c < n; c++) {
o[r] = o[r] || (m[n*r+c] && v[c]);
}
}
}
/*@
requires n>0;
requires n==2;
requires \valid(m+(0..n*n-1));
requires \valid(v+(0..n-1));
requires \valid(o+(0..n-1));
requires \separated(m+(0..n*n-1), v+(0..n-1), o+(0..n-1));
requires m[0]==1;
requires m[1]==1;
requires m[2]==0;
requires m[3]==0;
assigns o[0..n-1];
ensures \forall int i; 0 <= i < n ==>
o[i] == row_col_bool(n, i, n, m, v);
*/
void mv_mults_bool(int n, int *m, int *v, int *o) {
int r = 0;
o[r] = 0;
/*@
loop invariant 0 <= c <= n;
loop invariant 0 <= r < n;
loop invariant \forall int i; 0 <= i < r ==> o[i] == row_col_bool(n, i, n, m, v);
loop invariant o[r] == row_col_bool(c, r, n, m, v);
loop assigns c, o[r];
loop variant n-c;
*/
for (int c = 0; c < n; c++) {
o[r] = o[r] || (m[n*r+c] && v[c]);
}
o[1] = 0;
}
/*@
requires n>0;
requires n==2;
requires \valid(m+(0..n*n-1));
requires \valid(v+(0..n-1));
requires \valid(o+(0..n-1));
requires \separated(m+(0..n*n-1), v+(0..n-1), o+(0..n-1));
requires m[0]==1;
requires m[1]==1;
requires m[2]==0;
requires m[3]==0;
assigns o[0..n-1];
ensures \forall int i; 0 <= i < n ==>
o[i] == row_col_bool(n, i, n, m, v);
*/
void mv_multu_bool(int n, int *m, int *v, int *o) {
o[0] = 0;
o[0] = o[0] || v[0];
o[0] = o[0] || v[1];
o[1] = 0;
}
| 95 |
/*@
requires \valid(q) && \valid(r);
requires \separated(q, r);
requires y != 0;
assigns *q, *r;
ensures x == *q * y + *r;
ensures *r < y;
*/
void div_rem(unsigned x, unsigned y, unsigned* q, unsigned* r) {
*q = x / y;
*r = x % y;
}
| 10 |
/*@
requires n>0;
requires\valid(a+ (0..n-1));
ensures\forall integer i;
0<= i<n-1 ==>a[n-1]>=a[i];
*/
void q1(int a[],int n)
{
/*@
loop invariant\forall integer i;
0<= i<j ==> a[j]>=a[i];loop invariant 0<=j<=n-1;
loop assigns j,a[0..j+1];
loop variant n-1-j;
*/
for (int j=0;j<n-1;j++)
{
if(a[j]>a[j+1])
{
int t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}
}
}
| 24 |
/*@ logic integer max(integer a, integer b) =
a > b ? a : b;
*/
/*@ assigns \nothing;
ensures \result >= a;
ensures \result >= b;
ensures \result == a || \result == b;
ensures \result == max(a, b);
*/
int max(int a, int b)
{
return a > b ? a : b;
}
| 8 |
#include <limits.h>
/*@
requires (x0>0);
assigns \nothing;
ensures ((0<=\result) &&
(\result<x0));
*/
int pick_index(int x0) {
return 0;
}
/*@
requires ((x7>0) &&
\valid(x6+(0..x7-1)));
assigns \nothing;
*/
int pick_element(int * x6, int x7) {
int x9 = pick_index(x7);
int x10 = x6[x9];
return x10;
}
/*@
requires \valid(x15);
assigns \nothing;
ensures (\result==x15[0]);
*/
int pick_first(int * x15) {
int x17 = x15[0];
return x17;
}
| 16 |
/* Tested with:
* * Frama-C Aluminium
* * Alt-Ergo 1.01
* * Why3 platform, version 0.87.3
* */
#include <stdbool.h>
#define MAXV 1000000
/*@ requires 1 <= N <= 1000000;
@ requires \valid(a + (0..N-1));
@ requires \forall integer j; 0 <= j < 1000000 ==> 1 <= a[j] <= N;
@ ensures
@ \forall integer i, j; 0 <= i < 1000000 && 0 <= j < 1000000 && a[i] != a[j] ==> \result == 0 ||
@ \exists integer i, j; 0 <= i < 1000000 && 0 <= j < 1000000 && a[i] == a[j] ==> \result == a[i];
@*/
int findDouble(int N, int a[]) {
bool f[MAXV];
/*@ loop invariant 1 <= i <= (MAXV+1);
@ loop invariant \forall integer j; 1 <= j < i ==> f[j-1] == false;
@ loop assigns i, f[0..(MAXV-1)];
@ loop variant MAXV - i + 1;
@*/
for(int i = 1; i <= MAXV; ++i)
f[i - 1] = false;
/*@ loop invariant 0 <= i <= N;
@ loop invariant \forall integer j; 0 <= j < i ==> f[a[j] - 1] == true;
@ loop assigns i, f[0..N-1];
@ loop variant N - i;
@*/
for(int i = 0; i < N; ++i)
if (f[a[i] - 1]) return a[i]; else f[a[i] - 1] = true;
return 0;
}
| 34 |
/*@
requires \valid_read(a) && \valid_read(b);
requires \separated(a, b);
assigns \nothing;
ensures \result >= *a && \result >= *b;
ensures \result == *a && \result == *b;
*/
int max_ptr(int *a, int *b){
return (*a < *b) ? *b : *a ;
}
extern int h;
int main() {
h = 42;
int a = 24;
int b = 42;
int x = max_ptr(&a, &b);
//@ assert x == 42;
//@ assert h == 42;
}
| 34 |
struct list {
int hd;
struct list *next;
};
/*@ inductive reachable{L}(struct list *root, struct list *to) {
@ case empty: \forall struct list *l; reachable(l,l);
@ case non_empty: \forall struct list *l1, *l2; \valid(l1) && reachable(l1->next, l2) ==> reachable(l1, l2);
@ }
*/
/*@ requires reachable(p, \null);
assigns { q->hd | struct list *q; reachable(p,q)};
*/
void incr_list(struct list *p)
{
while (p) { p->hd++; p = p->next;}
}
| 34 |
struct counter
{int seconds,minutes,hours;};
struct counter c;
/*@
requires 0<=c.seconds<60 && 0<=c.minutes<60 && 0<=c.hours<24;
behavior one:
assumes c.seconds < 59 && c.minutes < 59;
ensures c.seconds == \old(c.seconds)+1;
behavior two:
assumes c.seconds == 59 && c.minutes < 59;
ensures c.seconds == 0;
ensures c.minutes == \old(c.minutes)+1;
behavior three:
assumes c.seconds < 59 && c.minutes == 59;
ensures c.seconds == \old(c.seconds)+1;
behavior four:
assumes c.seconds == 59 && c.minutes == 59 && c.hours < 23 ;
ensures c.seconds == 0;
ensures c.minutes == 0;
ensures c.hours == \old(c.hours)+1;
behavior five:
assumes c.seconds == 59 && c.minutes == 59 && c.hours == 23 ;
ensures c.seconds == 0;
ensures c.minutes == 0;
ensures c.hours == 0;
complete behaviors;
disjoint behaviors;
*/
void tick() {
if (c.seconds<59)
c.seconds++;
else {
c.seconds = (c.seconds+1)%60;
if (c.minutes < 59)
c.minutes++;
else
c.minutes = (c.minutes+1)%60;
if(c.hours <23)
c.hours++;
else
c.hours=0;
}
}
| 19 |
/*@ assigns \nothing;
ensures \result == (a + b) / 2;
*/
int avr(int a, int b)
{
int avr;
if (a >= 0 && b >= 0) {
if (b > a) {
avr = a + (b - a) / 2;
} else {
avr = b + (a - b) / 2;
}
} else if (a < 0 && b < 0) {
if (b > a) {
avr = b + (a - b) / 2;
} else {
avr = a + (b - a) / 2;
}
} else {
avr = (a + b) / 2;
}
return avr;
}
| 26 |
/* Generated by Frama-C */
typedef unsigned long size_t;
struct __e_acsl_mpz_struct {
int _mp_alloc ;
int _mp_size ;
unsigned long *_mp_d ;
};
typedef struct __e_acsl_mpz_struct __e_acsl_mpz_struct;
typedef __e_acsl_mpz_struct ( __attribute__((__FC_BUILTIN__)) __e_acsl_mpz_t)[1];
struct __e_acsl_mpq_struct {
__e_acsl_mpz_struct _mp_num ;
__e_acsl_mpz_struct _mp_den ;
};
typedef struct __e_acsl_mpq_struct __e_acsl_mpq_struct;
typedef __e_acsl_mpq_struct ( __attribute__((__FC_BUILTIN__)) __e_acsl_mpq_t)[1];
typedef struct _IO_FILE FILE;
/*@ ghost extern int __e_acsl_init; */
extern size_t __e_acsl_heap_allocation_size;
typedef unsigned short __uint16_t;
typedef unsigned int __uint32_t;
typedef unsigned long __uint64_t;
typedef long __off_t;
typedef long __off64_t;
struct _IO_FILE;
typedef void _IO_lock_t;
struct _IO_marker {
struct _IO_marker *_next ;
struct _IO_FILE *_sbuf ;
int _pos ;
};
struct _IO_FILE {
int _flags ;
char *_IO_read_ptr ;
char *_IO_read_end ;
char *_IO_read_base ;
char *_IO_write_base ;
char *_IO_write_ptr ;
char *_IO_write_end ;
char *_IO_buf_base ;
char *_IO_buf_end ;
char *_IO_save_base ;
char *_IO_backup_base ;
char *_IO_save_end ;
struct _IO_marker *_markers ;
struct _IO_FILE *_chain ;
int _fileno ;
int _flags2 ;
__off_t _old_offset ;
unsigned short _cur_column ;
signed char _vtable_offset ;
char _shortbuf[1] ;
_IO_lock_t *_lock ;
__off64_t _offset ;
void *__pad1 ;
void *__pad2 ;
void *__pad3 ;
void *__pad4 ;
size_t __pad5 ;
int _mode ;
char _unused2[((unsigned long)15 * sizeof(int) - (unsigned long)4 * sizeof(void *)) - sizeof(size_t)] ;
};
/* compiler builtin:
unsigned int __builtin_bswap32(unsigned int); */
/* compiler builtin:
unsigned long __builtin_bswap64(unsigned long); */
__inline static unsigned int __bswap_32(unsigned int __bsx)
{
unsigned int tmp;
tmp = __builtin_bswap32(__bsx);
return tmp;
}
__inline static __uint64_t __bswap_64(__uint64_t __bsx)
{
__uint64_t tmp;
tmp = __builtin_bswap64(__bsx);
return tmp;
}
__inline static __uint16_t __uint16_identity(__uint16_t __x)
{
return __x;
}
__inline static __uint32_t __uint32_identity(__uint32_t __x)
{
return __x;
}
__inline static __uint64_t __uint64_identity(__uint64_t __x)
{
return __x;
}
/*@
predicate diffSize{L1, L2}(ℤ i) =
\at(__e_acsl_heap_allocation_size,L1) -
\at(__e_acsl_heap_allocation_size,L2) ≡ i;
*/
extern __attribute__((__FC_BUILTIN__)) int ( /* missing proto */ __e_acsl_memory_init)(
int *x_0, char ***x_1, unsigned long x_2);
extern __attribute__((__FC_BUILTIN__)) int ( /* missing proto */ __e_acsl_store_block)(
void *x_0, unsigned long x_1);
extern __attribute__((__FC_BUILTIN__)) int ( /* missing proto */ __e_acsl_full_init)(
void *x_0);
extern __attribute__((__FC_BUILTIN__)) int ( /* missing proto */ __e_acsl_delete_block)(
void *x_0);
extern __attribute__((__FC_BUILTIN__)) int ( /* missing proto */ __e_acsl_memory_clean)(
void);
int main(int argc, char **argv)
{
int __retres;
__e_acsl_memory_init(& argc,& argv,8UL);
__e_acsl_memory_init(& argc,& argv,8UL);
__e_acsl_store_block((void *)(& argc),4UL);
{
int *p;
__e_acsl_store_block((void *)(& p),8UL);
__e_acsl_store_block((void *)(& p),8UL);
switch (argc) {
default: ;
__e_acsl_full_init((void *)(& p));
__e_acsl_full_init((void *)(& p));
p = & argc;
break;
}
__e_acsl_delete_block((void *)(& p));
__e_acsl_delete_block((void *)(& p));
}
__retres = 0;
__e_acsl_delete_block((void *)(& argc));
__e_acsl_memory_clean();
__e_acsl_delete_block((void *)(& argc));
__e_acsl_memory_clean();
return __retres;
}
| 13 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.