From 51b9292253d5d6872eb81639b16149b8a84a65ff Mon Sep 17 00:00:00 2001 From: michael-mahoney Date: Tue, 27 May 2014 00:30:57 -0400 Subject: [PATCH 01/29] Update ptranal.ml Change (&) to (&&) in line 287 --- src/ext/pta/ptranal.ml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ext/pta/ptranal.ml b/src/ext/pta/ptranal.ml index 3e9d33e6f..f9826a8ad 100644 --- a/src/ext/pta/ptranal.ml +++ b/src/ext/pta/ptranal.ml @@ -284,7 +284,7 @@ let analyze_instr (i : instr ) : unit = List.iter (fun e -> ignore (analyze_expr e)) actuals else (* todo : check to see if the thing is an undefined function *) let fnres, site = - if is_undefined_fun fexpr & !conservative_undefineds then + if is_undefined_fun fexpr && !conservative_undefineds then A.apply_undefined (Util.list_map analyze_expr actuals) else A.apply (analyze_expr fexpr) (Util.list_map analyze_expr actuals) From bfa78b17cf130b5e9aa95c51e0705b807f57685b Mon Sep 17 00:00:00 2001 From: Michael Mahoney Date: Tue, 27 May 2014 00:35:01 -0400 Subject: [PATCH 02/29] Change (&) to (&&) in line 287 --- ocamleditor | 1 + 1 file changed, 1 insertion(+) create mode 160000 ocamleditor diff --git a/ocamleditor b/ocamleditor new file mode 160000 index 000000000..5aba504b2 --- /dev/null +++ b/ocamleditor @@ -0,0 +1 @@ +Subproject commit 5aba504b2dd1f9401fae06cc23bd61f3c13e44de From 6cd55babf7c1f1227586525378a30f4471427eac Mon Sep 17 00:00:00 2001 From: L33t Hax0r Date: Mon, 2 Jun 2014 13:16:48 -0400 Subject: [PATCH 03/29] New example that prints out the highest integer value --- test/oblivc/highest/highest.c | 40 ++++++++++++++++++++++++++++++++++ test/oblivc/highest/highest.h | 15 +++++++++++++ test/oblivc/highest/highest.oc | 35 +++++++++++++++++++++++++++++ 3 files changed, 90 insertions(+) create mode 100644 test/oblivc/highest/highest.c create mode 100644 test/oblivc/highest/highest.h create mode 100644 test/oblivc/highest/highest.oc diff --git a/test/oblivc/highest/highest.c b/test/oblivc/highest/highest.c new file mode 100644 index 000000000..985f67107 --- /dev/null +++ b/test/oblivc/highest/highest.c @@ -0,0 +1,40 @@ +#include +#include + +#include "highest.h" + +int currentParty; + +const char* mySide() +{ + if(currentParty==1) return "Generator"; + else return "Evaluator"; +} + +int main(int argc,char *argv[]) +{ + + ProtocolDesc pd; + protocolIO io; + if(argc<3) + { if(argc<2) fprintf(stderr,"Party missing\n"); + else fprintf(stderr,"string missing\n"); + fprintf(stderr,"Usage: %s <1|2> \n",argv[0]); + return 1; + } + io.n = argc-2; + + int g = atoi("15"); + int j; + for(j = 0; j +#include + +#include "highest.h" + +void readValues(obliv int* dest, int n, const int* src,int party) +{ + OblivInputs specs[MAXN]; + int i; + for(i=0;in); + n2 = ocBroadcastInt(2, io->n); + readValues(i1, n1, io->i, 1); + readValues(i2, n2, io->i, 2); + + obliv int high = i1[0]; + for(i=0; i high) + high = i1[i]; + } + for(j =0; j high) + high = i2[j]; + } + revealOblivInt(&io->res,high,0); +} \ No newline at end of file From de337a3a296f09b9d43d99a8b4bd942eac6f73a3 Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Mon, 2 Jun 2014 14:24:06 -0400 Subject: [PATCH 04/29] Create README.txt --- test/oblivc/highest/README.txt | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 test/oblivc/highest/README.txt diff --git a/test/oblivc/highest/README.txt b/test/oblivc/highest/README.txt new file mode 100644 index 000000000..86ab5b554 --- /dev/null +++ b/test/oblivc/highest/README.txt @@ -0,0 +1,9 @@ +Prints out the highest value that is entered by two parties on the command line + +# compile using our GCC wrapper +/path/to/oblivcc highest.c highest.oc -I . +# run: party 1 enters the numbers 1,2, and 3 and party 2 entered the numbers 2,4, and 6 +cycle './a.out 1 1 2 3 | ./a.out 2 2 4 6' +#this result will be 6 + +The cycle command is a handy bash script that you can find at https://github.com/samee/cmd From a36ad0c7007b373f634a0d23c2201beecbf01e52 Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Mon, 2 Jun 2014 14:32:32 -0400 Subject: [PATCH 05/29] Added comments to highest.c --- test/oblivc/highest/highest.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/test/oblivc/highest/highest.c b/test/oblivc/highest/highest.c index 985f67107..3a8716399 100644 --- a/test/oblivc/highest/highest.c +++ b/test/oblivc/highest/highest.c @@ -13,28 +13,32 @@ const char* mySide() int main(int argc,char *argv[]) { - + //these variables are used everytime ProtocolDesc pd; protocolIO io; + + //checking that the input has the correct number of variables if(argc<3) { if(argc<2) fprintf(stderr,"Party missing\n"); else fprintf(stderr,"string missing\n"); fprintf(stderr,"Usage: %s <1|2> \n",argv[0]); return 1; } + + //sets the size of the array io.n = argc-2; - - int g = atoi("15"); + //the the values in the array to the input values int j; for(j = 0; j Date: Mon, 2 Jun 2014 14:46:57 -0400 Subject: [PATCH 06/29] Added comments to highest.oc --- test/oblivc/highest/highest.oc | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/test/oblivc/highest/highest.oc b/test/oblivc/highest/highest.oc index 1b91002ff..41209e6cb 100644 --- a/test/oblivc/highest/highest.oc +++ b/test/oblivc/highest/highest.oc @@ -16,12 +16,11 @@ void highest(void* args){ int n1, n2; int i, j; obliv int i1[MAXN], i2[MAXN]; - n1 = ocBroadcastInt(1, io->n); n2 = ocBroadcastInt(2, io->n); readValues(i1, n1, io->i, 1); readValues(i2, n2, io->i, 2); - + //runs the actual algorithm of higher value obliv int high = i1[0]; for(i=0; i high) From f04b9bc00bb98119a4e997a82d5c84d7da698ada Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Thu, 5 Jun 2014 17:05:20 -0400 Subject: [PATCH 07/29] Made the number of integers secretive --- test/oblivc/highest/highest.oc | 33 +++++++++++++++++++-------------- 1 file changed, 19 insertions(+), 14 deletions(-) diff --git a/test/oblivc/highest/highest.oc b/test/oblivc/highest/highest.oc index 41209e6cb..c3c8433f4 100644 --- a/test/oblivc/highest/highest.oc +++ b/test/oblivc/highest/highest.oc @@ -2,31 +2,36 @@ #include #include "highest.h" - -void readValues(obliv int* dest, int n, const int* src,int party) +//dest is the pointer to the array of obliv ints +//n is the size of the array +//src is where the data is coming from +void readValues(obliv int* dest,const int* src,int party) { OblivInputs specs[MAXN]; int i; - for(i=0;in); - n2 = ocBroadcastInt(2, io->n); - readValues(i1, n1, io->i, 1); - readValues(i2, n2, io->i, 2); + n1 = feedOblivInt(io->n, 1); + n2 = feedOblivInt(io->n, 2); + readValues(i1,io->i, 1); + readValues(i2,io->i, 2); //runs the actual algorithm of higher value obliv int high = i1[0]; - for(i=0; i high) - high = i1[i]; + for(k=0; k high) + high = i1[k]; } - for(j =0; j high) high = i2[j]; } From f59326b0082f4808001ef8987982e3eeb523820e Mon Sep 17 00:00:00 2001 From: Michael Mahoney Date: Thu, 5 Jun 2014 17:14:49 -0400 Subject: [PATCH 08/29] June 5 commit --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 50f8f8c97..355c40da7 100644 --- a/README.md +++ b/README.md @@ -7,3 +7,5 @@ Once in the source folder, a simple `./configure && make` should build it all. T Most of this code was forked from the project CIL (C Intermediate Language). You can diff with the master branch to see which part was added on later. Finally, if you have any questions, either open an issue here on GitHub or just send me an email at samee@virginia.edu. + +This is a practice edit to the readme file. From 4003f374fb76c10c851f877f83d2d8e8e4e653db Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Mon, 9 Jun 2014 16:32:48 -0400 Subject: [PATCH 09/29] Update README.md --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index 50f8f8c97..e246069da 100644 --- a/README.md +++ b/README.md @@ -2,6 +2,9 @@ Obliv-C Compiler (`oblivcc`) ============================ This readme is still under construction. But there is already a language tutorial at http://goo.gl/TXzxD0 + +This requires libgcrypt to run. this can be downloaded on Ubuntu with `sudo apt-get install libgcrypt` then it also requires libgcrypt11-dev, which can be downlaoded with `sudo apt-get install libgcrypt11-dev`. + Once in the source folder, a simple `./configure && make` should build it all. The compiler is a GCC wrapper script found in `bin/oblivcc`. Example codes are in `test/oblivc` Most of this code was forked from the project CIL (C Intermediate Language). You can diff with the master branch to see which part was added on later. From 4127f72ca3b891b2c160361aca4c2c2731d56411 Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Tue, 10 Jun 2014 15:03:11 -0400 Subject: [PATCH 10/29] Private Set Intersection Example --- test/oblivc/mutual/Makefile | 5 ++ test/oblivc/mutual/alice1.txt | 43 ++++++++++++ test/oblivc/mutual/bob1.txt | 41 ++++++++++++ test/oblivc/mutual/mutual.c | 86 ++++++++++++++++++++++++ test/oblivc/mutual/mutual.h | 18 +++++ test/oblivc/mutual/mutual.oc | 96 +++++++++++++++++++++++++++ test/oblivc/mutual/mutualStringTest.c | 62 +++++++++++++++++ 7 files changed, 351 insertions(+) create mode 100644 test/oblivc/mutual/Makefile create mode 100644 test/oblivc/mutual/alice1.txt create mode 100644 test/oblivc/mutual/bob1.txt create mode 100644 test/oblivc/mutual/mutual.c create mode 100644 test/oblivc/mutual/mutual.h create mode 100644 test/oblivc/mutual/mutual.oc create mode 100644 test/oblivc/mutual/mutualStringTest.c diff --git a/test/oblivc/mutual/Makefile b/test/oblivc/mutual/Makefile new file mode 100644 index 000000000..62c09f532 --- /dev/null +++ b/test/oblivc/mutual/Makefile @@ -0,0 +1,5 @@ +all: + ~/obliv-c/bin/oblivcc mutual.c mutual.oc -I ./ -lrt + +test: + ./cycle './a.out 1 alice1.txt | ./a.out 2 bob1.txt' diff --git a/test/oblivc/mutual/alice1.txt b/test/oblivc/mutual/alice1.txt new file mode 100644 index 000000000..300576527 --- /dev/null +++ b/test/oblivc/mutual/alice1.txt @@ -0,0 +1,43 @@ +Bob +Stu +Joe +Tom +Greg +Karl +Fred +Eric +Mark +Evan +Michael +L +M +N +O +P +Q +R +S +T +U +V +W +X +Y +Z +AA +BB +CC +DD +EE +FF +GG +HH +II +JJ +KK +LL +MM +NN +OO +PP +QQ diff --git a/test/oblivc/mutual/bob1.txt b/test/oblivc/mutual/bob1.txt new file mode 100644 index 000000000..e1060a154 --- /dev/null +++ b/test/oblivc/mutual/bob1.txt @@ -0,0 +1,41 @@ +Alice +Stu +Joe +Jairus +Collis +Mark +Michael +A +B +C +D +E +F +G +H +I +J +K +L +M +N +O +U +V +AA +BB +CC +DD +EE +FF +GG +HH +II +JJ +KK +LL +MM +NN +OO +PP +QQ diff --git a/test/oblivc/mutual/mutual.c b/test/oblivc/mutual/mutual.c new file mode 100644 index 000000000..f32337883 --- /dev/null +++ b/test/oblivc/mutual/mutual.c @@ -0,0 +1,86 @@ +#include +#include +#include +#include +#include + +#include "mutual.h" + +int currentParty; + +void merge(int start, int end, int mid, char* list){ + +} + +void mergesort(int start, int end, char* list){ + if(start>=end) + return; + int mid = (start + end) / 2; + mergesort(start, mid, list); + mergesort(mid+1, end, list); + merge(start, end, mid, list); +} + +const char* mySide() +{ + if(currentParty==1) return "Generator"; + else return "Evaluator"; +} + +double wallClock() +{ + struct timespec t; + int i = clock_gettime(CLOCK_REALTIME,&t); + return t.tv_sec+1e-9*t.tv_nsec; +} +double lap; + +int main(int argc,char *argv[]) +{ + //these variables are used everytime + ProtocolDesc pd; + protocolIO io; + + //checking that the input has the correct number of variables + if(argc<3) + { if(argc<2) fprintf(stderr,"Party missing\n"); + else fprintf(stderr,"friends missing\n"); + fprintf(stderr,"Usage: %s <1|2> \n",argv[0]); + return 1; + } + FILE *infile; + infile = fopen(argv[2], "r"); + if(infile==NULL){ + //Error("Unable to open file"); + fprintf(stderr, "ERROR!"); + return 1; + } + //TODO change input file so that it says how many friends there are + int i=0; + char buf[MAXN][MAXL]; + while(fgets(buf[i], MAXL, infile)!=NULL){ + strcpy(io.mine[i], buf[i]); + i++; + //buf[i] = malloc(20*sizeof(char)); + } + io.size = i; + fprintf(stderr,"Result: %d\n", io.size); + + fclose(infile); + //standard setup + protocolUseStdio(&pd); + currentParty = (argv[1][0]=='1'?1:2); + setCurrentParty(&pd,currentParty); + setCurrentParty(&pd,currentParty); + lap = wallClock(); + execYaoProtocol(&pd,mutualFriends,&io); + //execDebugProtocol(&pd,mutualFriends, &io); + fprintf(stderr,"%s total time: %lf s\n",mySide(),wallClock()-lap); + fprintf(stderr,"Gate Count: %u\n",yaoGateCount()); + cleanupProtocol(&pd); + fprintf(stderr, "Result: %d %c\n", io.commonSize, io.common[0][0]); + for(i=0; i +#include +#include + +#include "mutual.h" + +typedef obliv bool obool; + +obool oblivStrCmp(obliv char* s1, obliv char* s2) obliv{ + //return true; + obliv bool afternull = false; + int i; + obool ob = true; + //return ob; + for( i = 0; i < MAXL; i++) { + obliv + if (afternull) { + ; + } else { + obliv char c = s1[i]; + obliv if (c != s2[i]) { + ob = false; + } else { + obliv if (c == '\0') { + afternull = true; + } + } + } + } + + //return ob; + //ob = true; + return ob; +} + +void addString(obliv char* src, obliv char* dest) obliv{ + int i; + for(i=0; isize); + size2 = ocBroadcastInt(2, io->size); + for(i=0;imine[i][j], 1); + } + } + for(i=0; imine[i][j], 2); + + for( i=0; icommonSize, commonSize, 0); + for(i=0; icommon[i][j],commonFriends[i][j],0); + }} +} diff --git a/test/oblivc/mutual/mutualStringTest.c b/test/oblivc/mutual/mutualStringTest.c new file mode 100644 index 000000000..84d487d7a --- /dev/null +++ b/test/oblivc/mutual/mutualStringTest.c @@ -0,0 +1,62 @@ +#include +#include +#include +#include + +void cmp(char* s1, char* s2){ + +} +int main(int argc, char* argv[]){ + char* s1 = "Bob"; + char s2[6] = "Joe"; + char s3[10] = "Ricky"; + char* s4; + char s5[10]; + char ss1[20][20]; + s4 = s3;//valid for pointer = array + //s3 = s2; //illegal because s3 is an array and s2 is a pointer + //s2 = s3; //illegal views s3 as a pointer and s2 as an array + //can use strcpy for these!!! + s3[1] ='!'; + s4 = "Bobby!!!"; + //s4[2] = '!'; //SEG FAULT + s1 = s4; //valid for pointer to pointer + //s2 = s1; //illegal! views s1 as a pointer + //s2 = *s1;//illegal! views s1 as a char + //*s1 = *s2;//creates a segfault + //s5 = s2; //illegal! + strcpy(s5, s2);//valid for array to array IFFFFF Array has enough space + //s4 =s2; + strcpy(s2, s4);//Valid for array to pointer if array has enough space + int i; + for(i=0; s4[i]!='\0'; i++) + s2[i] = s4[i]; //Does the same thing as the cpy + strcpy(ss1[0], s1); + ss1[0][2]='1'; + printf("%s %s %s\n", s1, s2, ss1[0]); + i = 0; + strcpy(s3, "Boby"); + strcpy(ss1[1], s3); + bool b = true; + int c = 17; + char s6[20] = "Bo1by"; + strcpy(ss1[1], s6); + strcpy(ss1[0], s6); + cmp(ss1[0], s3); + int i1 = -1; + int i0 = -1; + for(i=0; i<20; i++){ + if(ss1[0][i]!=ss1[1][i] && i0 == -1 && i1 == -1){ + b = false; + } + if(ss1[0][i]=='\0' && i0 == -1) + i0 = i; + if(ss1[1][i]=='\0' && i1 == -1) + i1 = i; + } + if(i1!=i0) + b = false; + printf("%d %d %d\n", i,c, b); + printf("%s %s \n", ss1[0], ss1[1]); + return 0; +} From cf90c8bb14fb90071d3060651da24fa35be7d9b2 Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Tue, 10 Jun 2014 15:40:08 -0400 Subject: [PATCH 11/29] Trying alice --- test/oblivc/mutual/alice1.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/test/oblivc/mutual/alice1.txt b/test/oblivc/mutual/alice1.txt index 300576527..6c3459e74 100644 --- a/test/oblivc/mutual/alice1.txt +++ b/test/oblivc/mutual/alice1.txt @@ -41,3 +41,4 @@ NN OO PP QQ +ZZ From 6dc0ee7d4160ee741991afeeeeb6a9b9d403420a Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Tue, 10 Jun 2014 17:04:56 -0400 Subject: [PATCH 12/29] Was defining the type as an unsigned int --- src/ext/oblivc/obliv_bits.c | 8 ++++---- src/ext/oblivc/obliv_bits.h | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/ext/oblivc/obliv_bits.c b/src/ext/oblivc/obliv_bits.c index c0faf93a4..decf70aaa 100644 --- a/src/ext/oblivc/obliv_bits.c +++ b/src/ext/oblivc/obliv_bits.c @@ -184,8 +184,8 @@ static int sizeCheckSend(ProtocolTransport* pt,int dest,const void* s,size_t n) { int sent = osend(&((SizeCheckTransportAdapter*)pt)->pd,dest,s,n); if(sent==n) return n; else - { fprintf(stderr,"Was going to send %lu bytes to %d, sent %d\n", - n,dest,sent); + { fprintf(stderr,"Was going to send bytes to %d, sent %d\n", + dest,sent); if(sent<0) fprintf(stderr,"That means %s\n",strerror(sent)); exit(-1); } @@ -195,8 +195,8 @@ static int sizeCheckRecv(ProtocolTransport* pt,int src,void* s,size_t n) { int recv = orecv(&((SizeCheckTransportAdapter*)pt)->pd,src,s,n); if(recv==n) return n; else - { fprintf(stderr,"Was going to recv %lu bytes from %d, received %d\n", - n,src,recv); + { fprintf(stderr,"Was going to recv bytes from %d, received %d\n", + src,recv); if(recv<0) fprintf(stderr,"That means %s\n",strerror(recv)); exit(-1); } diff --git a/src/ext/oblivc/obliv_bits.h b/src/ext/oblivc/obliv_bits.h index 26eb916c4..73355359e 100644 --- a/src/ext/oblivc/obliv_bits.h +++ b/src/ext/oblivc/obliv_bits.h @@ -1,6 +1,6 @@ #ifndef OBLIV_BITS_H #define OBLIV_BITS_H -void* memset(void* s, int c, unsigned long n); // Hack, had to declare memset +//void* memset(void* s, int c, unsigned long n); // Hack, had to declare memset #include // size_t //#include // memset to zero #include From 1b4c2dca509c17d80ef54d28f3751c4baad3e040 Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Tue, 10 Jun 2014 17:14:58 -0400 Subject: [PATCH 13/29] Made changes to highest --- test/oblivc/highest/highest.h | 4 +--- test/oblivc/highest/highest.oc | 11 +++++------ 2 files changed, 6 insertions(+), 9 deletions(-) diff --git a/test/oblivc/highest/highest.h b/test/oblivc/highest/highest.h index 8618e93df..e03b51e19 100644 --- a/test/oblivc/highest/highest.h +++ b/test/oblivc/highest/highest.h @@ -4,12 +4,10 @@ typedef struct protocolIO { - int i[100]; + int i[MAXN]; int n; int res; } protocolIO; void highest(void* args); - -const char* mySide(); diff --git a/test/oblivc/highest/highest.oc b/test/oblivc/highest/highest.oc index c3c8433f4..edc189c9e 100644 --- a/test/oblivc/highest/highest.oc +++ b/test/oblivc/highest/highest.oc @@ -5,13 +5,12 @@ //dest is the pointer to the array of obliv ints //n is the size of the array //src is where the data is coming from -void readValues(obliv int* dest,const int* src,int party) +void readValues(obliv int* dest, int n, const int* src,int party) { OblivInputs specs[MAXN]; int i; - for( i = 0;in, 1); n2 = feedOblivInt(io->n, 2); - readValues(i1,io->i, 1); - readValues(i2,io->i, 2); + readValues(i1, MAXN, io->i, 1); + readValues(i2, MAXN, io->i, 2); //runs the actual algorithm of higher value obliv int high = i1[0]; for(k=0; k Date: Tue, 10 Jun 2014 17:51:14 -0400 Subject: [PATCH 14/29] Adding mutual files --- test/oblivc/mutual/mutual.c | 86 ++++++++++++++++++++++++++++++++ test/oblivc/mutual/mutual.h | 18 +++++++ test/oblivc/mutual/mutual.oc | 96 ++++++++++++++++++++++++++++++++++++ 3 files changed, 200 insertions(+) create mode 100644 test/oblivc/mutual/mutual.c create mode 100644 test/oblivc/mutual/mutual.h create mode 100644 test/oblivc/mutual/mutual.oc diff --git a/test/oblivc/mutual/mutual.c b/test/oblivc/mutual/mutual.c new file mode 100644 index 000000000..f32337883 --- /dev/null +++ b/test/oblivc/mutual/mutual.c @@ -0,0 +1,86 @@ +#include +#include +#include +#include +#include + +#include "mutual.h" + +int currentParty; + +void merge(int start, int end, int mid, char* list){ + +} + +void mergesort(int start, int end, char* list){ + if(start>=end) + return; + int mid = (start + end) / 2; + mergesort(start, mid, list); + mergesort(mid+1, end, list); + merge(start, end, mid, list); +} + +const char* mySide() +{ + if(currentParty==1) return "Generator"; + else return "Evaluator"; +} + +double wallClock() +{ + struct timespec t; + int i = clock_gettime(CLOCK_REALTIME,&t); + return t.tv_sec+1e-9*t.tv_nsec; +} +double lap; + +int main(int argc,char *argv[]) +{ + //these variables are used everytime + ProtocolDesc pd; + protocolIO io; + + //checking that the input has the correct number of variables + if(argc<3) + { if(argc<2) fprintf(stderr,"Party missing\n"); + else fprintf(stderr,"friends missing\n"); + fprintf(stderr,"Usage: %s <1|2> \n",argv[0]); + return 1; + } + FILE *infile; + infile = fopen(argv[2], "r"); + if(infile==NULL){ + //Error("Unable to open file"); + fprintf(stderr, "ERROR!"); + return 1; + } + //TODO change input file so that it says how many friends there are + int i=0; + char buf[MAXN][MAXL]; + while(fgets(buf[i], MAXL, infile)!=NULL){ + strcpy(io.mine[i], buf[i]); + i++; + //buf[i] = malloc(20*sizeof(char)); + } + io.size = i; + fprintf(stderr,"Result: %d\n", io.size); + + fclose(infile); + //standard setup + protocolUseStdio(&pd); + currentParty = (argv[1][0]=='1'?1:2); + setCurrentParty(&pd,currentParty); + setCurrentParty(&pd,currentParty); + lap = wallClock(); + execYaoProtocol(&pd,mutualFriends,&io); + //execDebugProtocol(&pd,mutualFriends, &io); + fprintf(stderr,"%s total time: %lf s\n",mySide(),wallClock()-lap); + fprintf(stderr,"Gate Count: %u\n",yaoGateCount()); + cleanupProtocol(&pd); + fprintf(stderr, "Result: %d %c\n", io.commonSize, io.common[0][0]); + for(i=0; i +#include +#include + +#include "mutual.h" + +typedef obliv bool obool; + +obool oblivStrCmp(obliv char* s1, obliv char* s2) obliv{ + //return true; + obliv bool afternull = false; + int i; + obool ob = true; + //return ob; + for( i = 0; i < MAXL; i++) { + obliv + if (afternull) { + ; + } else { + obliv char c = s1[i]; + obliv if (c != s2[i]) { + ob = false; + } else { + obliv if (c == '\0') { + afternull = true; + } + } + } + } + + //return ob; + //ob = true; + return ob; +} + +void addString(obliv char* src, obliv char* dest) obliv{ + int i; + for(i=0; isize); + size2 = ocBroadcastInt(2, io->size); + for(i=0;imine[i][j], 1); + } + } + for(i=0; imine[i][j], 2); + + for( i=0; icommonSize, commonSize, 0); + for(i=0; icommon[i][j],commonFriends[i][j],0); + }} +} From e6a5066201b481a4180d35e9b510256875054988 Mon Sep 17 00:00:00 2001 From: Michael Mahoney Date: Tue, 10 Jun 2014 17:57:37 -0400 Subject: [PATCH 15/29] Should add Alice and Bob --- README.md | 2 -- test/oblivc/editdist/editdist.c | 2 +- test/oblivc/highest/highest.oc | 2 +- test/oblivc/million/million.oc | 14 +++++++++----- 4 files changed, 11 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 355c40da7..50f8f8c97 100644 --- a/README.md +++ b/README.md @@ -7,5 +7,3 @@ Once in the source folder, a simple `./configure && make` should build it all. T Most of this code was forked from the project CIL (C Intermediate Language). You can diff with the master branch to see which part was added on later. Finally, if you have any questions, either open an issue here on GitHub or just send me an email at samee@virginia.edu. - -This is a practice edit to the readme file. diff --git a/test/oblivc/editdist/editdist.c b/test/oblivc/editdist/editdist.c index b4506095f..3bbfe57ad 100644 --- a/test/oblivc/editdist/editdist.c +++ b/test/oblivc/editdist/editdist.c @@ -17,7 +17,7 @@ const char* mySide() double wallClock() { struct timespec t; - clock_gettime(CLOCK_REALTIME,&t); + //clock_gettime(CLOCK_REALTIME,&t); return t.tv_sec+1e-9*t.tv_nsec; } diff --git a/test/oblivc/highest/highest.oc b/test/oblivc/highest/highest.oc index 41209e6cb..af54562df 100644 --- a/test/oblivc/highest/highest.oc +++ b/test/oblivc/highest/highest.oc @@ -31,4 +31,4 @@ void highest(void* args){ high = i2[j]; } revealOblivInt(&io->res,high,0); -} \ No newline at end of file +} diff --git a/test/oblivc/million/million.oc b/test/oblivc/million/million.oc index 3bb2b3cb9..610ebcbb4 100644 --- a/test/oblivc/million/million.oc +++ b/test/oblivc/million/million.oc @@ -6,12 +6,16 @@ void millionaire(void* args) protocolIO *io=args; obliv int v1,v2; bool eq,lt; + obliv int average; + int y; - v1 = feedOblivInt(io->mywealth,1); - v2 = feedOblivInt(io->mywealth,2); - revealOblivBool(&eq,v1==v2,0); - revealOblivBool(<,v1cmp = (!eq?lt?-1:1:0); + v1 = feedOblivInt(io->mywealth,1); //This is the first input + v2 = feedOblivInt(io->mywealth,2); //This is the second input + average = (v1+v2)/2; + revealOblivInt(&y,average,0); + revealOblivBool(&eq,v1==v2,0); //boolean comparing inputs (v1 and v2) + revealOblivBool(<,v1cmp = (!eq?lt?y:y:y); //This is the output (1<2):(1>2):(1=2) } From 2f5558a528d4e143d35a2a84ad3d60ba2ffc5906 Mon Sep 17 00:00:00 2001 From: Michael Mahoney Date: Tue, 10 Jun 2014 18:00:42 -0400 Subject: [PATCH 16/29] Adding average --- test/oblivc/average/average.c | 44 + test/oblivc/average/average.h | 15 + test/oblivc/average/average.oc | 34 + test/oblivc/mutual/Makefile | 5 + test/oblivc/mutual/alice1.txt | 44 + test/oblivc/mutual/bob1.txt | 41 + test/oblivc/mutual/mutual.oc.cil.c | 4865 +++++++++++++++++++++++ test/oblivc/mutual/mutual.oc.cil.i | 4517 +++++++++++++++++++++ test/oblivc/mutual/mutual.oc.i | 5220 +++++++++++++++++++++++++ test/oblivc/mutual/mutualStringTest.c | 62 + 10 files changed, 14847 insertions(+) create mode 100644 test/oblivc/average/average.c create mode 100644 test/oblivc/average/average.h create mode 100644 test/oblivc/average/average.oc create mode 100644 test/oblivc/mutual/Makefile create mode 100644 test/oblivc/mutual/alice1.txt create mode 100644 test/oblivc/mutual/bob1.txt create mode 100644 test/oblivc/mutual/mutual.oc.cil.c create mode 100644 test/oblivc/mutual/mutual.oc.cil.i create mode 100644 test/oblivc/mutual/mutual.oc.i create mode 100644 test/oblivc/mutual/mutualStringTest.c diff --git a/test/oblivc/average/average.c b/test/oblivc/average/average.c new file mode 100644 index 000000000..a6ee18c35 --- /dev/null +++ b/test/oblivc/average/average.c @@ -0,0 +1,44 @@ +#include +#include + +#include "average.h" + +int currentParty; + +const char* mySide() +{ + if(currentParty==1) return "Generator"; + else return "Evaluator"; +} + +int main(int argc,char *argv[]) +{ + //these variables are used everytime + ProtocolDesc pd; + protocolIO io; + + //checking that the input has the correct number of variables + if(argc<3) + { if(argc<2) fprintf(stderr,"Party missing\n"); + else fprintf(stderr,"string missing\n"); + fprintf(stderr,"Usage: %s <1|2> \n",argv[0]); + return 1; + } + + //sets the size of the array + io.n = argc-2; + //the the values in the array to the input values + int j; + for(j = 0; j +#include + +#include "average.h" + +void readValues(obliv int* dest, int n, const int* src,int party) +{ + OblivInputs specs[MAXN]; + int i; + for(i=0;in); + n2 = ocBroadcastInt(2, io->n); + readValues(i1, n1, io->i, 1); + readValues(i2, n2, io->i, 2); + //runs the actual algorithm to find average + for(i=0; ires,average,0); +} diff --git a/test/oblivc/mutual/Makefile b/test/oblivc/mutual/Makefile new file mode 100644 index 000000000..62c09f532 --- /dev/null +++ b/test/oblivc/mutual/Makefile @@ -0,0 +1,5 @@ +all: + ~/obliv-c/bin/oblivcc mutual.c mutual.oc -I ./ -lrt + +test: + ./cycle './a.out 1 alice1.txt | ./a.out 2 bob1.txt' diff --git a/test/oblivc/mutual/alice1.txt b/test/oblivc/mutual/alice1.txt new file mode 100644 index 000000000..6c3459e74 --- /dev/null +++ b/test/oblivc/mutual/alice1.txt @@ -0,0 +1,44 @@ +Bob +Stu +Joe +Tom +Greg +Karl +Fred +Eric +Mark +Evan +Michael +L +M +N +O +P +Q +R +S +T +U +V +W +X +Y +Z +AA +BB +CC +DD +EE +FF +GG +HH +II +JJ +KK +LL +MM +NN +OO +PP +QQ +ZZ diff --git a/test/oblivc/mutual/bob1.txt b/test/oblivc/mutual/bob1.txt new file mode 100644 index 000000000..e1060a154 --- /dev/null +++ b/test/oblivc/mutual/bob1.txt @@ -0,0 +1,41 @@ +Alice +Stu +Joe +Jairus +Collis +Mark +Michael +A +B +C +D +E +F +G +H +I +J +K +L +M +N +O +U +V +AA +BB +CC +DD +EE +FF +GG +HH +II +JJ +KK +LL +MM +NN +OO +PP +QQ diff --git a/test/oblivc/mutual/mutual.oc.cil.c b/test/oblivc/mutual/mutual.oc.cil.c new file mode 100644 index 000000000..855a4c938 --- /dev/null +++ b/test/oblivc/mutual/mutual.oc.cil.c @@ -0,0 +1,4865 @@ +/* Generated by CIL v. 1.6.0 */ +/* print_CIL_Input is true */ + +#line 150 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" +typedef long ptrdiff_t; +#line 212 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" +typedef unsigned long size_t; +#line 324 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" +typedef int wchar_t; +#line 37 "/usr/include/stdint.h" +typedef signed char int8_t; +#line 38 "/usr/include/stdint.h" +typedef short int16_t; +#line 39 "/usr/include/stdint.h" +typedef int int32_t; +#line 41 "/usr/include/stdint.h" +typedef long int64_t; +#line 49 "/usr/include/stdint.h" +typedef unsigned char uint8_t; +#line 50 "/usr/include/stdint.h" +typedef unsigned short uint16_t; +#line 52 "/usr/include/stdint.h" +typedef unsigned int uint32_t; +#line 56 "/usr/include/stdint.h" +typedef unsigned long uint64_t; +#line 66 "/usr/include/stdint.h" +typedef signed char int_least8_t; +#line 67 "/usr/include/stdint.h" +typedef short int_least16_t; +#line 68 "/usr/include/stdint.h" +typedef int int_least32_t; +#line 70 "/usr/include/stdint.h" +typedef long int_least64_t; +#line 77 "/usr/include/stdint.h" +typedef unsigned char uint_least8_t; +#line 78 "/usr/include/stdint.h" +typedef unsigned short uint_least16_t; +#line 79 "/usr/include/stdint.h" +typedef unsigned int uint_least32_t; +#line 81 "/usr/include/stdint.h" +typedef unsigned long uint_least64_t; +#line 91 "/usr/include/stdint.h" +typedef signed char int_fast8_t; +#line 93 "/usr/include/stdint.h" +typedef long int_fast16_t; +#line 94 "/usr/include/stdint.h" +typedef long int_fast32_t; +#line 95 "/usr/include/stdint.h" +typedef long int_fast64_t; +#line 104 "/usr/include/stdint.h" +typedef unsigned char uint_fast8_t; +#line 106 "/usr/include/stdint.h" +typedef unsigned long uint_fast16_t; +#line 107 "/usr/include/stdint.h" +typedef unsigned long uint_fast32_t; +#line 108 "/usr/include/stdint.h" +typedef unsigned long uint_fast64_t; +#line 120 "/usr/include/stdint.h" +typedef long intptr_t; +#line 123 "/usr/include/stdint.h" +typedef unsigned long uintptr_t; +#line 135 "/usr/include/stdint.h" +typedef long intmax_t; +#line 136 "/usr/include/stdint.h" +typedef unsigned long uintmax_t; +#line 67 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" +struct __anonstruct___wait_terminated_1 { + unsigned int __w_termsig : 7 ; + unsigned int __w_coredump : 1 ; + unsigned int __w_retcode : 8 ; + unsigned int : 16 ; +}; +#line 67 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" +struct __anonstruct___wait_stopped_2 { + unsigned int __w_stopval : 8 ; + unsigned int __w_stopsig : 8 ; + unsigned int : 16 ; +}; +#line 67 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" +union wait { + int w_status ; + struct __anonstruct___wait_terminated_1 __wait_terminated ; + struct __anonstruct___wait_stopped_2 __wait_stopped ; +}; +#line 68 "/usr/include/stdlib.h" +union __anonunion___WAIT_STATUS_3 { + union wait *__uptr ; + int *__iptr ; +}; +#line 68 "/usr/include/stdlib.h" +typedef union __anonunion___WAIT_STATUS_3 __attribute__((__transparent_union__)) __WAIT_STATUS; +#line 98 "/usr/include/stdlib.h" +struct __anonstruct_div_t_4 { + int quot ; + int rem ; +}; +#line 98 "/usr/include/stdlib.h" +typedef struct __anonstruct_div_t_4 div_t; +#line 106 "/usr/include/stdlib.h" +struct __anonstruct_ldiv_t_5 { + long quot ; + long rem ; +}; +#line 106 "/usr/include/stdlib.h" +typedef struct __anonstruct_ldiv_t_5 ldiv_t; +#line 118 "/usr/include/stdlib.h" +struct __anonstruct_lldiv_t_6 { + long long quot ; + long long rem ; +}; +#line 118 "/usr/include/stdlib.h" +typedef struct __anonstruct_lldiv_t_6 lldiv_t; +#line 31 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned char __u_char; +#line 32 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned short __u_short; +#line 33 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __u_int; +#line 34 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __u_long; +#line 37 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef signed char __int8_t; +#line 38 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned char __uint8_t; +#line 39 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef short __int16_t; +#line 40 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned short __uint16_t; +#line 41 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef int __int32_t; +#line 42 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __uint32_t; +#line 44 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __int64_t; +#line 45 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __uint64_t; +#line 53 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __quad_t; +#line 54 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __u_quad_t; +#line 134 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __dev_t; +#line 135 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __uid_t; +#line 136 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __gid_t; +#line 137 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __ino_t; +#line 138 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __ino64_t; +#line 139 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __mode_t; +#line 140 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __nlink_t; +#line 141 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __off_t; +#line 142 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __off64_t; +#line 143 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef int __pid_t; +#line 144 "/usr/include/x86_64-linux-gnu/bits/types.h" +struct __anonstruct___fsid_t_7 { + int __val[2] ; +}; +#line 144 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef struct __anonstruct___fsid_t_7 __fsid_t; +#line 145 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __clock_t; +#line 146 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __rlim_t; +#line 147 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __rlim64_t; +#line 148 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __id_t; +#line 149 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __time_t; +#line 150 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __useconds_t; +#line 151 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __suseconds_t; +#line 153 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef int __daddr_t; +#line 154 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __swblk_t; +#line 155 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef int __key_t; +#line 158 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef int __clockid_t; +#line 161 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef void *__timer_t; +#line 164 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __blksize_t; +#line 169 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __blkcnt_t; +#line 170 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __blkcnt64_t; +#line 173 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __fsblkcnt_t; +#line 174 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __fsblkcnt64_t; +#line 177 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __fsfilcnt_t; +#line 178 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __fsfilcnt64_t; +#line 180 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __ssize_t; +#line 184 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef __off64_t __loff_t; +#line 185 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef __quad_t *__qaddr_t; +#line 186 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef char *__caddr_t; +#line 189 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __intptr_t; +#line 192 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __socklen_t; +#line 34 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __u_char u_char; +#line 35 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __u_short u_short; +#line 36 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __u_int u_int; +#line 37 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __u_long u_long; +#line 38 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __quad_t quad_t; +#line 39 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __u_quad_t u_quad_t; +#line 40 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __fsid_t fsid_t; +#line 45 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __loff_t loff_t; +#line 49 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __ino_t ino_t; +#line 61 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __dev_t dev_t; +#line 66 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __gid_t gid_t; +#line 71 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __mode_t mode_t; +#line 76 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __nlink_t nlink_t; +#line 81 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __uid_t uid_t; +#line 87 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __off_t off_t; +#line 99 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __pid_t pid_t; +#line 105 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __id_t id_t; +#line 110 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __ssize_t ssize_t; +#line 116 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __daddr_t daddr_t; +#line 117 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __caddr_t caddr_t; +#line 123 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __key_t key_t; +#line 60 "/usr/include/time.h" +typedef __clock_t clock_t; +#line 76 "/usr/include/time.h" +typedef __time_t time_t; +#line 92 "/usr/include/time.h" +typedef __clockid_t clockid_t; +#line 104 "/usr/include/time.h" +typedef __timer_t timer_t; +#line 151 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef unsigned long ulong; +#line 152 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef unsigned short ushort; +#line 153 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef unsigned int uint; +#line 201 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef unsigned char u_int8_t; +#line 202 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef unsigned short u_int16_t; +#line 203 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef unsigned int u_int32_t; +#line 204 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef unsigned long u_int64_t; +#line 206 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef int register_t; +#line 24 "/usr/include/x86_64-linux-gnu/bits/sigset.h" +typedef int __sig_atomic_t; +#line 29 "/usr/include/x86_64-linux-gnu/bits/sigset.h" +struct __anonstruct___sigset_t_8 { + unsigned long __val[(unsigned long )1024 / (unsigned long )((unsigned long )8 * (unsigned long )sizeof(unsigned long ))] ; +}; +#line 29 "/usr/include/x86_64-linux-gnu/bits/sigset.h" +typedef struct __anonstruct___sigset_t_8 __sigset_t; +#line 38 "/usr/include/x86_64-linux-gnu/sys/select.h" +typedef __sigset_t sigset_t; +#line 120 "/usr/include/time.h" +struct timespec { + __time_t tv_sec ; + long tv_nsec ; +}; +#line 31 "/usr/include/x86_64-linux-gnu/bits/time.h" +struct timeval { + __time_t tv_sec ; + __suseconds_t tv_usec ; +}; +#line 49 "/usr/include/x86_64-linux-gnu/sys/select.h" +typedef __suseconds_t suseconds_t; +#line 55 "/usr/include/x86_64-linux-gnu/sys/select.h" +typedef long __fd_mask; +#line 65 "/usr/include/x86_64-linux-gnu/sys/select.h" +struct __anonstruct_fd_set_9 { + __fd_mask __fds_bits[(int )1024 / (int )((int )8 * (int )((int )sizeof(__fd_mask )))] ; +}; +#line 65 "/usr/include/x86_64-linux-gnu/sys/select.h" +typedef struct __anonstruct_fd_set_9 fd_set; +#line 83 "/usr/include/x86_64-linux-gnu/sys/select.h" +typedef __fd_mask fd_mask; +#line 229 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __blksize_t blksize_t; +#line 236 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __blkcnt_t blkcnt_t; +#line 240 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __fsblkcnt_t fsblkcnt_t; +#line 244 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __fsfilcnt_t fsfilcnt_t; +#line 50 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef unsigned long pthread_t; +#line 53 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_attr_t_10 { + char __size[56] ; + long __align ; +}; +#line 53 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_attr_t_10 pthread_attr_t; +#line 61 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +struct __pthread_internal_list { + struct __pthread_internal_list *__prev ; + struct __pthread_internal_list *__next ; +}; +#line 61 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef struct __pthread_internal_list __pthread_list_t; +#line 76 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +struct __pthread_mutex_s { + int __lock ; + unsigned int __count ; + int __owner ; + unsigned int __nusers ; + int __kind ; + int __spins ; + __pthread_list_t __list ; +}; +#line 76 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_mutex_t_11 { + struct __pthread_mutex_s __data ; + char __size[40] ; + long __align ; +}; +#line 76 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_mutex_t_11 pthread_mutex_t; +#line 106 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_mutexattr_t_12 { + char __size[4] ; + int __align ; +}; +#line 106 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_mutexattr_t_12 pthread_mutexattr_t; +#line 115 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +struct __anonstruct___data_14 { + int __lock ; + unsigned int __futex ; + unsigned long long __total_seq ; + unsigned long long __wakeup_seq ; + unsigned long long __woken_seq ; + void *__mutex ; + unsigned int __nwaiters ; + unsigned int __broadcast_seq ; +}; +#line 115 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_cond_t_13 { + struct __anonstruct___data_14 __data ; + char __size[48] ; + long long __align ; +}; +#line 115 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_cond_t_13 pthread_cond_t; +#line 132 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_condattr_t_15 { + char __size[4] ; + int __align ; +}; +#line 132 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_condattr_t_15 pthread_condattr_t; +#line 140 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef unsigned int pthread_key_t; +#line 144 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef int pthread_once_t; +#line 150 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +struct __anonstruct___data_17 { + int __lock ; + unsigned int __nr_readers ; + unsigned int __readers_wakeup ; + unsigned int __writer_wakeup ; + unsigned int __nr_readers_queued ; + unsigned int __nr_writers_queued ; + int __writer ; + int __shared ; + unsigned long __pad1 ; + unsigned long __pad2 ; + unsigned int __flags ; +}; +#line 150 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_rwlock_t_16 { + struct __anonstruct___data_17 __data ; + char __size[56] ; + long __align ; +}; +#line 150 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_rwlock_t_16 pthread_rwlock_t; +#line 191 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_rwlockattr_t_18 { + char __size[8] ; + long __align ; +}; +#line 191 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_rwlockattr_t_18 pthread_rwlockattr_t; +#line 201 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef int volatile pthread_spinlock_t; +#line 206 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_barrier_t_19 { + char __size[32] ; + long __align ; +}; +#line 206 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_barrier_t_19 pthread_barrier_t; +#line 212 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_barrierattr_t_20 { + char __size[4] ; + int __align ; +}; +#line 212 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_barrierattr_t_20 pthread_barrierattr_t; +#line 349 "/usr/include/stdlib.h" +struct random_data { + int32_t *fptr ; + int32_t *rptr ; + int32_t *state ; + int rand_type ; + int rand_deg ; + int rand_sep ; + int32_t *end_ptr ; +}; +#line 418 "/usr/include/stdlib.h" +struct drand48_data { + unsigned short __x[3] ; + unsigned short __old_x[3] ; + unsigned short __c ; + unsigned short __init ; + unsigned long long __a ; +}; +#line 742 "/usr/include/stdlib.h" +typedef int (*__compar_fn_t)(void const * , void const * ); +#line 40 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stdarg.h" +typedef __builtin_va_list __gnuc_va_list; +#line 102 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stdarg.h" +typedef __gnuc_va_list va_list; +#line 28 "/usr/include/xlocale.h" +struct __locale_data; +#line 28 "/usr/include/xlocale.h" +struct __locale_struct { + struct __locale_data *__locales[13] ; + unsigned short const *__ctype_b ; + int const *__ctype_tolower ; + int const *__ctype_toupper ; + char const *__names[13] ; +}; +#line 28 "/usr/include/xlocale.h" +typedef struct __locale_struct *__locale_t; +#line 43 "/usr/include/xlocale.h" +typedef __locale_t locale_t; +#line 78 "/usr/include/gpg-error.h" +enum __anonenum_gpg_err_source_t_21 { + GPG_ERR_SOURCE_UNKNOWN = 0, + GPG_ERR_SOURCE_GCRYPT = 1, + GPG_ERR_SOURCE_GPG = 2, + GPG_ERR_SOURCE_GPGSM = 3, + GPG_ERR_SOURCE_GPGAGENT = 4, + GPG_ERR_SOURCE_PINENTRY = 5, + GPG_ERR_SOURCE_SCD = 6, + GPG_ERR_SOURCE_GPGME = 7, + GPG_ERR_SOURCE_KEYBOX = 8, + GPG_ERR_SOURCE_KSBA = 9, + GPG_ERR_SOURCE_DIRMNGR = 10, + GPG_ERR_SOURCE_GSTI = 11, + GPG_ERR_SOURCE_GPA = 12, + GPG_ERR_SOURCE_KLEO = 13, + GPG_ERR_SOURCE_G13 = 14, + GPG_ERR_SOURCE_ANY = 31, + GPG_ERR_SOURCE_USER_1 = 32, + GPG_ERR_SOURCE_USER_2 = 33, + GPG_ERR_SOURCE_USER_3 = 34, + GPG_ERR_SOURCE_USER_4 = 35, + GPG_ERR_SOURCE_DIM = 128 +} ; +#line 78 "/usr/include/gpg-error.h" +typedef enum __anonenum_gpg_err_source_t_21 gpg_err_source_t; +#line 110 +enum __anonenum_gpg_err_code_t_22 { + GPG_ERR_NO_ERROR = 0, + GPG_ERR_GENERAL = 1, + GPG_ERR_UNKNOWN_PACKET = 2, + GPG_ERR_UNKNOWN_VERSION = 3, + GPG_ERR_PUBKEY_ALGO = 4, + GPG_ERR_DIGEST_ALGO = 5, + GPG_ERR_BAD_PUBKEY = 6, + GPG_ERR_BAD_SECKEY = 7, + GPG_ERR_BAD_SIGNATURE = 8, + GPG_ERR_NO_PUBKEY = 9, + GPG_ERR_CHECKSUM = 10, + GPG_ERR_BAD_PASSPHRASE = 11, + GPG_ERR_CIPHER_ALGO = 12, + GPG_ERR_KEYRING_OPEN = 13, + GPG_ERR_INV_PACKET = 14, + GPG_ERR_INV_ARMOR = 15, + GPG_ERR_NO_USER_ID = 16, + GPG_ERR_NO_SECKEY = 17, + GPG_ERR_WRONG_SECKEY = 18, + GPG_ERR_BAD_KEY = 19, + GPG_ERR_COMPR_ALGO = 20, + GPG_ERR_NO_PRIME = 21, + GPG_ERR_NO_ENCODING_METHOD = 22, + GPG_ERR_NO_ENCRYPTION_SCHEME = 23, + GPG_ERR_NO_SIGNATURE_SCHEME = 24, + GPG_ERR_INV_ATTR = 25, + GPG_ERR_NO_VALUE = 26, + GPG_ERR_NOT_FOUND = 27, + GPG_ERR_VALUE_NOT_FOUND = 28, + GPG_ERR_SYNTAX = 29, + GPG_ERR_BAD_MPI = 30, + GPG_ERR_INV_PASSPHRASE = 31, + GPG_ERR_SIG_CLASS = 32, + GPG_ERR_RESOURCE_LIMIT = 33, + GPG_ERR_INV_KEYRING = 34, + GPG_ERR_TRUSTDB = 35, + GPG_ERR_BAD_CERT = 36, + GPG_ERR_INV_USER_ID = 37, + GPG_ERR_UNEXPECTED = 38, + GPG_ERR_TIME_CONFLICT = 39, + GPG_ERR_KEYSERVER = 40, + GPG_ERR_WRONG_PUBKEY_ALGO = 41, + GPG_ERR_TRIBUTE_TO_D_A = 42, + GPG_ERR_WEAK_KEY = 43, + GPG_ERR_INV_KEYLEN = 44, + GPG_ERR_INV_ARG = 45, + GPG_ERR_BAD_URI = 46, + GPG_ERR_INV_URI = 47, + GPG_ERR_NETWORK = 48, + GPG_ERR_UNKNOWN_HOST = 49, + GPG_ERR_SELFTEST_FAILED = 50, + GPG_ERR_NOT_ENCRYPTED = 51, + GPG_ERR_NOT_PROCESSED = 52, + GPG_ERR_UNUSABLE_PUBKEY = 53, + GPG_ERR_UNUSABLE_SECKEY = 54, + GPG_ERR_INV_VALUE = 55, + GPG_ERR_BAD_CERT_CHAIN = 56, + GPG_ERR_MISSING_CERT = 57, + GPG_ERR_NO_DATA = 58, + GPG_ERR_BUG = 59, + GPG_ERR_NOT_SUPPORTED = 60, + GPG_ERR_INV_OP = 61, + GPG_ERR_TIMEOUT = 62, + GPG_ERR_INTERNAL = 63, + GPG_ERR_EOF_GCRYPT = 64, + GPG_ERR_INV_OBJ = 65, + GPG_ERR_TOO_SHORT = 66, + GPG_ERR_TOO_LARGE = 67, + GPG_ERR_NO_OBJ = 68, + GPG_ERR_NOT_IMPLEMENTED = 69, + GPG_ERR_CONFLICT = 70, + GPG_ERR_INV_CIPHER_MODE = 71, + GPG_ERR_INV_FLAG = 72, + GPG_ERR_INV_HANDLE = 73, + GPG_ERR_TRUNCATED = 74, + GPG_ERR_INCOMPLETE_LINE = 75, + GPG_ERR_INV_RESPONSE = 76, + GPG_ERR_NO_AGENT = 77, + GPG_ERR_AGENT = 78, + GPG_ERR_INV_DATA = 79, + GPG_ERR_ASSUAN_SERVER_FAULT = 80, + GPG_ERR_ASSUAN = 81, + GPG_ERR_INV_SESSION_KEY = 82, + GPG_ERR_INV_SEXP = 83, + GPG_ERR_UNSUPPORTED_ALGORITHM = 84, + GPG_ERR_NO_PIN_ENTRY = 85, + GPG_ERR_PIN_ENTRY = 86, + GPG_ERR_BAD_PIN = 87, + GPG_ERR_INV_NAME = 88, + GPG_ERR_BAD_DATA = 89, + GPG_ERR_INV_PARAMETER = 90, + GPG_ERR_WRONG_CARD = 91, + GPG_ERR_NO_DIRMNGR = 92, + GPG_ERR_DIRMNGR = 93, + GPG_ERR_CERT_REVOKED = 94, + GPG_ERR_NO_CRL_KNOWN = 95, + GPG_ERR_CRL_TOO_OLD = 96, + GPG_ERR_LINE_TOO_LONG = 97, + GPG_ERR_NOT_TRUSTED = 98, + GPG_ERR_CANCELED = 99, + GPG_ERR_BAD_CA_CERT = 100, + GPG_ERR_CERT_EXPIRED = 101, + GPG_ERR_CERT_TOO_YOUNG = 102, + GPG_ERR_UNSUPPORTED_CERT = 103, + GPG_ERR_UNKNOWN_SEXP = 104, + GPG_ERR_UNSUPPORTED_PROTECTION = 105, + GPG_ERR_CORRUPTED_PROTECTION = 106, + GPG_ERR_AMBIGUOUS_NAME = 107, + GPG_ERR_CARD = 108, + GPG_ERR_CARD_RESET = 109, + GPG_ERR_CARD_REMOVED = 110, + GPG_ERR_INV_CARD = 111, + GPG_ERR_CARD_NOT_PRESENT = 112, + GPG_ERR_NO_PKCS15_APP = 113, + GPG_ERR_NOT_CONFIRMED = 114, + GPG_ERR_CONFIGURATION = 115, + GPG_ERR_NO_POLICY_MATCH = 116, + GPG_ERR_INV_INDEX = 117, + GPG_ERR_INV_ID = 118, + GPG_ERR_NO_SCDAEMON = 119, + GPG_ERR_SCDAEMON = 120, + GPG_ERR_UNSUPPORTED_PROTOCOL = 121, + GPG_ERR_BAD_PIN_METHOD = 122, + GPG_ERR_CARD_NOT_INITIALIZED = 123, + GPG_ERR_UNSUPPORTED_OPERATION = 124, + GPG_ERR_WRONG_KEY_USAGE = 125, + GPG_ERR_NOTHING_FOUND = 126, + GPG_ERR_WRONG_BLOB_TYPE = 127, + GPG_ERR_MISSING_VALUE = 128, + GPG_ERR_HARDWARE = 129, + GPG_ERR_PIN_BLOCKED = 130, + GPG_ERR_USE_CONDITIONS = 131, + GPG_ERR_PIN_NOT_SYNCED = 132, + GPG_ERR_INV_CRL = 133, + GPG_ERR_BAD_BER = 134, + GPG_ERR_INV_BER = 135, + GPG_ERR_ELEMENT_NOT_FOUND = 136, + GPG_ERR_IDENTIFIER_NOT_FOUND = 137, + GPG_ERR_INV_TAG = 138, + GPG_ERR_INV_LENGTH = 139, + GPG_ERR_INV_KEYINFO = 140, + GPG_ERR_UNEXPECTED_TAG = 141, + GPG_ERR_NOT_DER_ENCODED = 142, + GPG_ERR_NO_CMS_OBJ = 143, + GPG_ERR_INV_CMS_OBJ = 144, + GPG_ERR_UNKNOWN_CMS_OBJ = 145, + GPG_ERR_UNSUPPORTED_CMS_OBJ = 146, + GPG_ERR_UNSUPPORTED_ENCODING = 147, + GPG_ERR_UNSUPPORTED_CMS_VERSION = 148, + GPG_ERR_UNKNOWN_ALGORITHM = 149, + GPG_ERR_INV_ENGINE = 150, + GPG_ERR_PUBKEY_NOT_TRUSTED = 151, + GPG_ERR_DECRYPT_FAILED = 152, + GPG_ERR_KEY_EXPIRED = 153, + GPG_ERR_SIG_EXPIRED = 154, + GPG_ERR_ENCODING_PROBLEM = 155, + GPG_ERR_INV_STATE = 156, + GPG_ERR_DUP_VALUE = 157, + GPG_ERR_MISSING_ACTION = 158, + GPG_ERR_MODULE_NOT_FOUND = 159, + GPG_ERR_INV_OID_STRING = 160, + GPG_ERR_INV_TIME = 161, + GPG_ERR_INV_CRL_OBJ = 162, + GPG_ERR_UNSUPPORTED_CRL_VERSION = 163, + GPG_ERR_INV_CERT_OBJ = 164, + GPG_ERR_UNKNOWN_NAME = 165, + GPG_ERR_LOCALE_PROBLEM = 166, + GPG_ERR_NOT_LOCKED = 167, + GPG_ERR_PROTOCOL_VIOLATION = 168, + GPG_ERR_INV_MAC = 169, + GPG_ERR_INV_REQUEST = 170, + GPG_ERR_UNKNOWN_EXTN = 171, + GPG_ERR_UNKNOWN_CRIT_EXTN = 172, + GPG_ERR_LOCKED = 173, + GPG_ERR_UNKNOWN_OPTION = 174, + GPG_ERR_UNKNOWN_COMMAND = 175, + GPG_ERR_NOT_OPERATIONAL = 176, + GPG_ERR_NO_PASSPHRASE = 177, + GPG_ERR_NO_PIN = 178, + GPG_ERR_NOT_ENABLED = 179, + GPG_ERR_NO_ENGINE = 180, + GPG_ERR_MISSING_KEY = 181, + GPG_ERR_TOO_MANY = 182, + GPG_ERR_LIMIT_REACHED = 183, + GPG_ERR_NOT_INITIALIZED = 184, + GPG_ERR_MISSING_ISSUER_CERT = 185, + GPG_ERR_FULLY_CANCELED = 198, + GPG_ERR_UNFINISHED = 199, + GPG_ERR_BUFFER_TOO_SHORT = 200, + GPG_ERR_SEXP_INV_LEN_SPEC = 201, + GPG_ERR_SEXP_STRING_TOO_LONG = 202, + GPG_ERR_SEXP_UNMATCHED_PAREN = 203, + GPG_ERR_SEXP_NOT_CANONICAL = 204, + GPG_ERR_SEXP_BAD_CHARACTER = 205, + GPG_ERR_SEXP_BAD_QUOTATION = 206, + GPG_ERR_SEXP_ZERO_PREFIX = 207, + GPG_ERR_SEXP_NESTED_DH = 208, + GPG_ERR_SEXP_UNMATCHED_DH = 209, + GPG_ERR_SEXP_UNEXPECTED_PUNC = 210, + GPG_ERR_SEXP_BAD_HEX_CHAR = 211, + GPG_ERR_SEXP_ODD_HEX_NUMBERS = 212, + GPG_ERR_SEXP_BAD_OCT_CHAR = 213, + GPG_ERR_ASS_GENERAL = 257, + GPG_ERR_ASS_ACCEPT_FAILED = 258, + GPG_ERR_ASS_CONNECT_FAILED = 259, + GPG_ERR_ASS_INV_RESPONSE = 260, + GPG_ERR_ASS_INV_VALUE = 261, + GPG_ERR_ASS_INCOMPLETE_LINE = 262, + GPG_ERR_ASS_LINE_TOO_LONG = 263, + GPG_ERR_ASS_NESTED_COMMANDS = 264, + GPG_ERR_ASS_NO_DATA_CB = 265, + GPG_ERR_ASS_NO_INQUIRE_CB = 266, + GPG_ERR_ASS_NOT_A_SERVER = 267, + GPG_ERR_ASS_NOT_A_CLIENT = 268, + GPG_ERR_ASS_SERVER_START = 269, + GPG_ERR_ASS_READ_ERROR = 270, + GPG_ERR_ASS_WRITE_ERROR = 271, + GPG_ERR_ASS_TOO_MUCH_DATA = 273, + GPG_ERR_ASS_UNEXPECTED_CMD = 274, + GPG_ERR_ASS_UNKNOWN_CMD = 275, + GPG_ERR_ASS_SYNTAX = 276, + GPG_ERR_ASS_CANCELED = 277, + GPG_ERR_ASS_NO_INPUT = 278, + GPG_ERR_ASS_NO_OUTPUT = 279, + GPG_ERR_ASS_PARAMETER = 280, + GPG_ERR_ASS_UNKNOWN_INQUIRE = 281, + GPG_ERR_USER_1 = 1024, + GPG_ERR_USER_2 = 1025, + GPG_ERR_USER_3 = 1026, + GPG_ERR_USER_4 = 1027, + GPG_ERR_USER_5 = 1028, + GPG_ERR_USER_6 = 1029, + GPG_ERR_USER_7 = 1030, + GPG_ERR_USER_8 = 1031, + GPG_ERR_USER_9 = 1032, + GPG_ERR_USER_10 = 1033, + GPG_ERR_USER_11 = 1034, + GPG_ERR_USER_12 = 1035, + GPG_ERR_USER_13 = 1036, + GPG_ERR_USER_14 = 1037, + GPG_ERR_USER_15 = 1038, + GPG_ERR_USER_16 = 1039, + GPG_ERR_MISSING_ERRNO = 16381, + GPG_ERR_UNKNOWN_ERRNO = 16382, + GPG_ERR_EOF = 16383, + GPG_ERR_E2BIG = 32768, + GPG_ERR_EACCES = 32769, + GPG_ERR_EADDRINUSE = 32770, + GPG_ERR_EADDRNOTAVAIL = 32771, + GPG_ERR_EADV = 32772, + GPG_ERR_EAFNOSUPPORT = 32773, + GPG_ERR_EAGAIN = 32774, + GPG_ERR_EALREADY = 32775, + GPG_ERR_EAUTH = 32776, + GPG_ERR_EBACKGROUND = 32777, + GPG_ERR_EBADE = 32778, + GPG_ERR_EBADF = 32779, + GPG_ERR_EBADFD = 32780, + GPG_ERR_EBADMSG = 32781, + GPG_ERR_EBADR = 32782, + GPG_ERR_EBADRPC = 32783, + GPG_ERR_EBADRQC = 32784, + GPG_ERR_EBADSLT = 32785, + GPG_ERR_EBFONT = 32786, + GPG_ERR_EBUSY = 32787, + GPG_ERR_ECANCELED = 32788, + GPG_ERR_ECHILD = 32789, + GPG_ERR_ECHRNG = 32790, + GPG_ERR_ECOMM = 32791, + GPG_ERR_ECONNABORTED = 32792, + GPG_ERR_ECONNREFUSED = 32793, + GPG_ERR_ECONNRESET = 32794, + GPG_ERR_ED = 32795, + GPG_ERR_EDEADLK = 32796, + GPG_ERR_EDEADLOCK = 32797, + GPG_ERR_EDESTADDRREQ = 32798, + GPG_ERR_EDIED = 32799, + GPG_ERR_EDOM = 32800, + GPG_ERR_EDOTDOT = 32801, + GPG_ERR_EDQUOT = 32802, + GPG_ERR_EEXIST = 32803, + GPG_ERR_EFAULT = 32804, + GPG_ERR_EFBIG = 32805, + GPG_ERR_EFTYPE = 32806, + GPG_ERR_EGRATUITOUS = 32807, + GPG_ERR_EGREGIOUS = 32808, + GPG_ERR_EHOSTDOWN = 32809, + GPG_ERR_EHOSTUNREACH = 32810, + GPG_ERR_EIDRM = 32811, + GPG_ERR_EIEIO = 32812, + GPG_ERR_EILSEQ = 32813, + GPG_ERR_EINPROGRESS = 32814, + GPG_ERR_EINTR = 32815, + GPG_ERR_EINVAL = 32816, + GPG_ERR_EIO = 32817, + GPG_ERR_EISCONN = 32818, + GPG_ERR_EISDIR = 32819, + GPG_ERR_EISNAM = 32820, + GPG_ERR_EL2HLT = 32821, + GPG_ERR_EL2NSYNC = 32822, + GPG_ERR_EL3HLT = 32823, + GPG_ERR_EL3RST = 32824, + GPG_ERR_ELIBACC = 32825, + GPG_ERR_ELIBBAD = 32826, + GPG_ERR_ELIBEXEC = 32827, + GPG_ERR_ELIBMAX = 32828, + GPG_ERR_ELIBSCN = 32829, + GPG_ERR_ELNRNG = 32830, + GPG_ERR_ELOOP = 32831, + GPG_ERR_EMEDIUMTYPE = 32832, + GPG_ERR_EMFILE = 32833, + GPG_ERR_EMLINK = 32834, + GPG_ERR_EMSGSIZE = 32835, + GPG_ERR_EMULTIHOP = 32836, + GPG_ERR_ENAMETOOLONG = 32837, + GPG_ERR_ENAVAIL = 32838, + GPG_ERR_ENEEDAUTH = 32839, + GPG_ERR_ENETDOWN = 32840, + GPG_ERR_ENETRESET = 32841, + GPG_ERR_ENETUNREACH = 32842, + GPG_ERR_ENFILE = 32843, + GPG_ERR_ENOANO = 32844, + GPG_ERR_ENOBUFS = 32845, + GPG_ERR_ENOCSI = 32846, + GPG_ERR_ENODATA = 32847, + GPG_ERR_ENODEV = 32848, + GPG_ERR_ENOENT = 32849, + GPG_ERR_ENOEXEC = 32850, + GPG_ERR_ENOLCK = 32851, + GPG_ERR_ENOLINK = 32852, + GPG_ERR_ENOMEDIUM = 32853, + GPG_ERR_ENOMEM = 32854, + GPG_ERR_ENOMSG = 32855, + GPG_ERR_ENONET = 32856, + GPG_ERR_ENOPKG = 32857, + GPG_ERR_ENOPROTOOPT = 32858, + GPG_ERR_ENOSPC = 32859, + GPG_ERR_ENOSR = 32860, + GPG_ERR_ENOSTR = 32861, + GPG_ERR_ENOSYS = 32862, + GPG_ERR_ENOTBLK = 32863, + GPG_ERR_ENOTCONN = 32864, + GPG_ERR_ENOTDIR = 32865, + GPG_ERR_ENOTEMPTY = 32866, + GPG_ERR_ENOTNAM = 32867, + GPG_ERR_ENOTSOCK = 32868, + GPG_ERR_ENOTSUP = 32869, + GPG_ERR_ENOTTY = 32870, + GPG_ERR_ENOTUNIQ = 32871, + GPG_ERR_ENXIO = 32872, + GPG_ERR_EOPNOTSUPP = 32873, + GPG_ERR_EOVERFLOW = 32874, + GPG_ERR_EPERM = 32875, + GPG_ERR_EPFNOSUPPORT = 32876, + GPG_ERR_EPIPE = 32877, + GPG_ERR_EPROCLIM = 32878, + GPG_ERR_EPROCUNAVAIL = 32879, + GPG_ERR_EPROGMISMATCH = 32880, + GPG_ERR_EPROGUNAVAIL = 32881, + GPG_ERR_EPROTO = 32882, + GPG_ERR_EPROTONOSUPPORT = 32883, + GPG_ERR_EPROTOTYPE = 32884, + GPG_ERR_ERANGE = 32885, + GPG_ERR_EREMCHG = 32886, + GPG_ERR_EREMOTE = 32887, + GPG_ERR_EREMOTEIO = 32888, + GPG_ERR_ERESTART = 32889, + GPG_ERR_EROFS = 32890, + GPG_ERR_ERPCMISMATCH = 32891, + GPG_ERR_ESHUTDOWN = 32892, + GPG_ERR_ESOCKTNOSUPPORT = 32893, + GPG_ERR_ESPIPE = 32894, + GPG_ERR_ESRCH = 32895, + GPG_ERR_ESRMNT = 32896, + GPG_ERR_ESTALE = 32897, + GPG_ERR_ESTRPIPE = 32898, + GPG_ERR_ETIME = 32899, + GPG_ERR_ETIMEDOUT = 32900, + GPG_ERR_ETOOMANYREFS = 32901, + GPG_ERR_ETXTBSY = 32902, + GPG_ERR_EUCLEAN = 32903, + GPG_ERR_EUNATCH = 32904, + GPG_ERR_EUSERS = 32905, + GPG_ERR_EWOULDBLOCK = 32906, + GPG_ERR_EXDEV = 32907, + GPG_ERR_EXFULL = 32908, + GPG_ERR_CODE_DIM = 65536 +} ; +#line 110 "/usr/include/gpg-error.h" +typedef enum __anonenum_gpg_err_code_t_22 gpg_err_code_t; +#line 513 "/usr/include/gpg-error.h" +typedef unsigned int gpg_error_t; +#line 44 "/usr/include/x86_64-linux-gnu/bits/uio.h" +struct iovec { + void *iov_base ; + size_t iov_len ; +}; +#line 35 "/usr/include/x86_64-linux-gnu/bits/socket.h" +typedef __socklen_t socklen_t; +#line 40 +enum __socket_type { + SOCK_STREAM = 1, + SOCK_DGRAM = 2, + SOCK_RAW = 3, + SOCK_RDM = 4, + SOCK_SEQPACKET = 5, + SOCK_DCCP = 6, + SOCK_PACKET = 10, + SOCK_CLOEXEC = 524288, + SOCK_NONBLOCK = 2048 +} ; +#line 29 "/usr/include/x86_64-linux-gnu/bits/sockaddr.h" +typedef unsigned short sa_family_t; +#line 180 "/usr/include/x86_64-linux-gnu/bits/socket.h" +struct sockaddr { + sa_family_t sa_family ; + char sa_data[14] ; +}; +#line 193 "/usr/include/x86_64-linux-gnu/bits/socket.h" +struct sockaddr_storage { + sa_family_t ss_family ; + unsigned long __ss_align ; + char __ss_padding[(unsigned long )128 - (unsigned long )((unsigned long )2 * (unsigned long )sizeof(unsigned long ))] ; +}; +#line 202 +enum __anonenum_23 { + MSG_OOB = 1, + MSG_PEEK = 2, + MSG_DONTROUTE = 4, + MSG_CTRUNC = 8, + MSG_PROXY = 16, + MSG_TRUNC = 32, + MSG_DONTWAIT = 64, + MSG_EOR = 128, + MSG_WAITALL = 256, + MSG_FIN = 512, + MSG_SYN = 1024, + MSG_CONFIRM = 2048, + MSG_RST = 4096, + MSG_ERRQUEUE = 8192, + MSG_NOSIGNAL = 16384, + MSG_MORE = 32768, + MSG_WAITFORONE = 65536, + MSG_CMSG_CLOEXEC = 1073741824 +} ; +#line 253 "/usr/include/x86_64-linux-gnu/bits/socket.h" +struct msghdr { + void *msg_name ; + socklen_t msg_namelen ; + struct iovec *msg_iov ; + size_t msg_iovlen ; + void *msg_control ; + size_t msg_controllen ; + int msg_flags ; +}; +#line 280 "/usr/include/x86_64-linux-gnu/bits/socket.h" +struct cmsghdr { + size_t cmsg_len ; + int cmsg_level ; + int cmsg_type ; + unsigned char __cmsg_data[] ; +}; +#line 337 +enum __anonenum_24 { + SCM_RIGHTS = 1 +} ; +#line 417 "/usr/include/x86_64-linux-gnu/bits/socket.h" +struct linger { + int l_onoff ; + int l_linger ; +}; +#line 431 +struct mmsghdr; +#line 45 "/usr/include/x86_64-linux-gnu/sys/socket.h" +struct osockaddr { + unsigned short sa_family ; + unsigned char sa_data[14] ; +}; +#line 54 +enum __anonenum_25 { + SHUT_RD = 0, + SHUT_WR = 1, + SHUT_RDWR = 2 +} ; +#line 57 "/usr/include/x86_64-linux-gnu/sys/time.h" +struct timezone { + int tz_minuteswest ; + int tz_dsttime ; +}; +#line 63 "/usr/include/x86_64-linux-gnu/sys/time.h" +typedef struct timezone * __restrict __timezone_ptr_t; +#line 93 +enum __itimer_which { + ITIMER_REAL = 0, + ITIMER_VIRTUAL = 1, + ITIMER_PROF = 2 +} ; +#line 109 "/usr/include/x86_64-linux-gnu/sys/time.h" +struct itimerval { + struct timeval it_interval ; + struct timeval it_value ; +}; +#line 122 "/usr/include/x86_64-linux-gnu/sys/time.h" +typedef int __itimer_which_t; +#line 47 "/usr/include/gcrypt.h" +typedef socklen_t gcry_socklen_t; +#line 117 "/usr/include/gcrypt.h" +typedef gpg_error_t gcry_error_t; +#line 118 "/usr/include/gcrypt.h" +typedef gpg_err_code_t gcry_err_code_t; +#line 119 "/usr/include/gcrypt.h" +typedef gpg_err_source_t gcry_err_source_t; +#line 179 +enum gcry_thread_option { + _GCRY_THREAD_OPTION_DUMMY = 0 +} __attribute__((__deprecated__)) ; +#line 197 "/usr/include/gcrypt.h" +struct gcry_thread_cbs { + unsigned int option ; + int (*init)(void) ; + int (*mutex_init)(void **priv ) ; + int (*mutex_destroy)(void **priv ) ; + int (*mutex_lock)(void **priv ) ; + int (*mutex_unlock)(void **priv ) ; + ssize_t (*read)(int fd , void *buf , size_t nbytes ) ; + ssize_t (*write)(int fd , void const *buf , size_t nbytes ) ; + ssize_t (*select)(int nfd , fd_set *rset , fd_set *wset , fd_set *eset , struct timeval *timeout ) ; + ssize_t (*waitpid)(pid_t pid , int *status , int options ) ; + int (*accept)(int s , struct sockaddr *addr , gcry_socklen_t *length_ptr ) ; + int (*connect)(int s , struct sockaddr *addr , gcry_socklen_t length ) ; + int (*sendmsg)(int s , struct msghdr const *msg , int flags ) ; + int (*recvmsg)(int s , struct msghdr *msg , int flags ) ; +}; +#line 343 +struct gcry_mpi; +#line 343 +struct gcry_mpi; +#line 344 "/usr/include/gcrypt.h" +typedef struct gcry_mpi *gcry_mpi_t; +#line 347 "/usr/include/gcrypt.h" +typedef struct gcry_mpi * __attribute__((__deprecated__)) GCRY_MPI; +#line 348 "/usr/include/gcrypt.h" +typedef struct gcry_mpi * __attribute__((__deprecated__)) GcryMPI; +#line 359 +enum gcry_ctl_cmds { + GCRYCTL_SET_KEY = 1, + GCRYCTL_SET_IV = 2, + GCRYCTL_CFB_SYNC = 3, + GCRYCTL_RESET = 4, + GCRYCTL_FINALIZE = 5, + GCRYCTL_GET_KEYLEN = 6, + GCRYCTL_GET_BLKLEN = 7, + GCRYCTL_TEST_ALGO = 8, + GCRYCTL_IS_SECURE = 9, + GCRYCTL_GET_ASNOID = 10, + GCRYCTL_ENABLE_ALGO = 11, + GCRYCTL_DISABLE_ALGO = 12, + GCRYCTL_DUMP_RANDOM_STATS = 13, + GCRYCTL_DUMP_SECMEM_STATS = 14, + GCRYCTL_GET_ALGO_NPKEY = 15, + GCRYCTL_GET_ALGO_NSKEY = 16, + GCRYCTL_GET_ALGO_NSIGN = 17, + GCRYCTL_GET_ALGO_NENCR = 18, + GCRYCTL_SET_VERBOSITY = 19, + GCRYCTL_SET_DEBUG_FLAGS = 20, + GCRYCTL_CLEAR_DEBUG_FLAGS = 21, + GCRYCTL_USE_SECURE_RNDPOOL = 22, + GCRYCTL_DUMP_MEMORY_STATS = 23, + GCRYCTL_INIT_SECMEM = 24, + GCRYCTL_TERM_SECMEM = 25, + GCRYCTL_DISABLE_SECMEM_WARN = 27, + GCRYCTL_SUSPEND_SECMEM_WARN = 28, + GCRYCTL_RESUME_SECMEM_WARN = 29, + GCRYCTL_DROP_PRIVS = 30, + GCRYCTL_ENABLE_M_GUARD = 31, + GCRYCTL_START_DUMP = 32, + GCRYCTL_STOP_DUMP = 33, + GCRYCTL_GET_ALGO_USAGE = 34, + GCRYCTL_IS_ALGO_ENABLED = 35, + GCRYCTL_DISABLE_INTERNAL_LOCKING = 36, + GCRYCTL_DISABLE_SECMEM = 37, + GCRYCTL_INITIALIZATION_FINISHED = 38, + GCRYCTL_INITIALIZATION_FINISHED_P = 39, + GCRYCTL_ANY_INITIALIZATION_P = 40, + GCRYCTL_SET_CBC_CTS = 41, + GCRYCTL_SET_CBC_MAC = 42, + GCRYCTL_SET_CTR = 43, + GCRYCTL_ENABLE_QUICK_RANDOM = 44, + GCRYCTL_SET_RANDOM_SEED_FILE = 45, + GCRYCTL_UPDATE_RANDOM_SEED_FILE = 46, + GCRYCTL_SET_THREAD_CBS = 47, + GCRYCTL_FAST_POLL = 48, + GCRYCTL_SET_RANDOM_DAEMON_SOCKET = 49, + GCRYCTL_USE_RANDOM_DAEMON = 50, + GCRYCTL_FAKED_RANDOM_P = 51, + GCRYCTL_SET_RNDEGD_SOCKET = 52, + GCRYCTL_PRINT_CONFIG = 53, + GCRYCTL_OPERATIONAL_P = 54, + GCRYCTL_FIPS_MODE_P = 55, + GCRYCTL_FORCE_FIPS_MODE = 56, + GCRYCTL_SELFTEST = 57, + GCRYCTL_DISABLE_HWF = 63 +} ; +#line 429 +struct gcry_sexp; +#line 429 +struct gcry_sexp; +#line 430 "/usr/include/gcrypt.h" +typedef struct gcry_sexp *gcry_sexp_t; +#line 433 "/usr/include/gcrypt.h" +typedef struct gcry_sexp * __attribute__((__deprecated__)) GCRY_SEXP; +#line 434 "/usr/include/gcrypt.h" +typedef struct gcry_sexp * __attribute__((__deprecated__)) GcrySexp; +#line 438 +enum gcry_sexp_format { + GCRYSEXP_FMT_DEFAULT = 0, + GCRYSEXP_FMT_CANON = 1, + GCRYSEXP_FMT_BASE64 = 2, + GCRYSEXP_FMT_ADVANCED = 3 +} ; +#line 561 +enum gcry_mpi_format { + GCRYMPI_FMT_NONE = 0, + GCRYMPI_FMT_STD = 1, + GCRYMPI_FMT_PGP = 2, + GCRYMPI_FMT_SSH = 3, + GCRYMPI_FMT_HEX = 4, + GCRYMPI_FMT_USG = 5 +} ; +#line 572 +enum gcry_mpi_flag { + GCRYMPI_FLAG_SECURE = 1, + GCRYMPI_FLAG_OPAQUE = 2 +} ; +#line 801 +struct gcry_cipher_handle; +#line 801 +struct gcry_cipher_handle; +#line 802 "/usr/include/gcrypt.h" +typedef struct gcry_cipher_handle *gcry_cipher_hd_t; +#line 805 "/usr/include/gcrypt.h" +typedef struct gcry_cipher_handle * __attribute__((__deprecated__)) GCRY_CIPHER_HD; +#line 806 "/usr/include/gcrypt.h" +typedef struct gcry_cipher_handle * __attribute__((__deprecated__)) GcryCipherHd; +#line 811 +enum gcry_cipher_algos { + GCRY_CIPHER_NONE = 0, + GCRY_CIPHER_IDEA = 1, + GCRY_CIPHER_3DES = 2, + GCRY_CIPHER_CAST5 = 3, + GCRY_CIPHER_BLOWFISH = 4, + GCRY_CIPHER_SAFER_SK128 = 5, + GCRY_CIPHER_DES_SK = 6, + GCRY_CIPHER_AES = 7, + GCRY_CIPHER_AES192 = 8, + GCRY_CIPHER_AES256 = 9, + GCRY_CIPHER_TWOFISH = 10, + GCRY_CIPHER_ARCFOUR = 301, + GCRY_CIPHER_DES = 302, + GCRY_CIPHER_TWOFISH128 = 303, + GCRY_CIPHER_SERPENT128 = 304, + GCRY_CIPHER_SERPENT192 = 305, + GCRY_CIPHER_SERPENT256 = 306, + GCRY_CIPHER_RFC2268_40 = 307, + GCRY_CIPHER_RFC2268_128 = 308, + GCRY_CIPHER_SEED = 309, + GCRY_CIPHER_CAMELLIA128 = 310, + GCRY_CIPHER_CAMELLIA192 = 311, + GCRY_CIPHER_CAMELLIA256 = 312 +} ; +#line 849 +enum gcry_cipher_modes { + GCRY_CIPHER_MODE_NONE = 0, + GCRY_CIPHER_MODE_ECB = 1, + GCRY_CIPHER_MODE_CFB = 2, + GCRY_CIPHER_MODE_CBC = 3, + GCRY_CIPHER_MODE_STREAM = 4, + GCRY_CIPHER_MODE_OFB = 5, + GCRY_CIPHER_MODE_CTR = 6, + GCRY_CIPHER_MODE_AESWRAP = 7 +} ; +#line 862 +enum gcry_cipher_flags { + GCRY_CIPHER_SECURE = 1, + GCRY_CIPHER_ENABLE_SYNC = 2, + GCRY_CIPHER_CBC_CTS = 4, + GCRY_CIPHER_CBC_MAC = 8 +} ; +#line 970 +enum gcry_pk_algos { + GCRY_PK_RSA = 1, + GCRY_PK_RSA_E = 2, + GCRY_PK_RSA_S = 3, + GCRY_PK_ELG_E = 16, + GCRY_PK_DSA = 17, + GCRY_PK_ELG = 20, + GCRY_PK_ECDSA = 301, + GCRY_PK_ECDH = 302 +} ; +#line 1070 +enum gcry_md_algos { + GCRY_MD_NONE = 0, + GCRY_MD_MD5 = 1, + GCRY_MD_SHA1 = 2, + GCRY_MD_RMD160 = 3, + GCRY_MD_MD2 = 5, + GCRY_MD_TIGER = 6, + GCRY_MD_HAVAL = 7, + GCRY_MD_SHA256 = 8, + GCRY_MD_SHA384 = 9, + GCRY_MD_SHA512 = 10, + GCRY_MD_SHA224 = 11, + GCRY_MD_MD4 = 301, + GCRY_MD_CRC32 = 302, + GCRY_MD_CRC32_RFC1510 = 303, + GCRY_MD_CRC24_RFC2440 = 304, + GCRY_MD_WHIRLPOOL = 305, + GCRY_MD_TIGER1 = 306, + GCRY_MD_TIGER2 = 307 +} ; +#line 1093 +enum gcry_md_flags { + GCRY_MD_FLAG_SECURE = 1, + GCRY_MD_FLAG_HMAC = 2 +} ; +#line 1100 +struct gcry_md_context; +#line 1100 +struct gcry_md_context; +#line 1105 "/usr/include/gcrypt.h" +struct gcry_md_handle { + struct gcry_md_context *ctx ; + int bufpos ; + int bufsize ; + unsigned char buf[1] ; +}; +#line 1105 "/usr/include/gcrypt.h" +typedef struct gcry_md_handle *gcry_md_hd_t; +#line 1118 "/usr/include/gcrypt.h" +typedef struct gcry_md_handle * __attribute__((__deprecated__)) GCRY_MD_HD; +#line 1119 "/usr/include/gcrypt.h" +typedef struct gcry_md_handle * __attribute__((__deprecated__)) GcryMDHd; +#line 1256 +enum gcry_ac_id { + GCRY_AC_RSA = 1, + GCRY_AC_DSA = 17, + GCRY_AC_ELG = 20, + GCRY_AC_ELG_E = 16 +} ; +#line 1256 "/usr/include/gcrypt.h" +typedef enum gcry_ac_id __attribute__((__deprecated__)) gcry_ac_id_t; +#line 1266 +enum gcry_ac_key_type { + GCRY_AC_KEY_SECRET = 0, + GCRY_AC_KEY_PUBLIC = 1 +} ; +#line 1266 "/usr/include/gcrypt.h" +typedef enum gcry_ac_key_type __attribute__((__deprecated__)) gcry_ac_key_type_t; +#line 1274 +enum gcry_ac_em { + GCRY_AC_EME_PKCS_V1_5 = 0, + GCRY_AC_EMSA_PKCS_V1_5 = 1 +} ; +#line 1274 "/usr/include/gcrypt.h" +typedef enum gcry_ac_em __attribute__((__deprecated__)) gcry_ac_em_t; +#line 1282 +enum gcry_ac_scheme { + GCRY_AC_ES_PKCS_V1_5 = 0, + GCRY_AC_SSA_PKCS_V1_5 = 1 +} ; +#line 1282 "/usr/include/gcrypt.h" +typedef enum gcry_ac_scheme __attribute__((__deprecated__)) gcry_ac_scheme_t; +#line 1295 +struct gcry_ac_data; +#line 1295 "/usr/include/gcrypt.h" +typedef struct gcry_ac_data * __attribute__((__deprecated__)) gcry_ac_data_t; +#line 1299 +struct gcry_ac_key; +#line 1299 "/usr/include/gcrypt.h" +typedef struct gcry_ac_key * __attribute__((__deprecated__)) gcry_ac_key_t; +#line 1303 +struct gcry_ac_key_pair; +#line 1303 "/usr/include/gcrypt.h" +typedef struct gcry_ac_key_pair * __attribute__((__deprecated__)) gcry_ac_key_pair_t; +#line 1307 +struct gcry_ac_handle; +#line 1307 "/usr/include/gcrypt.h" +typedef struct gcry_ac_handle * __attribute__((__deprecated__)) gcry_ac_handle_t; +#line 1309 "/usr/include/gcrypt.h" +typedef gpg_error_t (* __attribute__((__deprecated__)) gcry_ac_data_read_cb_t)(void *opaque , + unsigned char *buffer , + size_t *buffer_n ); +#line 1314 "/usr/include/gcrypt.h" +typedef gpg_error_t (* __attribute__((__deprecated__)) gcry_ac_data_write_cb_t)(void *opaque , + unsigned char *buffer , + size_t buffer_n ); +#line 1319 +enum __anonenum_gcry_ac_io_mode_t_26 { + GCRY_AC_IO_READABLE = 0, + GCRY_AC_IO_WRITABLE = 1 +} ; +#line 1319 "/usr/include/gcrypt.h" +typedef enum __anonenum_gcry_ac_io_mode_t_26 __attribute__((__deprecated__)) gcry_ac_io_mode_t; +#line 1326 +enum __anonenum_gcry_ac_io_type_t_27 { + GCRY_AC_IO_STRING = 0, + GCRY_AC_IO_CALLBACK = 1 +} ; +#line 1326 "/usr/include/gcrypt.h" +typedef enum __anonenum_gcry_ac_io_type_t_27 __attribute__((__deprecated__)) gcry_ac_io_type_t; +#line 1333 "/usr/include/gcrypt.h" +struct __anonstruct_callback_30 { + gpg_error_t (* __attribute__((__deprecated__)) cb)(void *opaque , unsigned char *buffer , + size_t *buffer_n ) ; + void *opaque ; +}; +#line 1333 "/usr/include/gcrypt.h" +struct __anonstruct_string_31 { + unsigned char *data ; + size_t data_n ; +}; +#line 1333 "/usr/include/gcrypt.h" +union __anonunion_readable_29 { + struct __anonstruct_callback_30 callback ; + struct __anonstruct_string_31 string ; + void *opaque ; +}; +#line 1333 "/usr/include/gcrypt.h" +struct __anonstruct_callback_33 { + gpg_error_t (* __attribute__((__deprecated__)) cb)(void *opaque , unsigned char *buffer , + size_t buffer_n ) ; + void *opaque ; +}; +#line 1333 "/usr/include/gcrypt.h" +struct __anonstruct_string_34 { + unsigned char **data ; + size_t *data_n ; +}; +#line 1333 "/usr/include/gcrypt.h" +union __anonunion_writable_32 { + struct __anonstruct_callback_33 callback ; + struct __anonstruct_string_34 string ; + void *opaque ; +}; +#line 1333 "/usr/include/gcrypt.h" +union __anonunion_io_28 { + union __anonunion_readable_29 readable ; + union __anonunion_writable_32 writable ; +}; +#line 1333 "/usr/include/gcrypt.h" +struct gcry_ac_io { + gcry_ac_io_mode_t mode __attribute__((__deprecated__)) ; + gcry_ac_io_type_t type __attribute__((__deprecated__)) ; + union __anonunion_io_28 io __attribute__((__deprecated__)) ; +}; +#line 1333 "/usr/include/gcrypt.h" +typedef struct gcry_ac_io __attribute__((__deprecated__)) gcry_ac_io_t; +#line 1375 "/usr/include/gcrypt.h" +struct gcry_ac_key_spec_rsa { + gcry_mpi_t e ; +}; +#line 1375 "/usr/include/gcrypt.h" +typedef struct gcry_ac_key_spec_rsa __attribute__((__deprecated__)) gcry_ac_key_spec_rsa_t; +#line 1382 "/usr/include/gcrypt.h" +struct gcry_ac_eme_pkcs_v1_5 { + size_t key_size ; +}; +#line 1382 "/usr/include/gcrypt.h" +typedef struct gcry_ac_eme_pkcs_v1_5 __attribute__((__deprecated__)) gcry_ac_eme_pkcs_v1_5_t; +#line 1387 "/usr/include/gcrypt.h" +typedef enum gcry_md_algos __attribute__((__deprecated__)) gcry_md_algo_t; +#line 1391 "/usr/include/gcrypt.h" +struct gcry_ac_emsa_pkcs_v1_5 { + gcry_md_algo_t md ; + size_t em_n ; +}; +#line 1391 "/usr/include/gcrypt.h" +typedef struct gcry_ac_emsa_pkcs_v1_5 __attribute__((__deprecated__)) gcry_ac_emsa_pkcs_v1_5_t; +#line 1399 "/usr/include/gcrypt.h" +struct gcry_ac_ssa_pkcs_v1_5 { + gcry_md_algo_t md ; +}; +#line 1399 "/usr/include/gcrypt.h" +typedef struct gcry_ac_ssa_pkcs_v1_5 __attribute__((__deprecated__)) gcry_ac_ssa_pkcs_v1_5_t; +#line 1668 +enum gcry_kdf_algos { + GCRY_KDF_NONE = 0, + GCRY_KDF_SIMPLE_S2K = 16, + GCRY_KDF_SALTED_S2K = 17, + GCRY_KDF_ITERSALTED_S2K = 19, + GCRY_KDF_PBKDF1 = 33, + GCRY_KDF_PBKDF2 = 34 +} ; +#line 1698 +enum gcry_random_level { + GCRY_WEAK_RANDOM = 0, + GCRY_STRONG_RANDOM = 1, + GCRY_VERY_STRONG_RANDOM = 2 +} ; +#line 1698 "/usr/include/gcrypt.h" +typedef enum gcry_random_level gcry_random_level_t; +#line 1762 "/usr/include/gcrypt.h" +typedef int (*gcry_prime_check_func_t)(void *arg , int mode , gcry_mpi_t candidate ); +#line 1815 +enum gcry_log_levels { + GCRY_LOG_CONT = 0, + GCRY_LOG_INFO = 10, + GCRY_LOG_WARN = 20, + GCRY_LOG_ERROR = 30, + GCRY_LOG_FATAL = 40, + GCRY_LOG_BUG = 50, + GCRY_LOG_DEBUG = 100 +} ; +#line 1827 "/usr/include/gcrypt.h" +typedef void (*gcry_handler_progress_t)(void * , char const * , int , int , int ); +#line 1830 "/usr/include/gcrypt.h" +typedef void *(*gcry_handler_alloc_t)(size_t n ); +#line 1833 "/usr/include/gcrypt.h" +typedef int (*gcry_handler_secure_check_t)(void const * ); +#line 1836 "/usr/include/gcrypt.h" +typedef void *(*gcry_handler_realloc_t)(void *p , size_t n ); +#line 1839 "/usr/include/gcrypt.h" +typedef void (*gcry_handler_free_t)(void * ); +#line 1842 "/usr/include/gcrypt.h" +typedef int (*gcry_handler_no_mem_t)(void * , size_t , unsigned int ); +#line 1845 "/usr/include/gcrypt.h" +typedef void (*gcry_handler_error_t)(void * , int , char const * ); +#line 1848 "/usr/include/gcrypt.h" +typedef void (*gcry_handler_log_t)(void * , int , char const * , va_list ); +#line 43 "/usr/include/gcrypt-module.h" +struct gcry_module; +#line 43 "/usr/include/gcrypt-module.h" +typedef struct gcry_module *gcry_module_t; +#line 48 "/usr/include/gcrypt-module.h" +typedef gcry_err_code_t (*gcry_cipher_setkey_t)(void *c , unsigned char const *key , + unsigned int keylen ); +#line 53 "/usr/include/gcrypt-module.h" +typedef void (*gcry_cipher_encrypt_t)(void *c , unsigned char *outbuf , unsigned char const *inbuf ); +#line 58 "/usr/include/gcrypt-module.h" +typedef void (*gcry_cipher_decrypt_t)(void *c , unsigned char *outbuf , unsigned char const *inbuf ); +#line 63 "/usr/include/gcrypt-module.h" +typedef void (*gcry_cipher_stencrypt_t)(void *c , unsigned char *outbuf , unsigned char const *inbuf , + unsigned int n ); +#line 69 "/usr/include/gcrypt-module.h" +typedef void (*gcry_cipher_stdecrypt_t)(void *c , unsigned char *outbuf , unsigned char const *inbuf , + unsigned int n ); +#line 74 "/usr/include/gcrypt-module.h" +struct gcry_cipher_oid_spec { + char const *oid ; + int mode ; +}; +#line 74 "/usr/include/gcrypt-module.h" +typedef struct gcry_cipher_oid_spec gcry_cipher_oid_spec_t; +#line 81 "/usr/include/gcrypt-module.h" +struct gcry_cipher_spec { + char const *name ; + char const **aliases ; + gcry_cipher_oid_spec_t *oids ; + size_t blocksize ; + size_t keylen ; + size_t contextsize ; + gcry_err_code_t (*setkey)(void *c , unsigned char const *key , unsigned int keylen ) ; + void (*encrypt)(void *c , unsigned char *outbuf , unsigned char const *inbuf ) ; + void (*decrypt)(void *c , unsigned char *outbuf , unsigned char const *inbuf ) ; + void (*stencrypt)(void *c , unsigned char *outbuf , unsigned char const *inbuf , + unsigned int n ) ; + void (*stdecrypt)(void *c , unsigned char *outbuf , unsigned char const *inbuf , + unsigned int n ) ; +}; +#line 81 "/usr/include/gcrypt-module.h" +typedef struct gcry_cipher_spec gcry_cipher_spec_t; +#line 113 "/usr/include/gcrypt-module.h" +typedef gcry_err_code_t (*gcry_pk_generate_t)(int algo , unsigned int nbits , unsigned long use_e , + gcry_mpi_t *skey , gcry_mpi_t **retfactors ); +#line 120 "/usr/include/gcrypt-module.h" +typedef gcry_err_code_t (*gcry_pk_check_secret_key_t)(int algo , gcry_mpi_t *skey ); +#line 124 "/usr/include/gcrypt-module.h" +typedef gcry_err_code_t (*gcry_pk_encrypt_t)(int algo , gcry_mpi_t *resarr , gcry_mpi_t data , + gcry_mpi_t *pkey , int flags ); +#line 131 "/usr/include/gcrypt-module.h" +typedef gcry_err_code_t (*gcry_pk_decrypt_t)(int algo , gcry_mpi_t *result , gcry_mpi_t *data , + gcry_mpi_t *skey , int flags ); +#line 138 "/usr/include/gcrypt-module.h" +typedef gcry_err_code_t (*gcry_pk_sign_t)(int algo , gcry_mpi_t *resarr , gcry_mpi_t data , + gcry_mpi_t *skey ); +#line 144 "/usr/include/gcrypt-module.h" +typedef gcry_err_code_t (*gcry_pk_verify_t)(int algo , gcry_mpi_t hash , gcry_mpi_t *data , + gcry_mpi_t *pkey , int (*cmp)(void * , + gcry_mpi_t ) , + void *opaquev ); +#line 152 "/usr/include/gcrypt-module.h" +typedef unsigned int (*gcry_pk_get_nbits_t)(int algo , gcry_mpi_t *pkey ); +#line 155 "/usr/include/gcrypt-module.h" +struct gcry_pk_spec { + char const *name ; + char const **aliases ; + char const *elements_pkey ; + char const *elements_skey ; + char const *elements_enc ; + char const *elements_sig ; + char const *elements_grip ; + int use ; + gcry_err_code_t (*generate)(int algo , unsigned int nbits , unsigned long use_e , + gcry_mpi_t *skey , gcry_mpi_t **retfactors ) ; + gcry_err_code_t (*check_secret_key)(int algo , gcry_mpi_t *skey ) ; + gcry_err_code_t (*encrypt)(int algo , gcry_mpi_t *resarr , gcry_mpi_t data , gcry_mpi_t *pkey , + int flags ) ; + gcry_err_code_t (*decrypt)(int algo , gcry_mpi_t *result , gcry_mpi_t *data , gcry_mpi_t *skey , + int flags ) ; + gcry_err_code_t (*sign)(int algo , gcry_mpi_t *resarr , gcry_mpi_t data , gcry_mpi_t *skey ) ; + gcry_err_code_t (*verify)(int algo , gcry_mpi_t hash , gcry_mpi_t *data , gcry_mpi_t *pkey , + int (*cmp)(void * , gcry_mpi_t ) , void *opaquev ) ; + unsigned int (*get_nbits)(int algo , gcry_mpi_t *pkey ) ; +}; +#line 155 "/usr/include/gcrypt-module.h" +typedef struct gcry_pk_spec gcry_pk_spec_t; +#line 190 "/usr/include/gcrypt-module.h" +typedef void (*gcry_md_init_t)(void *c ); +#line 193 "/usr/include/gcrypt-module.h" +typedef void (*gcry_md_write_t)(void *c , void const *buf , size_t nbytes ); +#line 196 "/usr/include/gcrypt-module.h" +typedef void (*gcry_md_final_t)(void *c ); +#line 199 "/usr/include/gcrypt-module.h" +typedef unsigned char *(*gcry_md_read_t)(void *c ); +#line 201 "/usr/include/gcrypt-module.h" +struct gcry_md_oid_spec { + char const *oidstring ; +}; +#line 201 "/usr/include/gcrypt-module.h" +typedef struct gcry_md_oid_spec gcry_md_oid_spec_t; +#line 207 "/usr/include/gcrypt-module.h" +struct gcry_md_spec { + char const *name ; + unsigned char *asnoid ; + int asnlen ; + gcry_md_oid_spec_t *oids ; + int mdlen ; + void (*init)(void *c ) ; + void (*write)(void *c , void const *buf , size_t nbytes ) ; + void (*final)(void *c ) ; + unsigned char *(*read)(void *c ) ; + size_t contextsize ; +}; +#line 207 "/usr/include/gcrypt-module.h" +typedef struct gcry_md_spec gcry_md_spec_t; +#line 9 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef long long widest_t; +#line 17 +struct ProtocolDesc; +#line 17 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef struct ProtocolDesc ProtocolDesc; +#line 18 +struct OblivInputs; +#line 18 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef struct OblivInputs OblivInputs; +#line 19 +struct OblivBit; +#line 19 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef struct OblivBit OblivBit; +#line 28 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef char yao_key_t[11]; +#line 30 +struct ProtocolTransport; +#line 30 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct __anonstruct_debug_36 { + unsigned int mulCount ; + unsigned int xorCount ; +}; +#line 30 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +union __anonunion____missing_field_name_35 { + struct __anonstruct_debug_36 debug ; +}; +#line 30 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct ProtocolDesc { + int partyCount ; + int thisParty ; + struct ProtocolTransport *trans ; + union __anonunion____missing_field_name_35 __annonCompField1 ; + void (*feedOblivInputs)(ProtocolDesc * , OblivInputs * , size_t , int ) ; + _Bool (*revealOblivBits)(ProtocolDesc * , widest_t * , OblivBit const * , size_t , + int ) ; + void (*setBitAnd)(ProtocolDesc * , OblivBit * , OblivBit const * , OblivBit const * ) ; + void (*setBitOr)(ProtocolDesc * , OblivBit * , OblivBit const * , OblivBit const * ) ; + void (*setBitXor)(ProtocolDesc * , OblivBit * , OblivBit const * , OblivBit const * ) ; + void (*setBitNot)(ProtocolDesc * , OblivBit * , OblivBit const * ) ; + void (*flipBit)(ProtocolDesc * , OblivBit * ) ; + void *extra ; +}; +#line 52 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct __anonstruct_OTsender_37 { + void *sender ; + void (*send)(void * , char const * , char const * , int n , int len ) ; + void (*release)(void * ) ; +}; +#line 52 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef struct __anonstruct_OTsender_37 OTsender; +#line 58 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct __anonstruct_OTrecver_38 { + void *recver ; + void (*recv)(void * , char * , _Bool const * , int n , int len ) ; + void (*release)(void * ) ; +}; +#line 58 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef struct __anonstruct_OTrecver_38 OTrecver; +#line 64 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +union __anonunion____missing_field_name_39 { + OTsender sender ; + OTrecver recver ; +}; +#line 64 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct YaoProtocolDesc { + yao_key_t R ; + yao_key_t I ; + uint64_t gcount ; + unsigned int icount ; + unsigned int ocount ; + void (*nonFreeGate)(struct ProtocolDesc * , OblivBit * , char , OblivBit const * , + OblivBit const * ) ; + union __anonunion____missing_field_name_39 __annonCompField2 ; +}; +#line 64 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef struct YaoProtocolDesc YaoProtocolDesc; +#line 73 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef struct ProtocolTransport ProtocolTransport; +#line 77 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct ProtocolTransport { + int maxParties ; + int maxChannels ; + int curChannel ; + ProtocolTransport *(*subtransport)(ProtocolTransport * , int ) ; + int (*send)(ProtocolTransport * , int , void const * , size_t ) ; + int (*recv)(ProtocolTransport * , int , void * , size_t ) ; + void (*cleanup)(ProtocolTransport * ) ; +}; +#line 85 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct OblivInputs { + unsigned long long src ; + struct OblivBit *dest ; + size_t size ; +}; +#line 92 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef void (*protocol_run)(void * ); +#line 12 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct __anonstruct_yao_41 { + yao_key_t w ; + _Bool inverted ; +}; +#line 12 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +union __anonunion____missing_field_name_40 { + _Bool knownValue ; + struct __anonstruct_yao_41 yao ; +}; +#line 12 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct OblivBit { + _Bool unknown ; + union __anonunion____missing_field_name_40 __annonCompField3 ; +}; +#line 12 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +typedef struct OblivBit OblivBit___0; +#line 33 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct __anonstruct___obliv_c__bool_42 { + OblivBit___0 bits[1] ; +}; +#line 33 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +typedef struct __anonstruct___obliv_c__bool_42 __obliv_c__bool; +#line 34 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct __anonstruct___obliv_c__char_43 { + OblivBit___0 bits[(unsigned long )8 * (unsigned long )sizeof(char )] ; +}; +#line 34 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +typedef struct __anonstruct___obliv_c__char_43 __obliv_c__char; +#line 35 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct __anonstruct___obliv_c__int_44 { + OblivBit___0 bits[(unsigned long )8 * (unsigned long )sizeof(int )] ; +}; +#line 35 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +typedef struct __anonstruct___obliv_c__int_44 __obliv_c__int; +#line 36 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct __anonstruct___obliv_c__short_45 { + OblivBit___0 bits[(unsigned long )8 * (unsigned long )sizeof(short )] ; +}; +#line 36 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +typedef struct __anonstruct___obliv_c__short_45 __obliv_c__short; +#line 37 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct __anonstruct___obliv_c__long_46 { + OblivBit___0 bits[(unsigned long )8 * (unsigned long )sizeof(long )] ; +}; +#line 37 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +typedef struct __anonstruct___obliv_c__long_46 __obliv_c__long; +#line 38 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct __anonstruct___obliv_c__lLong_47 { + OblivBit___0 bits[(unsigned long )8 * (unsigned long )sizeof(long long )] ; +}; +#line 38 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +typedef struct __anonstruct___obliv_c__lLong_47 __obliv_c__lLong; +#line 45 "/usr/include/stdio.h" +struct _IO_FILE; +#line 45 +struct _IO_FILE; +#line 49 "/usr/include/stdio.h" +typedef struct _IO_FILE FILE; +#line 65 "/usr/include/stdio.h" +typedef struct _IO_FILE __FILE; +#line 83 "/usr/include/wchar.h" +union __anonunion___value_49 { + unsigned int __wch ; + char __wchb[4] ; +}; +#line 83 "/usr/include/wchar.h" +struct __anonstruct___mbstate_t_48 { + int __count ; + union __anonunion___value_49 __value ; +}; +#line 83 "/usr/include/wchar.h" +typedef struct __anonstruct___mbstate_t_48 __mbstate_t; +#line 22 "/usr/include/_G_config.h" +struct __anonstruct__G_fpos_t_50 { + __off_t __pos ; + __mbstate_t __state ; +}; +#line 22 "/usr/include/_G_config.h" +typedef struct __anonstruct__G_fpos_t_50 _G_fpos_t; +#line 27 "/usr/include/_G_config.h" +struct __anonstruct__G_fpos64_t_51 { + __off64_t __pos ; + __mbstate_t __state ; +}; +#line 27 "/usr/include/_G_config.h" +typedef struct __anonstruct__G_fpos64_t_51 _G_fpos64_t; +#line 53 "/usr/include/_G_config.h" +typedef short _G_int16_t; +#line 54 "/usr/include/_G_config.h" +typedef int _G_int32_t; +#line 55 "/usr/include/_G_config.h" +typedef unsigned short _G_uint16_t; +#line 56 "/usr/include/_G_config.h" +typedef unsigned int _G_uint32_t; +#line 172 "/usr/include/libio.h" +struct _IO_jump_t; +#line 172 +struct _IO_jump_t; +#line 172 +struct _IO_FILE; +#line 182 "/usr/include/libio.h" +typedef void _IO_lock_t; +#line 188 "/usr/include/libio.h" +struct _IO_marker { + struct _IO_marker *_next ; + struct _IO_FILE *_sbuf ; + int _pos ; +}; +#line 208 +enum __codecvt_result { + __codecvt_ok = 0, + __codecvt_partial = 1, + __codecvt_error = 2, + __codecvt_noconv = 3 +} ; +#line 273 "/usr/include/libio.h" +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 )((unsigned long )((unsigned long )15 * (unsigned long )sizeof(int )) - (unsigned long )((unsigned long )4 * (unsigned long )sizeof(void *))) - (unsigned long )sizeof(size_t )] ; +}; +#line 343 "/usr/include/libio.h" +typedef struct _IO_FILE _IO_FILE; +#line 346 +struct _IO_FILE_plus; +#line 346 +struct _IO_FILE_plus; +#line 366 "/usr/include/libio.h" +typedef __ssize_t __io_read_fn(void *__cookie , char *__buf , size_t __nbytes ); +#line 374 "/usr/include/libio.h" +typedef __ssize_t __io_write_fn(void *__cookie , char const *__buf , size_t __n ); +#line 383 "/usr/include/libio.h" +typedef int __io_seek_fn(void *__cookie , __off64_t *__pos , int __w ); +#line 386 "/usr/include/libio.h" +typedef int __io_close_fn(void *__cookie ); +#line 111 "/usr/include/stdio.h" +typedef _G_fpos_t fpos_t; +#line 7 "./mutual.h" +typedef char *string; +#line 8 "./mutual.h" +struct protocolIO { + char mine[45][10] ; + int size ; + char common[45][10] ; + int commonSize ; +}; +#line 8 "./mutual.h" +typedef struct protocolIO protocolIO; +#line 7 "mutual.oc" +typedef __obliv_c__bool obool; +/* compiler builtin: + void __builtin_va_copy(__builtin_va_list , __builtin_va_list ) ; */ +/* compiler builtin: + double __builtin_huge_val(void) ; */ +/* compiler builtin: + int __builtin_clzl(unsigned long ) ; */ +/* compiler builtin: + float __builtin_frexpf(float , int * ) ; */ +/* compiler builtin: + long double __builtin_fmodl(long double ) ; */ +/* compiler builtin: + double __builtin_atan(double ) ; */ +/* compiler builtin: + int __builtin___fprintf_chk(void * , int , char const * , ...) ; */ +/* compiler builtin: + float __builtin_ceilf(float ) ; */ +/* compiler builtin: + void __attribute__((__overloaded__)) __sync_and_and_fetch(...) ; */ +/* compiler builtin: + void __attribute__((__overloaded__)) __sync_fetch_and_or(...) ; */ +/* compiler builtin: + void __builtin_return(void const * ) ; */ +/* compiler builtin: + int __builtin_popcountll(unsigned long long ) ; */ +/* compiler builtin: + long double __builtin_asinl(long double ) ; */ +/* compiler builtin: + float __builtin_atanf(float ) ; */ +/* compiler builtin: + int __builtin_ffsll(unsigned long long ) ; */ +/* compiler builtin: + float __attribute__((____vector_size____(16))) __builtin_ia32_addps(float __attribute__((____vector_size____(16))) , + float __attribute__((____vector_size____(16))) ) ; */ +/* compiler builtin: + unsigned long __builtin_strcspn(char const * , char const * ) ; */ +/* compiler builtin: + float __builtin_asinf(float ) ; */ +/* compiler builtin: + float __attribute__((____vector_size____(16))) __builtin_ia32_maxps(float __attribute__((____vector_size____(16))) , + float __attribute__((____vector_size____(16))) ) ; */ +/* compiler builtin: + float __attribute__((____vector_size____(16))) __builtin_ia32_unpckhps(float __attribute__((____vector_size____(16))) , + float __attribute__((____vector_size____(16))) ) ; */ +/* compiler builtin: + double __builtin_acos(double ) ; */ +/* compiler builtin: + int __builtin_va_arg_pack(void) ; */ +/* compiler builtin: + char *__builtin___strncpy_chk(char * , char const * , unsigned long , unsigned long ) ; */ +/* compiler builtin: + int __builtin___sprintf_chk(char * , int , unsigned long , char const * , ...) ; */ +/* compiler builtin: + double __builtin_powi(double , int ) ; */ +/* compiler builtin: + char *__builtin_strchr(char * , int ) ; */ +/* compiler builtin: + char *__builtin___strncat_chk(char * , char const * , unsigned long , unsigned long ) ; */ +/* compiler builtin: + long double __builtin_huge_vall(void) ; */ +/* compiler builtin: + int __builtin_ffsl(unsigned long ) ; */ +/* compiler builtin: + int __builtin___vprintf_chk(int , char const * , __builtin_va_list ) ; */ +/* compiler builtin: + float __attribute__((____vector_size____(16))) __builtin_ia32_unpcklps(float __attribute__((____vector_size____(16))) , + float __attribute__((____vector_size____(16))) ) ; */ +/* compiler builtin: + char *__builtin_strncat(char * , char const * , unsigned long ) ; */ +/* compiler builtin: + int __builtin_ctzll(unsigned long long ) ; */ +/* compiler builtin: + double __builtin_cosh(double ) ; */ +/* compiler builtin: + void __builtin_stdarg_start(__builtin_va_list ) ; */ +/* compiler builtin: + float __builtin_tanhf(float ) ; */ +/* compiler builtin: + void __attribute__((__overloaded__)) __sync_fetch_and_xor(...) ; */ +/* compiler builtin: + void *__builtin_mempcpy(void * , void const * , unsigned long ) ; */ +/* compiler builtin: + long double __builtin_frexpl(long double , int * ) ; */ +/* compiler builtin: + float __builtin_tanf(float ) ; */ +/* compiler builtin: + long double __builtin_logl(long double ) ; */ +/* compiler builtin: + long double __builtin_sqrtl(long double ) ; */ +/* compiler builtin: + int __builtin_parity(unsigned int ) ; */ +/* compiler builtin: + void __builtin_va_arg(__builtin_va_list , unsigned long , void * ) ; */ +/* compiler builtin: + long __builtin_expect(long , long ) ; */ +/* compiler builtin: + long double __builtin_coshl(long double ) ; */ +/* compiler builtin: + long double __builtin_cosl(long double ) ; */ +/* compiler builtin: + float __builtin_cosf(float ) ; */ +/* compiler builtin: + int __builtin___printf_chk(int , char const * , ...) ; */ +/* compiler builtin: + void __sync_synchronize(...) ; */ +/* compiler builtin: + long double __builtin_acosl(long double ) ; */ +/* compiler builtin: + int __builtin___vfprintf_chk(void * , int , char const * , __builtin_va_list ) ; */ +/* compiler builtin: + void *__builtin___mempcpy_chk(void * , void const * , unsigned long , unsigned long ) ; */ +/* compiler builtin: + void __attribute__((__overloaded__)) __sync_or_and_fetch(...) ; */ +/* compiler builtin: + void __builtin_prefetch(void const * , ...) ; */ +/* compiler builtin: + long double __builtin_nansl(char const * ) ; */ +/* compiler builtin: + double __builtin_fmod(double ) ; */ +/* compiler builtin: + int __builtin_clz(unsigned int ) ; */ +/* compiler builtin: + void __attribute__((__overloaded__)) __sync_val_compare_and_swap(...) ; */ +/* compiler builtin: + double __builtin_log10(double ) ; */ +/* compiler builtin: + char *__builtin___strcat_chk(char * , char const * , unsigned long ) ; */ +/* compiler builtin: + double __builtin_tanh(double ) ; */ +/* compiler builtin: + float __builtin_modff(float , float * ) ; */ +/* compiler builtin: + double __builtin_sin(double ) ; */ +/* compiler builtin: + double __builtin_frexp(double , int * ) ; */ +/* compiler builtin: + float __builtin_acosf(float ) ; */ +/* compiler builtin: + void __attribute__((__overloaded__)) __sync_add_and_fetch(...) ; */ +/* compiler builtin: + long double __builtin_sinhl(long double ) ; */ +/* compiler builtin: + char *__builtin___stpcpy_chk(char * , char const * , unsigned long ) ; */ +/* compiler builtin: + long double __builtin_ldexpl(long double , int ) ; */ +/* compiler builtin: + double __builtin_fabs(double ) ; */ +/* compiler builtin: + void __attribute__((__overloaded__)) __sync_fetch_and_nand(...) ; */ +/* compiler builtin: + void *__builtin_apply(void (*)() , void * , unsigned long ) ; */ +/* compiler builtin: + float __builtin_sinf(float ) ; */ +/* compiler builtin: + double __builtin_ceil(double ) ; */ +/* compiler builtin: + long double __builtin_powil(long double , int ) ; */ +/* compiler builtin: + void __builtin_va_start(__builtin_va_list ) ; */ +/* compiler builtin: + long double __builtin_expl(long double ) ; */ +/* compiler builtin: + int __builtin_constant_p(int ) ; */ +/* compiler builtin: + double __builtin_log(double ) ; */ +/* compiler builtin: + float __builtin_expf(float ) ; */ +/* compiler builtin: + int __builtin_types_compatible_p(unsigned long , unsigned long ) ; */ +/* compiler builtin: + int __builtin_ctz(unsigned int ) ; */ +/* compiler builtin: + long double __builtin_atan2l(long double , long double ) ; */ +/* compiler builtin: + void *__builtin_apply_args(void) ; */ +/* compiler builtin: + char *__builtin_strpbrk(char const * , char const * ) ; */ +/* compiler builtin: + char *__builtin_strcpy(char * , char const * ) ; */ +/* compiler builtin: + double __builtin_sqrt(double ) ; */ +/* compiler builtin: + __builtin_va_list __builtin_next_arg(void) ; */ +/* compiler builtin: + float __builtin_logf(float ) ; */ +/* compiler builtin: + float __builtin_log10f(float ) ; */ +/* compiler builtin: + long double __builtin_fabsl(long double ) ; */ +/* compiler builtin: + unsigned long __builtin_strlen(char const * ) ; */ +/* compiler builtin: + long double __builtin_floorl(long double ) ; */ +/* compiler builtin: + int __builtin_ffs(unsigned int ) ; */ +/* compiler builtin: + double __builtin_inf(void) ; */ +/* compiler builtin: + float __builtin_floorf(float ) ; */ +/* compiler builtin: + void *__builtin_memcpy(void * , void const * , unsigned long ) ; */ +/* compiler builtin: + void *__builtin___memcpy_chk(void * , void const * , unsigned long , unsigned long ) ; */ +/* compiler builtin: + void __attribute__((__overloaded__)) __sync_sub_and_fetch(...) ; */ +/* compiler builtin: + int __builtin_parityl(unsigned long ) ; */ +/* compiler builtin: + void __attribute__((__overloaded__)) __sync_nand_and_fetch(...) ; */ +/* compiler builtin: + float __attribute__((____vector_size____(16))) __builtin_ia32_subps(float __attribute__((____vector_size____(16))) , + float __attribute__((____vector_size____(16))) ) ; */ +/* compiler builtin: + void __attribute__((__overloaded__)) __sync_lock_test_and_set(...) ; */ +/* compiler builtin: + unsigned long __builtin_strspn(char const * , char const * ) ; */ +/* compiler builtin: + void __builtin_varargs_start(__builtin_va_list ) ; */ +/* compiler builtin: + int __builtin_parityll(unsigned long long ) ; */ +/* compiler builtin: + void __builtin_va_end(__builtin_va_list ) ; */ +/* compiler builtin: + void __builtin_bzero(void * , unsigned long ) ; */ +/* compiler builtin: + int __builtin_strncmp(char const * , char const * , unsigned long ) ; */ +/* compiler builtin: + double __builtin_nan(char const * ) ; */ +/* compiler builtin: + void __attribute__((__overloaded__)) __sync_xor_and_fetch(...) ; */ +/* compiler builtin: + int __builtin___vsprintf_chk(char * , int , unsigned long , char const * , + __builtin_va_list ) ; */ +/* compiler builtin: + int __builtin___snprintf_chk(char * , unsigned long , int , unsigned long , + char const * , ...) ; */ +/* compiler builtin: + float __builtin_sqrtf(float ) ; */ +/* compiler builtin: + double __builtin_nans(char const * ) ; */ +/* compiler builtin: + long double __builtin_atanl(long double ) ; */ +/* compiler builtin: + double __builtin_exp(double ) ; */ +/* compiler builtin: + int __builtin_clzll(unsigned long long ) ; */ +/* compiler builtin: + float __builtin_huge_valf(void) ; */ +/* compiler builtin: + float __builtin_coshf(float ) ; */ +/* compiler builtin: + float __builtin_nansf(char const * ) ; */ +/* compiler builtin: + void __attribute__((__overloaded__)) __sync_fetch_and_add(...) ; */ +/* compiler builtin: + int __builtin___vsnprintf_chk(char * , unsigned long , int , unsigned long , + char const * , __builtin_va_list ) ; */ +/* compiler builtin: + float __builtin_nanf(char const * ) ; */ +/* compiler builtin: + int __builtin_strcmp(char const * , char const * ) ; */ +/* compiler builtin: + _Bool __sync_bool_compare_and_swap(...) ; */ +/* compiler builtin: + float __builtin_ldexpf(float , int ) ; */ +/* compiler builtin: + double __builtin_atan2(double , double ) ; */ +/* compiler builtin: + int __builtin_popcountl(unsigned long ) ; */ +/* compiler builtin: + float __builtin_powif(float , int ) ; */ +/* compiler builtin: + long double __builtin_ceill(long double ) ; */ +/* compiler builtin: + char *__builtin___strcpy_chk(char * , char const * , unsigned long ) ; */ +/* compiler builtin: + long double __builtin_log10l(long double ) ; */ +/* compiler builtin: + void *__builtin___memmove_chk(void * , void const * , unsigned long , unsigned long ) ; */ +/* compiler builtin: + void __attribute__((__overloaded__)) __sync_fetch_and_and(...) ; */ +/* compiler builtin: + void *__builtin_return_address(unsigned int ) ; */ +/* compiler builtin: + float __builtin_fabsf(float ) ; */ +/* compiler builtin: + double __builtin_floor(double ) ; */ +/* compiler builtin: + double __builtin_cos(double ) ; */ +/* compiler builtin: + void __attribute__((__overloaded__)) __sync_fetch_and_sub(...) ; */ +/* compiler builtin: + unsigned long __builtin_object_size(void * , int ) ; */ +/* compiler builtin: + void *__builtin_memset(void * , int , int ) ; */ +/* compiler builtin: + void *__builtin_alloca(unsigned long ) ; */ +/* compiler builtin: + long double __builtin_nanl(char const * ) ; */ +/* compiler builtin: + float __builtin_atan2f(float , float ) ; */ +/* compiler builtin: + int __builtin_popcount(unsigned int ) ; */ +/* compiler builtin: + int __builtin_va_arg_pack_len(void) ; */ +/* compiler builtin: + long double __builtin_tanl(long double ) ; */ +/* compiler builtin: + double __builtin_sinh(double ) ; */ +/* compiler builtin: + void __builtin_bcopy(void const * , void * , unsigned long ) ; */ +/* compiler builtin: + void __sync_lock_release(...) ; */ +/* compiler builtin: + long double __builtin_modfl(long double , long double * ) ; */ +/* compiler builtin: + char *__builtin_stpcpy(char * , char const * ) ; */ +/* compiler builtin: + long double __builtin_sinl(long double ) ; */ +/* compiler builtin: + double __builtin_asin(double ) ; */ +/* compiler builtin: + float __builtin_sinhf(float ) ; */ +/* compiler builtin: + int __builtin_ctzl(unsigned long ) ; */ +/* compiler builtin: + long double __builtin_tanhl(long double ) ; */ +/* compiler builtin: + int __builtin_bswap32(int ) ; */ +/* compiler builtin: + double __builtin_ldexp(double , int ) ; */ +/* compiler builtin: + long double __builtin_infl(void) ; */ +/* compiler builtin: + long __builtin_bswap64(long ) ; */ +/* compiler builtin: + float __builtin_fmodf(float ) ; */ +/* compiler builtin: + float __attribute__((____vector_size____(16))) __builtin_ia32_mulps(float __attribute__((____vector_size____(16))) , + float __attribute__((____vector_size____(16))) ) ; */ +/* compiler builtin: + double __builtin_tan(double ) ; */ +/* compiler builtin: + char *__builtin_strncpy(char * , char const * , unsigned long ) ; */ +/* compiler builtin: + float __builtin_inff(void) ; */ +/* compiler builtin: + void *__builtin___memset_chk(void * , int , unsigned long , unsigned long ) ; */ +/* compiler builtin: + void *__builtin_frame_address(unsigned int ) ; */ +#line 3 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern __attribute__((__nothrow__)) void *( __attribute__((__nonnull__(1), __leaf__)) memset)(void *__s , + int __c , + unsigned long __n ) ; +#line 140 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) size_t ( __attribute__((__leaf__)) __ctype_get_mb_cur_max)(void) ; +#line 145 +extern __attribute__((__nothrow__)) double ( __attribute__((__nonnull__(1), __leaf__)) atof)(char const *__nptr ) __attribute__((__pure__)) ; +#line 148 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) atoi)(char const *__nptr ) __attribute__((__pure__)) ; +#line 151 +extern __attribute__((__nothrow__)) long ( __attribute__((__nonnull__(1), __leaf__)) atol)(char const *__nptr ) __attribute__((__pure__)) ; +#line 158 +extern __attribute__((__nothrow__)) long long ( __attribute__((__nonnull__(1), __leaf__)) atoll)(char const *__nptr ) __attribute__((__pure__)) ; +#line 165 +extern __attribute__((__nothrow__)) double ( __attribute__((__nonnull__(1), __leaf__)) strtod)(char const * __restrict __nptr , + char ** __restrict __endptr ) ; +#line 173 +extern __attribute__((__nothrow__)) float ( __attribute__((__nonnull__(1), __leaf__)) strtof)(char const * __restrict __nptr , + char ** __restrict __endptr ) ; +#line 176 +extern __attribute__((__nothrow__)) long double ( __attribute__((__nonnull__(1), +__leaf__)) strtold)(char const * __restrict __nptr , char ** __restrict __endptr ) ; +#line 184 +extern __attribute__((__nothrow__)) long ( __attribute__((__nonnull__(1), __leaf__)) strtol)(char const * __restrict __nptr , + char ** __restrict __endptr , + int __base ) ; +#line 188 +extern __attribute__((__nothrow__)) unsigned long ( __attribute__((__nonnull__(1), +__leaf__)) strtoul)(char const * __restrict __nptr , char ** __restrict __endptr , + int __base ) ; +#line 196 +extern __attribute__((__nothrow__)) long long ( __attribute__((__nonnull__(1), __leaf__)) strtoq)(char const * __restrict __nptr , + char ** __restrict __endptr , + int __base ) ; +#line 201 +extern __attribute__((__nothrow__)) unsigned long long ( __attribute__((__nonnull__(1), +__leaf__)) strtouq)(char const * __restrict __nptr , char ** __restrict __endptr , + int __base ) ; +#line 210 +extern __attribute__((__nothrow__)) long long ( __attribute__((__nonnull__(1), __leaf__)) strtoll)(char const * __restrict __nptr , + char ** __restrict __endptr , + int __base ) ; +#line 215 +extern __attribute__((__nothrow__)) unsigned long long ( __attribute__((__nonnull__(1), +__leaf__)) strtoull)(char const * __restrict __nptr , char ** __restrict __endptr , + int __base ) ; +#line 311 +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) l64a)(long __n ) ; +#line 314 +extern __attribute__((__nothrow__)) long ( __attribute__((__nonnull__(1), __leaf__)) a64l)(char const *__s ) __attribute__((__pure__)) ; +#line 107 "/usr/include/x86_64-linux-gnu/sys/select.h" +extern int select(int __nfds , fd_set * __restrict __readfds , fd_set * __restrict __writefds , + fd_set * __restrict __exceptfds , struct timeval * __restrict __timeout ) ; +#line 119 +extern int pselect(int __nfds , fd_set * __restrict __readfds , fd_set * __restrict __writefds , + fd_set * __restrict __exceptfds , struct timespec const * __restrict __timeout , + __sigset_t const * __restrict __sigmask ) ; +#line 33 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" +extern __attribute__((__nothrow__)) unsigned int ( __attribute__((__leaf__)) gnu_dev_major)(unsigned long long __dev ) __attribute__((__const__)) ; +#line 36 +extern __attribute__((__nothrow__)) unsigned int ( __attribute__((__leaf__)) gnu_dev_minor)(unsigned long long __dev ) __attribute__((__const__)) ; +#line 39 +extern __attribute__((__nothrow__)) unsigned long long ( __attribute__((__leaf__)) gnu_dev_makedev)(unsigned int __major , + unsigned int __minor ) __attribute__((__const__)) ; +#line 327 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) long ( __attribute__((__leaf__)) random)(void) ; +#line 330 +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) srandom)(unsigned int __seed ) ; +#line 336 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(2), __leaf__)) initstate)(unsigned int __seed , + char *__statebuf , + size_t __statelen ) ; +#line 341 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) setstate)(char *__statebuf ) ; +#line 360 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) random_r)(struct random_data * __restrict __buf , + int32_t * __restrict __result ) ; +#line 363 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(2), __leaf__)) srandom_r)(unsigned int __seed , + struct random_data *__buf ) ; +#line 366 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(2,4), __leaf__)) initstate_r)(unsigned int __seed , + char * __restrict __statebuf , + size_t __statelen , + struct random_data * __restrict __buf ) ; +#line 371 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) setstate_r)(char * __restrict __statebuf , + struct random_data * __restrict __buf ) ; +#line 380 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) rand)(void) ; +#line 382 +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) srand)(unsigned int __seed ) ; +#line 387 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) rand_r)(unsigned int *__seed ) ; +#line 395 +extern __attribute__((__nothrow__)) double ( __attribute__((__leaf__)) drand48)(void) ; +#line 396 +extern __attribute__((__nothrow__)) double ( __attribute__((__nonnull__(1), __leaf__)) erand48)(unsigned short *__xsubi ) ; +#line 399 +extern __attribute__((__nothrow__)) long ( __attribute__((__leaf__)) lrand48)(void) ; +#line 400 +extern __attribute__((__nothrow__)) long ( __attribute__((__nonnull__(1), __leaf__)) nrand48)(unsigned short *__xsubi ) ; +#line 404 +extern __attribute__((__nothrow__)) long ( __attribute__((__leaf__)) mrand48)(void) ; +#line 405 +extern __attribute__((__nothrow__)) long ( __attribute__((__nonnull__(1), __leaf__)) jrand48)(unsigned short *__xsubi ) ; +#line 409 +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) srand48)(long __seedval ) ; +#line 410 +extern __attribute__((__nothrow__)) unsigned short *( __attribute__((__nonnull__(1), +__leaf__)) seed48)(unsigned short *__seed16v ) ; +#line 412 +extern __attribute__((__nothrow__)) void ( __attribute__((__nonnull__(1), __leaf__)) lcong48)(unsigned short *__param ) ; +#line 428 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) drand48_r)(struct drand48_data * __restrict __buffer , + double * __restrict __result ) ; +#line 430 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) erand48_r)(unsigned short *__xsubi , + struct drand48_data * __restrict __buffer , + double * __restrict __result ) ; +#line 435 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) lrand48_r)(struct drand48_data * __restrict __buffer , + long * __restrict __result ) ; +#line 438 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) nrand48_r)(unsigned short *__xsubi , + struct drand48_data * __restrict __buffer , + long * __restrict __result ) ; +#line 444 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) mrand48_r)(struct drand48_data * __restrict __buffer , + long * __restrict __result ) ; +#line 447 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) jrand48_r)(unsigned short *__xsubi , + struct drand48_data * __restrict __buffer , + long * __restrict __result ) ; +#line 453 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(2), __leaf__)) srand48_r)(long __seedval , + struct drand48_data *__buffer ) ; +#line 456 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) seed48_r)(unsigned short *__seed16v , + struct drand48_data *__buffer ) ; +#line 459 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) lcong48_r)(unsigned short *__param , + struct drand48_data *__buffer ) ; +#line 471 +extern __attribute__((__nothrow__)) void *( __attribute__((__leaf__)) malloc)(size_t __size ) __attribute__((__malloc__)) ; +#line 473 +extern __attribute__((__nothrow__)) void *( __attribute__((__leaf__)) calloc)(size_t __nmemb , + size_t __size ) __attribute__((__malloc__)) ; +#line 485 +extern __attribute__((__nothrow__)) void *( __attribute__((__warn_unused_result__, +__leaf__)) realloc)(void *__ptr , size_t __size ) ; +#line 488 +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) free)(void *__ptr ) ; +#line 493 +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) cfree)(void *__ptr ) ; +#line 33 "/usr/include/alloca.h" +extern __attribute__((__nothrow__)) void *( __attribute__((__leaf__)) alloca)(size_t __size ) ; +#line 503 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) void *( __attribute__((__leaf__)) valloc)(size_t __size ) __attribute__((__malloc__)) ; +#line 508 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) posix_memalign)(void **__memptr , + size_t __alignment , + size_t __size ) ; +#line 514 +extern __attribute__((__nothrow__, __noreturn__)) void ( __attribute__((__leaf__)) abort)(void) ; +#line 518 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) atexit)(void (*__func)(void) ) ; +#line 536 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) on_exit)(void (*__func)(int __status , + void *__arg ) , + void *__arg ) ; +#line 544 +extern __attribute__((__nothrow__, __noreturn__)) void ( __attribute__((__leaf__)) exit)(int __status ) ; +#line 560 +extern __attribute__((__nothrow__, __noreturn__)) void ( __attribute__((__leaf__)) _Exit)(int __status ) ; +#line 567 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) getenv)(char const *__name ) ; +#line 572 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) __secure_getenv)(char const *__name ) ; +#line 579 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) putenv)(char *__string ) ; +#line 585 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(2), __leaf__)) setenv)(char const *__name , + char const *__value , + int __replace ) ; +#line 589 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) unsetenv)(char const *__name ) ; +#line 596 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) clearenv)(void) ; +#line 606 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) mktemp)(char *__template ) ; +#line 620 +extern int ( __attribute__((__nonnull__(1))) mkstemp)(char *__template ) ; +#line 642 +extern int ( __attribute__((__nonnull__(1))) mkstemps)(char *__template , int __suffixlen ) ; +#line 663 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) mkdtemp)(char *__template ) ; +#line 717 +extern int system(char const *__command ) ; +#line 734 +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) realpath)(char const * __restrict __name , + char * __restrict __resolved ) ; +#line 755 +extern void *( __attribute__((__nonnull__(1,2,5))) bsearch)(void const *__key , + void const *__base , + size_t __nmemb , size_t __size , + int (*__compar)(void const * , + void const * ) ) ; +#line 761 +extern void ( __attribute__((__nonnull__(1,4))) qsort)(void *__base , size_t __nmemb , + size_t __size , int (*__compar)(void const * , + void const * ) ) ; +#line 771 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) abs)(int __x ) __attribute__((__const__)) ; +#line 772 +extern __attribute__((__nothrow__)) long ( __attribute__((__leaf__)) labs)(long __x ) __attribute__((__const__)) ; +#line 776 +extern __attribute__((__nothrow__)) long long ( __attribute__((__leaf__)) llabs)(long long __x ) __attribute__((__const__)) ; +#line 785 +extern __attribute__((__nothrow__)) div_t ( __attribute__((__leaf__)) div)(int __numer , + int __denom ) __attribute__((__const__)) ; +#line 787 +extern __attribute__((__nothrow__)) ldiv_t ( __attribute__((__leaf__)) ldiv)(long __numer , + long __denom ) __attribute__((__const__)) ; +#line 793 +extern __attribute__((__nothrow__)) lldiv_t ( __attribute__((__leaf__)) lldiv)(long long __numer , + long long __denom ) __attribute__((__const__)) ; +#line 808 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(3,4), __leaf__)) ecvt)(double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign ) ; +#line 814 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(3,4), __leaf__)) fcvt)(double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign ) ; +#line 820 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(3), __leaf__)) gcvt)(double __value , + int __ndigit , + char *__buf ) ; +#line 826 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(3,4), __leaf__)) qecvt)(long double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign ) ; +#line 829 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(3,4), __leaf__)) qfcvt)(long double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign ) ; +#line 832 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(3), __leaf__)) qgcvt)(long double __value , + int __ndigit , + char *__buf ) ; +#line 838 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(3,4,5), __leaf__)) ecvt_r)(double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign , + char * __restrict __buf , + size_t __len ) ; +#line 841 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(3,4,5), __leaf__)) fcvt_r)(double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign , + char * __restrict __buf , + size_t __len ) ; +#line 845 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(3,4,5), __leaf__)) qecvt_r)(long double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign , + char * __restrict __buf , + size_t __len ) ; +#line 849 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(3,4,5), __leaf__)) qfcvt_r)(long double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign , + char * __restrict __buf , + size_t __len ) ; +#line 860 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) mblen)(char const *__s , + size_t __n ) ; +#line 863 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) mbtowc)(wchar_t * __restrict __pwc , + char const * __restrict __s , + size_t __n ) ; +#line 867 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) wctomb)(char *__s , + wchar_t __wchar ) ; +#line 871 +extern __attribute__((__nothrow__)) size_t ( __attribute__((__leaf__)) mbstowcs)(wchar_t * __restrict __pwcs , + char const * __restrict __s , + size_t __n ) ; +#line 874 +extern __attribute__((__nothrow__)) size_t ( __attribute__((__leaf__)) wcstombs)(char * __restrict __s , + wchar_t const * __restrict __pwcs , + size_t __n ) ; +#line 885 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) rpmatch)(char const *__response ) ; +#line 896 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2,3), __leaf__)) getsubopt)(char ** __restrict __optionp , + char * const * __restrict __tokens , + char ** __restrict __valuep ) ; +#line 948 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) getloadavg)(double *__loadavg , + int __nelem ) ; +#line 44 "/usr/include/string.h" +extern __attribute__((__nothrow__)) void *( __attribute__((__nonnull__(1,2), __leaf__)) memcpy)(void * __restrict __dest , + void const * __restrict __src , + size_t __n ) ; +#line 49 +extern __attribute__((__nothrow__)) void *( __attribute__((__nonnull__(1,2), __leaf__)) memmove)(void *__dest , + void const *__src , + size_t __n ) ; +#line 57 +extern __attribute__((__nothrow__)) void *( __attribute__((__nonnull__(1,2), __leaf__)) memccpy)(void * __restrict __dest , + void const * __restrict __src , + int __c , + size_t __n ) ; +#line 68 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) memcmp)(void const *__s1 , + void const *__s2 , + size_t __n ) __attribute__((__pure__)) ; +#line 95 +extern __attribute__((__nothrow__)) void *( __attribute__((__nonnull__(1), __leaf__)) memchr)(void const *__s , + int __c , + size_t __n ) __attribute__((__pure__)) ; +#line 128 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) strcpy)(char * __restrict __dest , + char const * __restrict __src ) ; +#line 131 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) strncpy)(char * __restrict __dest , + char const * __restrict __src , + size_t __n ) ; +#line 136 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) strcat)(char * __restrict __dest , + char const * __restrict __src ) ; +#line 139 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) strncat)(char * __restrict __dest , + char const * __restrict __src , + size_t __n ) ; +#line 143 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) strcmp)(char const *__s1 , + char const *__s2 ) __attribute__((__pure__)) ; +#line 146 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) strncmp)(char const *__s1 , + char const *__s2 , + size_t __n ) __attribute__((__pure__)) ; +#line 150 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) strcoll)(char const *__s1 , + char const *__s2 ) __attribute__((__pure__)) ; +#line 153 +extern __attribute__((__nothrow__)) size_t ( __attribute__((__nonnull__(2), __leaf__)) strxfrm)(char * __restrict __dest , + char const * __restrict __src , + size_t __n ) ; +#line 165 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2,3), __leaf__)) strcoll_l)(char const *__s1 , + char const *__s2 , + __locale_t __l ) __attribute__((__pure__)) ; +#line 168 +extern __attribute__((__nothrow__)) size_t ( __attribute__((__nonnull__(2,4), __leaf__)) strxfrm_l)(char *__dest , + char const *__src , + size_t __n , + __locale_t __l ) ; +#line 175 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) strdup)(char const *__s ) __attribute__((__malloc__)) ; +#line 183 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) strndup)(char const *__string , + size_t __n ) __attribute__((__malloc__)) ; +#line 235 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) strchr)(char const *__s , + int __c ) __attribute__((__pure__)) ; +#line 262 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) strrchr)(char const *__s , + int __c ) __attribute__((__pure__)) ; +#line 284 +extern __attribute__((__nothrow__)) size_t ( __attribute__((__nonnull__(1,2), __leaf__)) strcspn)(char const *__s , + char const *__reject ) __attribute__((__pure__)) ; +#line 288 +extern __attribute__((__nothrow__)) size_t ( __attribute__((__nonnull__(1,2), __leaf__)) strspn)(char const *__s , + char const *__accept ) __attribute__((__pure__)) ; +#line 314 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) strpbrk)(char const *__s , + char const *__accept ) __attribute__((__pure__)) ; +#line 342 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) strstr)(char const *__haystack , + char const *__needle ) __attribute__((__pure__)) ; +#line 348 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(2), __leaf__)) strtok)(char * __restrict __s , + char const * __restrict __delim ) ; +#line 354 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(2,3), __leaf__)) __strtok_r)(char * __restrict __s , + char const * __restrict __delim , + char ** __restrict __save_ptr ) ; +#line 359 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(2,3), __leaf__)) strtok_r)(char * __restrict __s , + char const * __restrict __delim , + char ** __restrict __save_ptr ) ; +#line 399 +extern __attribute__((__nothrow__)) size_t ( __attribute__((__nonnull__(1), __leaf__)) strlen)(char const *__s ) __attribute__((__pure__)) ; +#line 406 +extern __attribute__((__nothrow__)) size_t ( __attribute__((__nonnull__(1), __leaf__)) strnlen)(char const *__string , + size_t __maxlen ) __attribute__((__pure__)) ; +#line 413 +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) strerror)(int __errnum ) ; +#line 427 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(2), __leaf__)) strerror_r)(int __errnum , + char *__buf , + size_t __buflen ) __asm__("__xpg_strerror_r") ; +#line 445 +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) strerror_l)(int __errnum , + __locale_t __l ) ; +#line 451 +extern __attribute__((__nothrow__)) void ( __attribute__((__nonnull__(1), __leaf__)) __bzero)(void *__s , + size_t __n ) ; +#line 455 +extern __attribute__((__nothrow__)) void ( __attribute__((__nonnull__(1,2), __leaf__)) bcopy)(void const *__src , + void *__dest , + size_t __n ) ; +#line 459 +extern __attribute__((__nothrow__)) void ( __attribute__((__nonnull__(1), __leaf__)) bzero)(void *__s , + size_t __n ) ; +#line 462 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) bcmp)(void const *__s1 , + void const *__s2 , + size_t __n ) __attribute__((__pure__)) ; +#line 489 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) index)(char const *__s , + int __c ) __attribute__((__pure__)) ; +#line 517 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) rindex)(char const *__s , + int __c ) __attribute__((__pure__)) ; +#line 523 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) ffs)(int __i ) __attribute__((__const__)) ; +#line 536 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) strcasecmp)(char const *__s1 , + char const *__s2 ) __attribute__((__pure__)) ; +#line 540 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) strncasecmp)(char const *__s1 , + char const *__s2 , + size_t __n ) __attribute__((__pure__)) ; +#line 559 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) strsep)(char ** __restrict __stringp , + char const * __restrict __delim ) ; +#line 566 +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) strsignal)(int __sig ) ; +#line 569 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) __stpcpy)(char * __restrict __dest , + char const * __restrict __src ) ; +#line 571 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) stpcpy)(char * __restrict __dest , + char const * __restrict __src ) ; +#line 576 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) __stpncpy)(char * __restrict __dest , + char const * __restrict __src , + size_t __n ) ; +#line 579 +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) stpncpy)(char * __restrict __dest , + char const * __restrict __src , + size_t __n ) ; +#line 551 "/usr/include/gpg-error.h" +extern gpg_error_t gpg_err_init(void) __attribute__((__constructor__)) ; +#line 562 +extern void gpg_err_deinit(int mode ) ; +#line 569 "/usr/include/gpg-error.h" +__inline static gpg_error_t gpg_err_make(gpg_err_source_t source , gpg_err_code_t code ) +{ + unsigned int tmp ; + unsigned int __cil_tmp4 ; + unsigned int __cil_tmp5 ; + unsigned int __cil_tmp6 ; + unsigned int __cil_tmp7 ; + unsigned int __cil_tmp8 ; + unsigned int __cil_tmp9 ; + int __cil_tmp10 ; + unsigned int __cil_tmp11 ; + unsigned int __cil_tmp12 ; + unsigned int __cil_tmp13 ; + unsigned int __cil_tmp14 ; + unsigned int __cil_tmp15 ; + unsigned int __cil_tmp16 ; + + { +#line 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(unsigned int )); + { +#line 572 "/usr/include/gpg-error.h" + __cil_tmp4 = (unsigned int )0; +#line 572 + __cil_tmp5 = (unsigned int )code; +#line 572 + if (__cil_tmp5 == __cil_tmp4) { +#line 572 + tmp = (unsigned int )0; + } else { +#line 572 + __cil_tmp6 = (unsigned int )65535; +#line 572 + __cil_tmp7 = (unsigned int )code; +#line 572 + __cil_tmp8 = __cil_tmp7 & __cil_tmp6; +#line 572 + __cil_tmp9 = (unsigned int )__cil_tmp8; +#line 572 + __cil_tmp10 = (int )24; +#line 572 + __cil_tmp11 = (unsigned int )127; +#line 572 + __cil_tmp12 = (unsigned int )source; +#line 572 + __cil_tmp13 = __cil_tmp12 & __cil_tmp11; +#line 572 + __cil_tmp14 = (unsigned int )__cil_tmp13; +#line 572 + __cil_tmp15 = __cil_tmp14 << __cil_tmp10; +#line 572 + __cil_tmp16 = (unsigned int )__cil_tmp15; +#line 572 + tmp = __cil_tmp16 | __cil_tmp9; + } + } +#line 572 + return (tmp); +} +} +#line 584 "/usr/include/gpg-error.h" +__inline static gpg_error_t gpg_error(gpg_err_code_t code ) +{ + gpg_error_t tmp ; + gpg_err_source_t __cil_tmp3 ; + + { +#line 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gpg_error_t )); +#line 587 "/usr/include/gpg-error.h" + __cil_tmp3 = (gpg_err_source_t )0; +#line 587 + tmp = gpg_err_make(__cil_tmp3, code); +#line 587 + return (tmp); +} +} +#line 592 "/usr/include/gpg-error.h" +__inline static gpg_err_code_t gpg_err_code(gpg_error_t err ) +{ + unsigned int __cil_tmp2 ; + unsigned int __cil_tmp3 ; + unsigned int __cil_tmp4 ; + + { + { +#line 595 + __cil_tmp2 = (unsigned int )65535; +#line 595 + __cil_tmp3 = (unsigned int )err; +#line 595 + __cil_tmp4 = __cil_tmp3 & __cil_tmp2; +#line 595 + return ((gpg_err_code_t )__cil_tmp4); + } +} +} +#line 600 "/usr/include/gpg-error.h" +__inline static gpg_err_source_t gpg_err_source(gpg_error_t err ) +{ + unsigned int __cil_tmp2 ; + int __cil_tmp3 ; + gpg_error_t __cil_tmp4 ; + gpg_error_t __cil_tmp5 ; + unsigned int __cil_tmp6 ; + unsigned int __cil_tmp7 ; + + { + { +#line 603 + __cil_tmp2 = (unsigned int )127; +#line 603 + __cil_tmp3 = (int )24; +#line 603 + __cil_tmp4 = (gpg_error_t )err; +#line 603 + __cil_tmp5 = __cil_tmp4 >> __cil_tmp3; +#line 603 + __cil_tmp6 = (unsigned int )__cil_tmp5; +#line 603 + __cil_tmp7 = __cil_tmp6 & __cil_tmp2; +#line 603 + return ((gpg_err_source_t )__cil_tmp7); + } +} +} +#line 612 +extern char const *gpg_strerror(gpg_error_t err ) ; +#line 621 +extern int gpg_strerror_r(gpg_error_t err , char *buf , size_t buflen ) ; +#line 625 +extern char const *gpg_strsource(gpg_error_t err ) ; +#line 633 +extern gpg_err_code_t gpg_err_code_from_errno(int err ) ; +#line 638 +extern int gpg_err_code_to_errno(gpg_err_code_t code ) ; +#line 644 +extern gpg_err_code_t gpg_err_code_from_syserror(void) ; +#line 649 +extern void gpg_err_set_errno(int err ) ; +#line 654 "/usr/include/gpg-error.h" +__inline static gpg_error_t gpg_err_make_from_errno(gpg_err_source_t source , int err ) +{ + gpg_err_code_t tmp ; + gpg_error_t tmp___0 ; + + { +#line 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gpg_err_code_t )); +#line 49 + memset((void *)(& tmp___0), 0, sizeof(gpg_error_t )); +#line 657 "/usr/include/gpg-error.h" + tmp = gpg_err_code_from_errno(err); +#line 657 + tmp___0 = gpg_err_make(source, tmp); +#line 657 + return (tmp___0); +} +} +#line 661 "/usr/include/gpg-error.h" +__inline static gpg_error_t gpg_error_from_errno(int err ) +{ + gpg_err_code_t tmp ; + gpg_error_t tmp___0 ; + + { +#line 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gpg_err_code_t )); +#line 49 + memset((void *)(& tmp___0), 0, sizeof(gpg_error_t )); +#line 664 "/usr/include/gpg-error.h" + tmp = gpg_err_code_from_errno(err); +#line 664 + tmp___0 = gpg_error(tmp); +#line 664 + return (tmp___0); +} +} +#line 667 "/usr/include/gpg-error.h" +__inline static gpg_error_t gpg_error_from_syserror(void) +{ + gpg_err_code_t tmp ; + gpg_error_t tmp___0 ; + + { +#line 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gpg_err_code_t )); +#line 49 + memset((void *)(& tmp___0), 0, sizeof(gpg_error_t )); +#line 670 "/usr/include/gpg-error.h" + tmp = gpg_err_code_from_syserror(); +#line 670 + tmp___0 = gpg_error(tmp); +#line 670 + return (tmp___0); +} +} +#line 58 "/usr/include/x86_64-linux-gnu/bits/uio.h" +extern __attribute__((__nothrow__)) ssize_t ( __attribute__((__leaf__)) process_vm_readv)(pid_t __pid , + struct iovec const *__lvec , + unsigned long __liovcnt , + struct iovec const *__rvec , + unsigned long __riovcnt , + unsigned long __flags ) ; +#line 66 +extern __attribute__((__nothrow__)) ssize_t ( __attribute__((__leaf__)) process_vm_writev)(pid_t __pid , + struct iovec const *__lvec , + unsigned long __liovcnt , + struct iovec const *__rvec , + unsigned long __riovcnt , + unsigned long __flags ) ; +#line 40 "/usr/include/x86_64-linux-gnu/sys/uio.h" +extern ssize_t readv(int __fd , struct iovec const *__iovec , int __count ) ; +#line 51 +extern ssize_t writev(int __fd , struct iovec const *__iovec , int __count ) ; +#line 66 +extern ssize_t preadv(int __fd , struct iovec const *__iovec , int __count , __off_t __offset ) ; +#line 78 +extern ssize_t pwritev(int __fd , struct iovec const *__iovec , int __count , __off_t __offset ) ; +#line 310 "/usr/include/x86_64-linux-gnu/bits/socket.h" +extern __attribute__((__nothrow__)) struct cmsghdr *( __attribute__((__leaf__)) __cmsg_nxthdr)(struct msghdr *__mhdr , + struct cmsghdr *__cmsg ) ; +#line 431 +extern int recvmmsg(int __fd , struct mmsghdr *__vmessages , unsigned int __vlen , + int __flags , struct timespec const *__tmo ) ; +#line 439 +extern int sendmmsg(int __fd , struct mmsghdr *__vmessages , unsigned int __vlen , + int __flags ) ; +#line 105 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) socket)(int __domain , + int __type , + int __protocol ) ; +#line 111 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) socketpair)(int __domain , + int __type , + int __protocol , + int *__fds ) ; +#line 115 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) bind)(int __fd , + struct sockaddr const *__addr , + socklen_t __len ) ; +#line 119 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) getsockname)(int __fd , + struct sockaddr * __restrict __addr , + socklen_t * __restrict __len ) ; +#line 129 +extern int connect(int __fd , struct sockaddr const *__addr , socklen_t __len ) ; +#line 133 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) getpeername)(int __fd , + struct sockaddr * __restrict __addr , + socklen_t * __restrict __len ) ; +#line 141 +extern ssize_t send(int __fd , void const *__buf , size_t __n , int __flags ) ; +#line 148 +extern ssize_t recv(int __fd , void *__buf , size_t __n , int __flags ) ; +#line 155 +extern ssize_t sendto(int __fd , void const *__buf , size_t __n , int __flags , + struct sockaddr const *__addr , socklen_t __addr_len ) ; +#line 166 +extern ssize_t recvfrom(int __fd , void * __restrict __buf , size_t __n , int __flags , + struct sockaddr * __restrict __addr , socklen_t * __restrict __addr_len ) ; +#line 176 +extern ssize_t sendmsg(int __fd , struct msghdr const *__message , int __flags ) ; +#line 184 +extern ssize_t recvmsg(int __fd , struct msghdr *__message , int __flags ) ; +#line 190 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) getsockopt)(int __fd , + int __level , + int __optname , + void * __restrict __optval , + socklen_t * __restrict __optlen ) ; +#line 197 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) setsockopt)(int __fd , + int __level , + int __optname , + void const *__optval , + socklen_t __optlen ) ; +#line 204 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) listen)(int __fd , + int __n ) ; +#line 214 +extern int accept(int __fd , struct sockaddr * __restrict __addr , socklen_t * __restrict __addr_len ) ; +#line 232 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) shutdown)(int __fd , + int __how ) ; +#line 237 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) sockatmark)(int __fd ) ; +#line 245 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) isfdtype)(int __fd , + int __fdtype ) ; +#line 73 "/usr/include/x86_64-linux-gnu/sys/time.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) gettimeofday)(struct timeval * __restrict __tv , + __timezone_ptr_t __tz ) ; +#line 79 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) settimeofday)(struct timeval const *__tv , + struct timezone const *__tz ) ; +#line 87 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) adjtime)(struct timeval const *__delta , + struct timeval *__olddelta ) ; +#line 127 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) getitimer)(__itimer_which_t __which , + struct itimerval *__value ) ; +#line 133 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) setitimer)(__itimer_which_t __which , + struct itimerval const * __restrict __new , + struct itimerval * __restrict __old ) ; +#line 140 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) utimes)(char const *__file , + struct timeval const *__tvp ) ; +#line 145 +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) lutimes)(char const *__file , + struct timeval const *__tvp ) ; +#line 149 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) futimes)(int __fd , + struct timeval const *__tvp ) ; +#line 121 "/usr/include/gcrypt.h" +__inline static gcry_error_t gcry_err_make(gcry_err_source_t source , gcry_err_code_t code ) +{ + gpg_error_t tmp ; + + { +#line 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gpg_error_t )); +#line 124 "/usr/include/gcrypt.h" + tmp = gpg_err_make(source, code); +#line 124 + return (tmp); +} +} +#line 133 "/usr/include/gcrypt.h" +__inline static gcry_error_t gcry_error(gcry_err_code_t code ) +{ + gcry_error_t tmp ; + gcry_err_source_t __cil_tmp3 ; + + { +#line 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gcry_error_t )); +#line 136 "/usr/include/gcrypt.h" + __cil_tmp3 = (gcry_err_source_t )32; +#line 136 + tmp = gcry_err_make(__cil_tmp3, code); +#line 136 + return (tmp); +} +} +#line 139 "/usr/include/gcrypt.h" +__inline static gcry_err_code_t gcry_err_code(gcry_error_t err ) +{ + gpg_err_code_t tmp ; + + { +#line 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gpg_err_code_t )); +#line 142 "/usr/include/gcrypt.h" + tmp = gpg_err_code(err); +#line 142 + return (tmp); +} +} +#line 146 "/usr/include/gcrypt.h" +__inline static gcry_err_source_t gcry_err_source(gcry_error_t err ) +{ + gpg_err_source_t tmp ; + + { +#line 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gpg_err_source_t )); +#line 149 "/usr/include/gcrypt.h" + tmp = gpg_err_source(err); +#line 149 + return (tmp); +} +} +#line 154 +extern char const *gcry_strerror(gcry_error_t err ) ; +#line 158 +extern char const *gcry_strsource(gcry_error_t err ) ; +#line 163 +extern gcry_err_code_t gcry_err_code_from_errno(int err ) ; +#line 167 +extern int gcry_err_code_to_errno(gcry_err_code_t code ) ; +#line 171 +extern gcry_error_t gcry_err_make_from_errno(gcry_err_source_t source , int err ) ; +#line 174 +extern gcry_err_code_t gcry_error_from_errno(int err ) ; +#line 354 +extern char const *gcry_check_version(char const *req_version ) ; +#line 422 +extern gcry_error_t gcry_control(enum gcry_ctl_cmds CMD , ...) ; +#line 449 +extern gcry_error_t gcry_sexp_new(gcry_sexp_t *retsexp , void const *buffer , size_t length , + int autodetect ) ; +#line 455 +extern gcry_error_t gcry_sexp_create(gcry_sexp_t *retsexp , void *buffer , size_t length , + int autodetect , void (*freefnc)(void * ) ) ; +#line 461 +extern gcry_error_t gcry_sexp_sscan(gcry_sexp_t *retsexp , size_t *erroff , char const *buffer , + size_t length ) ; +#line 466 +extern gcry_error_t gcry_sexp_build(gcry_sexp_t *retsexp , size_t *erroff , char const *format + , ...) ; +#line 471 +extern gcry_error_t gcry_sexp_build_array(gcry_sexp_t *retsexp , size_t *erroff , + char const *format , void **arg_list ) ; +#line 475 +extern void gcry_sexp_release(gcry_sexp_t sexp ) ; +#line 479 +extern size_t gcry_sexp_canon_len(unsigned char const *buffer , size_t length , + size_t *erroff , gcry_error_t *errcode ) ; +#line 484 +extern size_t gcry_sexp_sprint(gcry_sexp_t sexp , int mode , void *buffer , size_t maxlength ) ; +#line 489 +extern void gcry_sexp_dump(gcry_sexp_t const a ) ; +#line 491 +extern gcry_sexp_t gcry_sexp_cons(gcry_sexp_t const a , gcry_sexp_t const b ) ; +#line 492 +extern gcry_sexp_t gcry_sexp_alist(gcry_sexp_t const *array ) ; +#line 493 +extern gcry_sexp_t gcry_sexp_vlist(gcry_sexp_t const a , ...) ; +#line 494 +extern gcry_sexp_t gcry_sexp_append(gcry_sexp_t const a , gcry_sexp_t const n ) ; +#line 495 +extern gcry_sexp_t gcry_sexp_prepend(gcry_sexp_t const a , gcry_sexp_t const n ) ; +#line 502 +extern gcry_sexp_t gcry_sexp_find_token(gcry_sexp_t list , char const *tok , size_t toklen ) ; +#line 506 +extern int gcry_sexp_length(gcry_sexp_t const list ) ; +#line 511 +extern gcry_sexp_t gcry_sexp_nth(gcry_sexp_t const list , int number ) ; +#line 516 +extern gcry_sexp_t gcry_sexp_car(gcry_sexp_t const list ) ; +#line 523 +extern gcry_sexp_t gcry_sexp_cdr(gcry_sexp_t const list ) ; +#line 525 +extern gcry_sexp_t gcry_sexp_cadr(gcry_sexp_t const list ) ; +#line 534 +extern char const *gcry_sexp_nth_data(gcry_sexp_t const list , int number , size_t *datalen ) ; +#line 542 +extern char *gcry_sexp_nth_string(gcry_sexp_t list , int number ) ; +#line 550 +extern gcry_mpi_t gcry_sexp_nth_mpi(gcry_sexp_t list , int number , int mpifmt ) ; +#line 583 +extern gcry_mpi_t gcry_mpi_new(unsigned int nbits ) ; +#line 586 +extern gcry_mpi_t gcry_mpi_snew(unsigned int nbits ) ; +#line 589 +extern void gcry_mpi_release(gcry_mpi_t a ) ; +#line 592 +extern gcry_mpi_t gcry_mpi_copy(gcry_mpi_t const a ) ; +#line 595 +extern gcry_mpi_t gcry_mpi_set(gcry_mpi_t w , gcry_mpi_t const u ) ; +#line 598 +extern gcry_mpi_t gcry_mpi_set_ui(gcry_mpi_t w , unsigned long u ) ; +#line 601 +extern void gcry_mpi_swap(gcry_mpi_t a , gcry_mpi_t b ) ; +#line 605 +extern int gcry_mpi_cmp(gcry_mpi_t const u , gcry_mpi_t const v ) ; +#line 610 +extern int gcry_mpi_cmp_ui(gcry_mpi_t const u , unsigned long v ) ; +#line 616 +extern gcry_error_t gcry_mpi_scan(gcry_mpi_t *ret_mpi , enum gcry_mpi_format format , + void const *buffer , size_t buflen , size_t *nscanned ) ; +#line 625 +extern gcry_error_t gcry_mpi_print(enum gcry_mpi_format format , unsigned char *buffer , + size_t buflen , size_t *nwritten , gcry_mpi_t const a ) ; +#line 634 +extern gcry_error_t gcry_mpi_aprint(enum gcry_mpi_format format , unsigned char **buffer , + size_t *nwritten , gcry_mpi_t const a ) ; +#line 642 +extern void gcry_mpi_dump(gcry_mpi_t const a ) ; +#line 646 +extern void gcry_mpi_add(gcry_mpi_t w , gcry_mpi_t u , gcry_mpi_t v ) ; +#line 649 +extern void gcry_mpi_add_ui(gcry_mpi_t w , gcry_mpi_t u , unsigned long v ) ; +#line 652 +extern void gcry_mpi_addm(gcry_mpi_t w , gcry_mpi_t u , gcry_mpi_t v , gcry_mpi_t m ) ; +#line 655 +extern void gcry_mpi_sub(gcry_mpi_t w , gcry_mpi_t u , gcry_mpi_t v ) ; +#line 658 +extern void gcry_mpi_sub_ui(gcry_mpi_t w , gcry_mpi_t u , unsigned long v ) ; +#line 661 +extern void gcry_mpi_subm(gcry_mpi_t w , gcry_mpi_t u , gcry_mpi_t v , gcry_mpi_t m ) ; +#line 664 +extern void gcry_mpi_mul(gcry_mpi_t w , gcry_mpi_t u , gcry_mpi_t v ) ; +#line 667 +extern void gcry_mpi_mul_ui(gcry_mpi_t w , gcry_mpi_t u , unsigned long v ) ; +#line 670 +extern void gcry_mpi_mulm(gcry_mpi_t w , gcry_mpi_t u , gcry_mpi_t v , gcry_mpi_t m ) ; +#line 673 +extern void gcry_mpi_mul_2exp(gcry_mpi_t w , gcry_mpi_t u , unsigned long cnt ) ; +#line 677 +extern void gcry_mpi_div(gcry_mpi_t q , gcry_mpi_t r , gcry_mpi_t dividend , gcry_mpi_t divisor , + int round ) ; +#line 681 +extern void gcry_mpi_mod(gcry_mpi_t r , gcry_mpi_t dividend , gcry_mpi_t divisor ) ; +#line 684 +extern void gcry_mpi_powm(gcry_mpi_t w , gcry_mpi_t const b , gcry_mpi_t const e , + gcry_mpi_t const m ) ; +#line 690 +extern int gcry_mpi_gcd(gcry_mpi_t g , gcry_mpi_t a , gcry_mpi_t b ) ; +#line 694 +extern int gcry_mpi_invm(gcry_mpi_t x , gcry_mpi_t a , gcry_mpi_t m ) ; +#line 698 +extern unsigned int gcry_mpi_get_nbits(gcry_mpi_t a ) ; +#line 701 +extern int gcry_mpi_test_bit(gcry_mpi_t a , unsigned int n ) ; +#line 704 +extern void gcry_mpi_set_bit(gcry_mpi_t a , unsigned int n ) ; +#line 707 +extern void gcry_mpi_clear_bit(gcry_mpi_t a , unsigned int n ) ; +#line 710 +extern void gcry_mpi_set_highbit(gcry_mpi_t a , unsigned int n ) ; +#line 713 +extern void gcry_mpi_clear_highbit(gcry_mpi_t a , unsigned int n ) ; +#line 716 +extern void gcry_mpi_rshift(gcry_mpi_t x , gcry_mpi_t a , unsigned int n ) ; +#line 719 +extern void gcry_mpi_lshift(gcry_mpi_t x , gcry_mpi_t a , unsigned int n ) ; +#line 724 +extern gcry_mpi_t gcry_mpi_set_opaque(gcry_mpi_t a , void *p , unsigned int nbits ) ; +#line 729 +extern void *gcry_mpi_get_opaque(gcry_mpi_t a , unsigned int *nbits ) ; +#line 734 +extern void gcry_mpi_set_flag(gcry_mpi_t a , enum gcry_mpi_flag flag ) ; +#line 738 +extern void gcry_mpi_clear_flag(gcry_mpi_t a , enum gcry_mpi_flag flag ) ; +#line 741 +extern int gcry_mpi_get_flag(gcry_mpi_t a , enum gcry_mpi_flag flag ) ; +#line 873 +extern gcry_error_t gcry_cipher_open(gcry_cipher_hd_t *handle , int algo , int mode , + unsigned int flags ) ; +#line 877 +extern void gcry_cipher_close(gcry_cipher_hd_t h ) ; +#line 880 +extern gcry_error_t gcry_cipher_ctl(gcry_cipher_hd_t h , int cmd , void *buffer , + size_t buflen ) ; +#line 884 +extern gcry_error_t gcry_cipher_info(gcry_cipher_hd_t h , int what , void *buffer , + size_t *nbytes ) ; +#line 888 +extern gcry_error_t gcry_cipher_algo_info(int algo , int what , void *buffer , size_t *nbytes ) ; +#line 894 +extern char const *gcry_cipher_algo_name(int algorithm ) __attribute__((__pure__)) ; +#line 898 +extern int gcry_cipher_map_name(char const *name ) __attribute__((__pure__)) ; +#line 903 +extern int gcry_cipher_mode_from_oid(char const *string ) __attribute__((__pure__)) ; +#line 909 +extern gcry_error_t gcry_cipher_encrypt(gcry_cipher_hd_t h , void *out , size_t outsize , + void const *in , size_t inlen ) ; +#line 914 +extern gcry_error_t gcry_cipher_decrypt(gcry_cipher_hd_t h , void *out , size_t outsize , + void const *in , size_t inlen ) ; +#line 919 +extern gcry_error_t gcry_cipher_setkey(gcry_cipher_hd_t hd , void const *key , size_t keylen ) ; +#line 924 +extern gcry_error_t gcry_cipher_setiv(gcry_cipher_hd_t hd , void const *iv , size_t ivlen ) ; +#line 941 +extern gpg_error_t gcry_cipher_setctr(gcry_cipher_hd_t hd , void const *ctr , size_t ctrlen ) ; +#line 945 +extern size_t gcry_cipher_get_algo_keylen(int algo ) ; +#line 948 +extern size_t gcry_cipher_get_algo_blklen(int algo ) ; +#line 960 +extern gcry_error_t gcry_cipher_list(int *list , int *list_length ) ; +#line 991 +extern gcry_error_t gcry_pk_encrypt(gcry_sexp_t *result , gcry_sexp_t data , gcry_sexp_t pkey ) ; +#line 996 +extern gcry_error_t gcry_pk_decrypt(gcry_sexp_t *result , gcry_sexp_t data , gcry_sexp_t skey ) ; +#line 1001 +extern gcry_error_t gcry_pk_sign(gcry_sexp_t *result , gcry_sexp_t data , gcry_sexp_t skey ) ; +#line 1005 +extern gcry_error_t gcry_pk_verify(gcry_sexp_t sigval , gcry_sexp_t data , gcry_sexp_t pkey ) ; +#line 1009 +extern gcry_error_t gcry_pk_testkey(gcry_sexp_t key ) ; +#line 1014 +extern gcry_error_t gcry_pk_genkey(gcry_sexp_t *r_key , gcry_sexp_t s_parms ) ; +#line 1017 +extern gcry_error_t gcry_pk_ctl(int cmd , void *buffer , size_t buflen ) ; +#line 1020 +extern gcry_error_t gcry_pk_algo_info(int algo , int what , void *buffer , size_t *nbytes ) ; +#line 1026 +extern char const *gcry_pk_algo_name(int algorithm ) __attribute__((__pure__)) ; +#line 1030 +extern int gcry_pk_map_name(char const *name ) __attribute__((__pure__)) ; +#line 1034 +extern unsigned int gcry_pk_get_nbits(gcry_sexp_t key ) __attribute__((__pure__)) ; +#line 1038 +extern unsigned char *gcry_pk_get_keygrip(gcry_sexp_t key , unsigned char *array ) ; +#line 1041 +extern char const *gcry_pk_get_curve(gcry_sexp_t key , int iterator , unsigned int *r_nbits ) ; +#line 1046 +extern gcry_sexp_t gcry_pk_get_param(int algo , char const *name ) ; +#line 1058 +extern gcry_error_t gcry_pk_list(int *list , int *list_length ) ; +#line 1126 +extern gcry_error_t gcry_md_open(gcry_md_hd_t *h , int algo , unsigned int flags ) ; +#line 1129 +extern void gcry_md_close(gcry_md_hd_t hd ) ; +#line 1132 +extern gcry_error_t gcry_md_enable(gcry_md_hd_t hd , int algo ) ; +#line 1135 +extern gcry_error_t gcry_md_copy(gcry_md_hd_t *bhd , gcry_md_hd_t ahd ) ; +#line 1138 +extern void gcry_md_reset(gcry_md_hd_t hd ) ; +#line 1141 +extern gcry_error_t gcry_md_ctl(gcry_md_hd_t hd , int cmd , void *buffer , size_t buflen ) ; +#line 1147 +extern void gcry_md_write(gcry_md_hd_t hd , void const *buffer , size_t length ) ; +#line 1151 +extern unsigned char *gcry_md_read(gcry_md_hd_t hd , int algo ) ; +#line 1158 +extern void gcry_md_hash_buffer(int algo , void *digest , void const *buffer , size_t length ) ; +#line 1163 +extern int gcry_md_get_algo(gcry_md_hd_t hd ) ; +#line 1167 +extern unsigned int gcry_md_get_algo_dlen(int algo ) ; +#line 1171 +extern int gcry_md_is_enabled(gcry_md_hd_t a , int algo ) ; +#line 1174 +extern int gcry_md_is_secure(gcry_md_hd_t a ) ; +#line 1177 +extern gcry_error_t gcry_md_info(gcry_md_hd_t h , int what , void *buffer , size_t *nbytes ) ; +#line 1181 +extern gcry_error_t gcry_md_algo_info(int algo , int what , void *buffer , size_t *nbytes ) ; +#line 1187 +extern char const *gcry_md_algo_name(int algo ) __attribute__((__pure__)) ; +#line 1191 +extern int gcry_md_map_name(char const *name ) __attribute__((__pure__)) ; +#line 1195 +extern gcry_error_t gcry_md_setkey(gcry_md_hd_t hd , void const *key , size_t keylen ) ; +#line 1200 +extern void gcry_md_debug(gcry_md_hd_t hd , char const *suffix ) ; +#line 1249 +extern gcry_error_t gcry_md_list(int *list , int *list_length ) ; +#line 1407 +extern gcry_error_t gcry_ac_data_new(gcry_ac_data_t *data ) __attribute__((__deprecated__)) ; +#line 1411 +extern void gcry_ac_data_destroy(gcry_ac_data_t data ) __attribute__((__deprecated__)) ; +#line 1415 +extern gcry_error_t gcry_ac_data_copy(gcry_ac_data_t *data_cp , gcry_ac_data_t data ) __attribute__((__deprecated__)) ; +#line 1421 +extern unsigned int gcry_ac_data_length(gcry_ac_data_t data ) __attribute__((__deprecated__)) ; +#line 1425 +extern void gcry_ac_data_clear(gcry_ac_data_t data ) __attribute__((__deprecated__)) ; +#line 1433 +extern gcry_error_t gcry_ac_data_set(gcry_ac_data_t data , unsigned int flags , char const *name , + gcry_mpi_t mpi ) __attribute__((__deprecated__)) ; +#line 1440 +extern gcry_error_t gcry_ac_data_get_name(gcry_ac_data_t data , unsigned int flags , + char const *name , gcry_mpi_t *mpi ) __attribute__((__deprecated__)) ; +#line 1448 +extern gcry_error_t gcry_ac_data_get_index(gcry_ac_data_t data , unsigned int flags , + unsigned int idx , char const **name , + gcry_mpi_t *mpi ) __attribute__((__deprecated__)) ; +#line 1456 +extern gcry_error_t gcry_ac_data_to_sexp(gcry_ac_data_t data , gcry_sexp_t *sexp , + char const **identifiers ) __attribute__((__deprecated__)) ; +#line 1463 +extern gcry_error_t gcry_ac_data_from_sexp(gcry_ac_data_t *data , gcry_sexp_t sexp , + char const **identifiers ) __attribute__((__deprecated__)) ; +#line 1470 +extern void gcry_ac_io_init(gcry_ac_io_t *ac_io , gcry_ac_io_mode_t mode , gcry_ac_io_type_t type + , ...) __attribute__((__deprecated__)) ; +#line 1477 +extern void gcry_ac_io_init_va(gcry_ac_io_t *ac_io , gcry_ac_io_mode_t mode , gcry_ac_io_type_t type , + va_list ap ) __attribute__((__deprecated__)) ; +#line 1482 +extern gcry_error_t gcry_ac_open(gcry_ac_handle_t *handle , gcry_ac_id_t algorithm , + unsigned int flags ) __attribute__((__deprecated__)) ; +#line 1487 +extern void gcry_ac_close(gcry_ac_handle_t handle ) __attribute__((__deprecated__)) ; +#line 1491 +extern gcry_error_t gcry_ac_key_init(gcry_ac_key_t *key , gcry_ac_handle_t handle , + gcry_ac_key_type_t type , gcry_ac_data_t data ) __attribute__((__deprecated__)) ; +#line 1500 +extern gcry_error_t gcry_ac_key_pair_generate(gcry_ac_handle_t handle , unsigned int nbits , + void *spec , gcry_ac_key_pair_t *key_pair , + gcry_mpi_t **misc_data ) __attribute__((__deprecated__)) ; +#line 1507 +extern gcry_ac_key_t gcry_ac_key_pair_extract(gcry_ac_key_pair_t key_pair , gcry_ac_key_type_t which ) __attribute__((__deprecated__)) ; +#line 1512 +extern gcry_ac_data_t gcry_ac_key_data_get(gcry_ac_key_t key ) __attribute__((__deprecated__)) ; +#line 1516 +extern gcry_error_t gcry_ac_key_test(gcry_ac_handle_t handle , gcry_ac_key_t key ) __attribute__((__deprecated__)) ; +#line 1520 +extern gcry_error_t gcry_ac_key_get_nbits(gcry_ac_handle_t handle , gcry_ac_key_t key , + unsigned int *nbits ) __attribute__((__deprecated__)) ; +#line 1526 +extern gcry_error_t gcry_ac_key_get_grip(gcry_ac_handle_t handle , gcry_ac_key_t key , + unsigned char *key_grip ) __attribute__((__deprecated__)) ; +#line 1531 +extern void gcry_ac_key_destroy(gcry_ac_key_t key ) __attribute__((__deprecated__)) ; +#line 1535 +extern void gcry_ac_key_pair_destroy(gcry_ac_key_pair_t key_pair ) __attribute__((__deprecated__)) ; +#line 1541 +extern gcry_error_t gcry_ac_data_encode(gcry_ac_em_t method , unsigned int flags , + void *options , gcry_ac_io_t *io_read , gcry_ac_io_t *io_write ) __attribute__((__deprecated__)) ; +#line 1550 +extern gcry_error_t gcry_ac_data_decode(gcry_ac_em_t method , unsigned int flags , + void *options , gcry_ac_io_t *io_read , gcry_ac_io_t *io_write ) __attribute__((__deprecated__)) ; +#line 1559 +extern gcry_error_t gcry_ac_data_encrypt(gcry_ac_handle_t handle , unsigned int flags , + gcry_ac_key_t key , gcry_mpi_t data_plain , + gcry_ac_data_t *data_encrypted ) __attribute__((__deprecated__)) ; +#line 1569 +extern gcry_error_t gcry_ac_data_decrypt(gcry_ac_handle_t handle , unsigned int flags , + gcry_ac_key_t key , gcry_mpi_t *data_plain , + gcry_ac_data_t data_encrypted ) __attribute__((__deprecated__)) ; +#line 1578 +extern gcry_error_t gcry_ac_data_sign(gcry_ac_handle_t handle , gcry_ac_key_t key , + gcry_mpi_t data , gcry_ac_data_t *data_signature ) __attribute__((__deprecated__)) ; +#line 1587 +extern gcry_error_t gcry_ac_data_verify(gcry_ac_handle_t handle , gcry_ac_key_t key , + gcry_mpi_t data , gcry_ac_data_t data_signature ) __attribute__((__deprecated__)) ; +#line 1598 +extern gcry_error_t gcry_ac_data_encrypt_scheme(gcry_ac_handle_t handle , gcry_ac_scheme_t scheme , + unsigned int flags , void *opts , + gcry_ac_key_t key , gcry_ac_io_t *io_message , + gcry_ac_io_t *io_cipher ) __attribute__((__deprecated__)) ; +#line 1611 +extern gcry_error_t gcry_ac_data_decrypt_scheme(gcry_ac_handle_t handle , gcry_ac_scheme_t scheme , + unsigned int flags , void *opts , + gcry_ac_key_t key , gcry_ac_io_t *io_cipher , + gcry_ac_io_t *io_message ) __attribute__((__deprecated__)) ; +#line 1624 +extern gcry_error_t gcry_ac_data_sign_scheme(gcry_ac_handle_t handle , gcry_ac_scheme_t scheme , + unsigned int flags , void *opts , gcry_ac_key_t key , + gcry_ac_io_t *io_message , gcry_ac_io_t *io_signature ) __attribute__((__deprecated__)) ; +#line 1638 +extern gcry_error_t gcry_ac_data_verify_scheme(gcry_ac_handle_t handle , gcry_ac_scheme_t scheme , + unsigned int flags , void *opts , gcry_ac_key_t key , + gcry_ac_io_t *io_message , gcry_ac_io_t *io_signature ) __attribute__((__deprecated__)) ; +#line 1649 +extern gcry_error_t gcry_ac_id_to_name(gcry_ac_id_t algorithm , char const **name ) __attribute__((__deprecated__)) ; +#line 1655 +extern gcry_error_t gcry_ac_name_to_id(char const *name , gcry_ac_id_t *algorithm ) __attribute__((__deprecated__)) ; +#line 1679 +extern gpg_error_t gcry_kdf_derive(void const *passphrase , size_t passphraselen , + int algo , int subalgo , void const *salt , size_t saltlen , + unsigned long iterations , size_t keysize , void *keybuffer ) ; +#line 1708 +extern void gcry_randomize(void *buffer , size_t length , enum gcry_random_level level ) ; +#line 1714 +extern gcry_error_t gcry_random_add_bytes(void const *buffer , size_t length , int quality ) ; +#line 1725 +extern void *gcry_random_bytes(size_t nbytes , enum gcry_random_level level ) __attribute__((__malloc__)) ; +#line 1731 +extern void *gcry_random_bytes_secure(size_t nbytes , enum gcry_random_level level ) __attribute__((__malloc__)) ; +#line 1738 +extern void gcry_mpi_randomize(gcry_mpi_t w , unsigned int nbits , enum gcry_random_level level ) ; +#line 1743 +extern void gcry_create_nonce(void *buffer , size_t length ) ; +#line 1780 +extern gcry_error_t gcry_prime_generate(gcry_mpi_t *prime , unsigned int prime_bits , + unsigned int factor_bits , gcry_mpi_t **factors , + int (*cb_func)(void *arg , int mode , gcry_mpi_t candidate ) , + void *cb_arg , gcry_random_level_t random_level , + unsigned int flags ) ; +#line 1793 +extern gcry_error_t gcry_prime_group_generator(gcry_mpi_t *r_g , gcry_mpi_t prime , + gcry_mpi_t *factors , gcry_mpi_t start_g ) ; +#line 1800 +extern void gcry_prime_release_factors(gcry_mpi_t *factors ) ; +#line 1804 +extern gcry_error_t gcry_prime_check(gcry_mpi_t x , unsigned int flags ) ; +#line 1852 +extern void gcry_set_progress_handler(void (*cb)(void * , char const * , int , + int , int ) , void *cb_data ) ; +#line 1856 +extern void gcry_set_allocation_handler(void *(*func_alloc)(size_t n ) , void *(*func_alloc_secure)(size_t n ) , + int (*func_secure_check)(void const * ) , + void *(*func_realloc)(void *p , size_t n ) , + void (*func_free)(void * ) ) ; +#line 1865 +extern void gcry_set_outofcore_handler(int (*h)(void * , size_t , unsigned int ) , + void *opaque ) ; +#line 1869 +extern void gcry_set_fatalerror_handler(void (*fnc)(void * , int , char const * ) , + void *opaque ) ; +#line 1873 +extern void gcry_set_log_handler(void (*f)(void * , int , char const * , va_list ) , + void *opaque ) ; +#line 1876 +extern void gcry_set_gettext_handler(char const *(*f)(char const * ) ) ; +#line 1880 +extern void *gcry_malloc(size_t n ) __attribute__((__malloc__)) ; +#line 1881 +extern void *gcry_calloc(size_t n , size_t m ) __attribute__((__malloc__)) ; +#line 1882 +extern void *gcry_malloc_secure(size_t n ) __attribute__((__malloc__)) ; +#line 1883 +extern void *gcry_calloc_secure(size_t n , size_t m ) __attribute__((__malloc__)) ; +#line 1884 +extern void *gcry_realloc(void *a , size_t n ) ; +#line 1885 +extern char *gcry_strdup(char const *string ) __attribute__((__malloc__)) ; +#line 1886 +extern void *gcry_xmalloc(size_t n ) __attribute__((__malloc__)) ; +#line 1887 +extern void *gcry_xcalloc(size_t n , size_t m ) __attribute__((__malloc__)) ; +#line 1888 +extern void *gcry_xmalloc_secure(size_t n ) __attribute__((__malloc__)) ; +#line 1889 +extern void *gcry_xcalloc_secure(size_t n , size_t m ) __attribute__((__malloc__)) ; +#line 1890 +extern void *gcry_xrealloc(void *a , size_t n ) ; +#line 1891 +extern char *gcry_xstrdup(char const *a ) __attribute__((__malloc__)) ; +#line 1892 +extern void gcry_free(void *a ) ; +#line 1895 +extern int gcry_is_secure(void const *a ) __attribute__((__pure__)) ; +#line 99 "/usr/include/gcrypt-module.h" +extern gcry_error_t gcry_cipher_register(gcry_cipher_spec_t *cipher , int *algorithm_id , + gcry_module_t *module ) __attribute__((__deprecated__)) ; +#line 107 +extern void gcry_cipher_unregister(gcry_module_t module ) __attribute__((__deprecated__)) ; +#line 177 +extern gcry_error_t gcry_pk_register(gcry_pk_spec_t *pubkey , unsigned int *algorithm_id , + gcry_module_t *module ) __attribute__((__deprecated__)) ; +#line 184 +extern void gcry_pk_unregister(gcry_module_t module ) __attribute__((__deprecated__)) ; +#line 224 +extern gcry_error_t gcry_md_register(gcry_md_spec_t *digest , unsigned int *algorithm_id , + gcry_module_t *module ) __attribute__((__deprecated__)) ; +#line 231 +extern void gcry_md_unregister(gcry_module_t module ) __attribute__((__deprecated__)) ; +#line 40 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +static struct __anonstruct___obliv_c__bool_42 const __obliv_c__trueCond = {{{(_Bool )0, {(_Bool )1}}}}; +#line 44 +extern void __obliv_c__assignBitKnown(OblivBit___0 *dest , _Bool value ) ; +#line 45 +extern void __obliv_c__copyBit(OblivBit___0 *dest , OblivBit___0 const *src ) ; +#line 46 +extern _Bool __obliv_c__bitIsKnown(_Bool *val , OblivBit___0 const *bit ) ; +#line 49 +extern void __obliv_c__setBitAnd(OblivBit___0 *dest , OblivBit___0 const *a , OblivBit___0 const *b ) ; +#line 50 +extern void __obliv_c__setBitOr(OblivBit___0 *dest , OblivBit___0 const *a , OblivBit___0 const *b ) ; +#line 51 +extern void __obliv_c__setBitXor(OblivBit___0 *dest , OblivBit___0 const *a , OblivBit___0 const *b ) ; +#line 52 +extern void __obliv_c__setBitNot(OblivBit___0 *dest , OblivBit___0 const *a ) ; +#line 53 +extern void __obliv_c__flipBit(OblivBit___0 *dest ) ; +#line 58 +extern int ocCurrentParty(void) ; +#line 63 +extern void __obliv_c__setSignedKnown(void *dest , size_t size , long long value ) ; +#line 65 +extern void __obliv_c__setUnsignedKnown(void *dest , size_t size , unsigned long long value ) ; +#line 67 +extern void __obliv_c__setBitsKnown(OblivBit___0 *dest , _Bool const *value , size_t size ) ; +#line 68 +extern void __obliv_c__copyBits(OblivBit___0 *dest , OblivBit___0 const *src , size_t size ) ; +#line 70 +extern _Bool __obliv_c__allBitsKnown(OblivBit___0 const *bits , _Bool *dest , size_t size ) ; +#line 72 +extern void __obliv_c__setBitwiseAnd(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +#line 75 +extern void __obliv_c__setBitwiseOr(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +#line 78 +extern void __obliv_c__setBitwiseXor(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +#line 81 +extern void __obliv_c__setBitwiseNot(void *dest , void const *op , size_t size ) ; +#line 82 +extern void __obliv_c__setBitwiseNotInPlace(void *dest , size_t size ) ; +#line 83 +extern void __obliv_c__setLShift(void *vdest , void const *vsrc , size_t size , + unsigned int shiftAmt ) ; +#line 85 +extern void __obliv_c__setRShiftSigned(void *vdest , void const *vsrc , size_t size , + unsigned int shiftAmt ) ; +#line 87 +extern void __obliv_c__setRShiftUnsigned(void *vdest , void const *vsrc , size_t size , + unsigned int shiftAmt ) ; +#line 89 +extern void __obliv_c__setRShift(void *vdest , void const *vsrc , size_t size , + unsigned int shiftAmt , _Bool isSigned ) ; +#line 97 +extern void __obliv_c__setPlainAdd(void *vdest , void const *vop1 , void const *vop2 , + size_t size ) ; +#line 100 +extern void __obliv_c__setPlainSub(void *vdest , void const *vop1 , void const *vop2 , + size_t size ) ; +#line 103 +extern void __obliv_c__setBitsAdd(void *dest , void *carryOut , void const *op1 , + void const *op2 , void const *carryIn , size_t size ) ; +#line 107 +extern void __obliv_c__setNeg(void *vdest , void const *vsrc , size_t n ) ; +#line 108 +extern void __obliv_c__condNeg(void const *vcond , void *vdest , void const *vsrc , + size_t n ) ; +#line 112 +extern void __obliv_c__setMul(void *vdest , void const *vop1 , void const *vop2 , + size_t size ) ; +#line 115 +extern void __obliv_c__setDivModUnsigned(void *vquot , void *vrem , void const *vop1 , + void const *vop2 , size_t size ) ; +#line 118 +extern void __obliv_c__setDivModSigned(void *vquot , void *vrem , void const *vop1 , + void const *vop2 , size_t size ) ; +#line 121 +extern void __obliv_c__setDivUnsigned(void *vdest , void const *vop1 , void const *vop2 , + size_t size ) ; +#line 124 +extern void __obliv_c__setModUnsigned(void *vdest , void const *vop1 , void const *vop2 , + size_t size ) ; +#line 127 +extern void __obliv_c__setDivSigned(void *vdest , void const *vop1 , void const *vop2 , + size_t size ) ; +#line 130 +extern void __obliv_c__setModSigned(void *vdest , void const *vop1 , void const *vop2 , + size_t size ) ; +#line 134 +extern void __obliv_c__setBitsSub(void *dest , void *borrowOut , void const *op1 , + void const *op2 , void const *borrowIn , size_t size ) ; +#line 137 +extern void __obliv_c__setSignExtend(void *dest , size_t dsize , void const *src , + size_t ssize ) ; +#line 139 +extern void __obliv_c__setZeroExtend(void *dest , size_t dsize , void const *src , + size_t ssize ) ; +#line 141 +extern void __obliv_c__ifThenElse(void *dest , void const *tsrc , void const *fsrc , + size_t size , void const *cond ) ; +#line 144 +extern void __obliv_c__setLessThanUnit(OblivBit___0 *ltOut , OblivBit___0 const *op1 , + OblivBit___0 const *op2 , size_t size , OblivBit___0 const *ltIn ) ; +#line 147 +extern void __obliv_c__setLessThanUnsigned(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +#line 150 +extern void __obliv_c__setLessOrEqualUnsigned(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +#line 153 +extern void __obliv_c__setLessThanSigned(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +#line 156 +extern void __obliv_c__setLessOrEqualSigned(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +#line 159 +extern void __obliv_c__setEqualTo(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +#line 162 +extern void __obliv_c__setNotEqual(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +#line 165 +extern void __obliv_c__setLogicalNot(void *dest , void const *op , size_t size ) ; +#line 167 +extern void __obliv_c__condAssign(void const *cond , void *dest , void const *src , + size_t size ) ; +#line 170 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +__inline static void __obliv_c__condAssignKnown(void const *cond , void *dest , + size_t size , widest_t val ) +{ + OblivBit___0 ov[(unsigned long )8 * (unsigned long )sizeof(widest_t )] ; + unsigned long __cil_tmp6 ; + unsigned long __cil_tmp7 ; + OblivBit___0 *__cil_tmp8 ; + void *__cil_tmp9 ; + unsigned long __cil_tmp10 ; + unsigned long __cil_tmp11 ; + OblivBit___0 *__cil_tmp12 ; + void const *__cil_tmp13 ; + void const *__cil_tmp14 ; + + { +#line 49 "mutual.oc" + memset((void *)(& ov), 0, sizeof(OblivBit___0 [(unsigned long )8 * (unsigned long )sizeof(widest_t )])); +#line 175 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" + __cil_tmp6 = 0 * 13UL; +#line 175 + __cil_tmp7 = (unsigned long )(ov) + __cil_tmp6; +#line 175 + __cil_tmp8 = (OblivBit___0 *)__cil_tmp7; +#line 175 + __cil_tmp9 = (void *)__cil_tmp8; +#line 175 + __obliv_c__setSignedKnown(__cil_tmp9, size, val); +#line 176 + __cil_tmp10 = 0 * 13UL; +#line 176 + __cil_tmp11 = (unsigned long )(ov) + __cil_tmp10; +#line 176 + __cil_tmp12 = (OblivBit___0 *)__cil_tmp11; +#line 176 + __cil_tmp13 = (void const *)__cil_tmp12; +#line 176 + __cil_tmp14 = (void const *)dest; +#line 176 + __obliv_c__ifThenElse(dest, __cil_tmp13, __cil_tmp14, size, cond); +#line 177 + return; +} +} +#line 179 +extern void __obliv_c__condAdd(void const *c , void *dest , void const *x , size_t size ) ; +#line 182 +extern void __obliv_c__condSub(void const *c , void *dest , void const *x , size_t size ) ; +#line 348 "/usr/include/libio.h" +extern struct _IO_FILE_plus _IO_2_1_stdin_ ; +#line 349 +extern struct _IO_FILE_plus _IO_2_1_stdout_ ; +#line 350 +extern struct _IO_FILE_plus _IO_2_1_stderr_ ; +#line 418 +extern int __underflow(_IO_FILE * ) ; +#line 419 +extern int __uflow(_IO_FILE * ) ; +#line 420 +extern int __overflow(_IO_FILE * , int ) ; +#line 462 +extern int _IO_getc(_IO_FILE *__fp ) ; +#line 463 +extern int _IO_putc(int __c , _IO_FILE *__fp ) ; +#line 464 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) _IO_feof)(_IO_FILE *__fp ) ; +#line 465 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) _IO_ferror)(_IO_FILE *__fp ) ; +#line 467 +extern int _IO_peekc_locked(_IO_FILE *__fp ) ; +#line 473 +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) _IO_flockfile)(_IO_FILE * ) ; +#line 474 +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) _IO_funlockfile)(_IO_FILE * ) ; +#line 475 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) _IO_ftrylockfile)(_IO_FILE * ) ; +#line 492 +extern int _IO_vfscanf(_IO_FILE * __restrict , char const * __restrict , __gnuc_va_list , + int * __restrict ) ; +#line 494 +extern int _IO_vfprintf(_IO_FILE * __restrict , char const * __restrict , __gnuc_va_list ) ; +#line 496 +extern __ssize_t _IO_padn(_IO_FILE * , int , __ssize_t ) ; +#line 497 +extern size_t _IO_sgetn(_IO_FILE * , void * , size_t ) ; +#line 499 +extern __off64_t _IO_seekoff(_IO_FILE * , __off64_t , int , int ) ; +#line 500 +extern __off64_t _IO_seekpos(_IO_FILE * , __off64_t , int ) ; +#line 502 +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) _IO_free_backup_area)(_IO_FILE * ) ; +#line 169 "/usr/include/stdio.h" +extern struct _IO_FILE *stdin ; +#line 170 +extern struct _IO_FILE *stdout ; +#line 171 +extern struct _IO_FILE *stderr ; +#line 179 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) remove)(char const *__filename ) ; +#line 181 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) rename)(char const *__old , + char const *__new ) ; +#line 186 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) renameat)(int __oldfd , + char const *__old , + int __newfd , + char const *__new ) ; +#line 196 +extern FILE *tmpfile(void) ; +#line 210 +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) tmpnam)(char *__s ) ; +#line 216 +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) tmpnam_r)(char *__s ) ; +#line 228 +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) tempnam)(char const *__dir , + char const *__pfx ) __attribute__((__malloc__)) ; +#line 238 +extern int fclose(FILE *__stream ) ; +#line 243 +extern int fflush(FILE *__stream ) ; +#line 253 +extern int fflush_unlocked(FILE *__stream ) ; +#line 273 +extern FILE *fopen(char const * __restrict __filename , char const * __restrict __modes ) ; +#line 279 +extern FILE *freopen(char const * __restrict __filename , char const * __restrict __modes , + FILE * __restrict __stream ) ; +#line 307 +extern __attribute__((__nothrow__)) FILE *( __attribute__((__leaf__)) fdopen)(int __fd , + char const *__modes ) ; +#line 320 +extern __attribute__((__nothrow__)) FILE *( __attribute__((__leaf__)) fmemopen)(void *__s , + size_t __len , + char const *__modes ) ; +#line 326 +extern __attribute__((__nothrow__)) FILE *( __attribute__((__leaf__)) open_memstream)(char **__bufloc , + size_t *__sizeloc ) ; +#line 333 +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) setbuf)(FILE * __restrict __stream , + char * __restrict __buf ) ; +#line 337 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) setvbuf)(FILE * __restrict __stream , + char * __restrict __buf , + int __modes , + size_t __n ) ; +#line 344 +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) setbuffer)(FILE * __restrict __stream , + char * __restrict __buf , + size_t __size ) ; +#line 348 +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) setlinebuf)(FILE *__stream ) ; +#line 357 +extern int fprintf(FILE * __restrict __stream , char const * __restrict __format + , ...) ; +#line 363 +extern int printf(char const * __restrict __format , ...) ; +#line 365 +extern __attribute__((__nothrow__)) int sprintf(char * __restrict __s , char const * __restrict __format + , ...) ; +#line 372 +extern int vfprintf(FILE * __restrict __s , char const * __restrict __format , + __gnuc_va_list __arg ) ; +#line 378 +extern int vprintf(char const * __restrict __format , __gnuc_va_list __arg ) ; +#line 380 +extern __attribute__((__nothrow__)) int vsprintf(char * __restrict __s , char const * __restrict __format , + __gnuc_va_list __arg ) ; +#line 387 +extern __attribute__((__nothrow__)) int ( /* format attribute */ snprintf)(char * __restrict __s , + size_t __maxlen , + char const * __restrict __format + , ...) ; +#line 391 +extern __attribute__((__nothrow__)) int ( /* format attribute */ vsnprintf)(char * __restrict __s , + size_t __maxlen , + char const * __restrict __format , + __gnuc_va_list __arg ) ; +#line 418 +extern int ( /* format attribute */ vdprintf)(int __fd , char const * __restrict __fmt , + __gnuc_va_list __arg ) ; +#line 421 +extern int ( /* format attribute */ dprintf)(int __fd , char const * __restrict __fmt + , ...) ; +#line 431 +extern int fscanf(FILE * __restrict __stream , char const * __restrict __format + , ...) __asm__("__isoc99_fscanf") ; +#line 437 +extern int scanf(char const * __restrict __format , ...) __asm__("__isoc99_scanf") ; +#line 439 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) sscanf)(char const * __restrict __s , + char const * __restrict __format + , ...) __asm__("__isoc99_sscanf") ; +#line 477 +extern int ( /* format attribute */ vfscanf)(FILE * __restrict __s , char const * __restrict __format , + __gnuc_va_list __arg ) __asm__("__isoc99_vfscanf") ; +#line 485 +extern int ( /* format attribute */ vscanf)(char const * __restrict __format , + __gnuc_va_list __arg ) __asm__("__isoc99_vscanf") ; +#line 489 +extern __attribute__((__nothrow__)) int ( /* format attribute */ __attribute__((__leaf__)) vsscanf)(char const * __restrict __s , + char const * __restrict __format , + __gnuc_va_list __arg ) __asm__("__isoc99_vsscanf") ; +#line 537 +extern int fgetc(FILE *__stream ) ; +#line 538 +extern int getc(FILE *__stream ) ; +#line 544 +extern int getchar(void) ; +#line 556 +extern int getc_unlocked(FILE *__stream ) ; +#line 557 +extern int getchar_unlocked(void) ; +#line 567 +extern int fgetc_unlocked(FILE *__stream ) ; +#line 579 +extern int fputc(int __c , FILE *__stream ) ; +#line 580 +extern int putc(int __c , FILE *__stream ) ; +#line 586 +extern int putchar(int __c ) ; +#line 600 +extern int fputc_unlocked(int __c , FILE *__stream ) ; +#line 608 +extern int putc_unlocked(int __c , FILE *__stream ) ; +#line 609 +extern int putchar_unlocked(int __c ) ; +#line 616 +extern int getw(FILE *__stream ) ; +#line 619 +extern int putw(int __w , FILE *__stream ) ; +#line 628 +extern char *fgets(char * __restrict __s , int __n , FILE * __restrict __stream ) ; +#line 636 +extern char *gets(char *__s ) ; +#line 662 +extern __ssize_t __getdelim(char ** __restrict __lineptr , size_t * __restrict __n , + int __delimiter , FILE * __restrict __stream ) ; +#line 665 +extern __ssize_t getdelim(char ** __restrict __lineptr , size_t * __restrict __n , + int __delimiter , FILE * __restrict __stream ) ; +#line 675 +extern __ssize_t getline(char ** __restrict __lineptr , size_t * __restrict __n , + FILE * __restrict __stream ) ; +#line 686 +extern int fputs(char const * __restrict __s , FILE * __restrict __stream ) ; +#line 692 +extern int puts(char const *__s ) ; +#line 699 +extern int ungetc(int __c , FILE *__stream ) ; +#line 706 +extern size_t fread(void * __restrict __ptr , size_t __size , size_t __n , FILE * __restrict __stream ) ; +#line 712 +extern size_t fwrite(void const * __restrict __ptr , size_t __size , size_t __n , + FILE * __restrict __s ) ; +#line 734 +extern size_t fread_unlocked(void * __restrict __ptr , size_t __size , size_t __n , + FILE * __restrict __stream ) ; +#line 736 +extern size_t fwrite_unlocked(void const * __restrict __ptr , size_t __size , size_t __n , + FILE * __restrict __stream ) ; +#line 746 +extern int fseek(FILE *__stream , long __off , int __whence ) ; +#line 751 +extern long ftell(FILE *__stream ) ; +#line 756 +extern void rewind(FILE *__stream ) ; +#line 770 +extern int fseeko(FILE *__stream , __off_t __off , int __whence ) ; +#line 775 +extern __off_t ftello(FILE *__stream ) ; +#line 795 +extern int fgetpos(FILE * __restrict __stream , fpos_t * __restrict __pos ) ; +#line 800 +extern int fsetpos(FILE *__stream , fpos_t const *__pos ) ; +#line 823 +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) clearerr)(FILE *__stream ) ; +#line 825 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) feof)(FILE *__stream ) ; +#line 827 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) ferror)(FILE *__stream ) ; +#line 832 +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) clearerr_unlocked)(FILE *__stream ) ; +#line 833 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) feof_unlocked)(FILE *__stream ) ; +#line 834 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) ferror_unlocked)(FILE *__stream ) ; +#line 843 +extern void perror(char const *__s ) ; +#line 27 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" +extern int sys_nerr ; +#line 28 +extern char const * const sys_errlist[] ; +#line 855 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) fileno)(FILE *__stream ) ; +#line 860 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) fileno_unlocked)(FILE *__stream ) ; +#line 870 +extern FILE *popen(char const *__command , char const *__modes ) ; +#line 876 +extern int pclose(FILE *__stream ) ; +#line 882 +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) ctermid)(char *__s ) ; +#line 910 +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) flockfile)(FILE *__stream ) ; +#line 914 +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) ftrylockfile)(FILE *__stream ) ; +#line 917 +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) funlockfile)(FILE *__stream ) ; +#line 4 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern struct ProtocolDesc *ocCurrentProto(void) ; +#line 7 +extern void setupOblivBool(OblivInputs *spec , __obliv_c__bool *dest , _Bool v ) ; +#line 8 +extern void setupOblivChar(OblivInputs *spec , __obliv_c__char *dest , char v ) ; +#line 9 +extern void setupOblivInt(OblivInputs *spec , __obliv_c__int *dest , int v ) ; +#line 10 +extern void setupOblivShort(OblivInputs *spec , __obliv_c__short *dest , short v ) ; +#line 11 +extern void setupOblivLong(OblivInputs *spec , __obliv_c__long *dest , long v ) ; +#line 12 +extern void setupOblivLLong(OblivInputs *spec , __obliv_c__lLong *dest , long long v ) ; +#line 14 +extern void feedOblivInputs(OblivInputs *spec , size_t count , int party ) ; +#line 17 +extern __obliv_c__bool feedOblivBool(_Bool v , int party ) ; +#line 18 +extern __obliv_c__char feedOblivChar(char v , int party ) ; +#line 19 +extern __obliv_c__short feedOblivShort(short v , int party ) ; +#line 20 +extern __obliv_c__int feedOblivInt(int v , int party ) ; +#line 21 +extern __obliv_c__long feedOblivLong(long v , int party ) ; +#line 22 +extern __obliv_c__lLong feedOblivLLong(long long v , int party ) ; +#line 27 +extern _Bool revealOblivBool(_Bool *dest , __obliv_c__bool src , int party ) ; +#line 28 +extern _Bool revealOblivChar(char *dest , __obliv_c__char src , int party ) ; +#line 29 +extern _Bool revealOblivInt(int *dest , __obliv_c__int src , int party ) ; +#line 30 +extern _Bool revealOblivShort(short *dest , __obliv_c__short src , int party ) ; +#line 31 +extern _Bool revealOblivLong(long *dest , __obliv_c__long src , int party ) ; +#line 32 +extern _Bool revealOblivLLong(long long *dest , __obliv_c__lLong src , int party ) ; +#line 34 +extern _Bool ocBroadcastBool(int source , _Bool v ) ; +#line 35 +extern char ocBroadcastChar(int source , char v ) ; +#line 36 +extern int ocBroadcastInt(int source , int v ) ; +#line 37 +extern short ocBroadcastShort(int source , short v ) ; +#line 38 +extern long ocBroadcastLong(int source , long v ) ; +#line 39 +extern long long ocBroadcastLLong(int source , long long v ) ; +#line 15 "./mutual.h" +extern char const *mySide() ; +#line 17 +void mutualFriends(void *args ) ; +#line 9 "mutual.oc" +obool oblivStrCmp(__obliv_c__bool const *__obliv_c__en , __obliv_c__char *s1 , __obliv_c__char *s2 ) +{ + __obliv_c__bool afternull ; + int i ; + obool ob ; + __obliv_c__char c ; + int __cil_tmp7 ; + int __cil_tmp8 ; + __obliv_c__char *__cil_tmp9 ; + __obliv_c__char __cil_tmp10 ; + __obliv_c__char *__cil_tmp11 ; + __obliv_c__char __cil_tmp12 ; + __obliv_c__int __cil_tmp13 ; + __obliv_c__int __cil_tmp14 ; + __obliv_c__int __cil_tmp15 ; + __obliv_c__int __cil_tmp16 ; + int __cil_tmp17 ; + int __cil_tmp18 ; + int __cil_tmp19 ; + __obliv_c__bool __obliv_c__cond21 ; + __obliv_c__bool __obliv_c__cond22 ; + __obliv_c__bool __obliv_c__cond23 ; + __obliv_c__bool __obliv_c__cond24 ; + __obliv_c__bool __obliv_c__cond25 ; + __obliv_c__bool __obliv_c__cond26 ; + __obliv_c__bool __obliv_c__cond27 ; + __obliv_c__bool __obliv_c__cond28 ; + __obliv_c__bool __obliv_c__cond29 ; + + { +#line 49 + memset((void *)(& afternull), 0, sizeof(__obliv_c__bool )); +#line 49 + memset((void *)(& i), 0, sizeof(int )); +#line 49 + memset((void *)(& ob), 0, sizeof(obool )); +#line 49 + memset((void *)(& c), 0, sizeof(__obliv_c__char )); +#line 11 + __obliv_c__setSignedKnown(& afternull, 1UL, (widest_t )((_Bool )0)); +#line 13 + __obliv_c__setSignedKnown(& ob, 1UL, (widest_t )((_Bool )1)); +#line 15 + i = 0; +#line 15 + while (1) { + { +#line 15 + __cil_tmp7 = (int )10; +#line 15 + __cil_tmp8 = (int )i; +#line 15 + if (! (__cil_tmp8 < __cil_tmp7)) { +#line 15 + break; + } + } + { +#line 17 + __obliv_c__cond21 = afternull; +#line 17 + __obliv_c__setBitAnd((struct OblivBit *)(& __obliv_c__cond22), (struct OblivBit const *)(& __obliv_c__cond21), + (struct OblivBit const *)(& *__obliv_c__en)); +#line 17 + __obliv_c__setNotEqual(& __obliv_c__cond23, & __obliv_c__cond22, & *__obliv_c__en, + 1UL); + { + + } + { +#line 20 + __cil_tmp9 = s1 + i; +#line 20 + __cil_tmp10 = *((__obliv_c__char *)__cil_tmp9); +#line 20 + __obliv_c__setSignExtend(& c, 8UL, & __cil_tmp10, 8UL); + { +#line 21 + __cil_tmp11 = s2 + i; +#line 21 + __cil_tmp12 = *((__obliv_c__char *)__cil_tmp11); +#line 21 + __obliv_c__setSignExtend(& __cil_tmp13, 32UL, & __cil_tmp12, 8UL); +#line 21 + __obliv_c__setSignExtend(& __cil_tmp14, 32UL, & c, 8UL); + { +#line 21 + __obliv_c__setNotEqual(& __obliv_c__cond24, & __cil_tmp14, & __cil_tmp13, 32UL); +#line 21 + __obliv_c__setBitAnd((struct OblivBit *)(& __obliv_c__cond25), (struct OblivBit const *)(& __obliv_c__cond24), + (struct OblivBit const *)(& __obliv_c__cond23)); +#line 21 + __obliv_c__setNotEqual(& __obliv_c__cond26, & __obliv_c__cond25, & __obliv_c__cond23, + 1UL); + { +#line 22 + __obliv_c__condAssignKnown(& __obliv_c__cond25, & ob, 1UL, (widest_t )((_Bool )0)); + } + { + { +#line 24 + __obliv_c__setSignedKnown(& __cil_tmp15, 32UL, (widest_t )((int )0)); +#line 24 + __obliv_c__setSignExtend(& __cil_tmp16, 32UL, & c, 8UL); + { +#line 24 + __obliv_c__setEqualTo(& __obliv_c__cond27, & __cil_tmp16, & __cil_tmp15, 32UL); +#line 24 + __obliv_c__setBitAnd((struct OblivBit *)(& __obliv_c__cond28), (struct OblivBit const *)(& __obliv_c__cond27), + (struct OblivBit const *)(& __obliv_c__cond26)); +#line 24 + __obliv_c__setNotEqual(& __obliv_c__cond29, & __obliv_c__cond28, & __obliv_c__cond26, + 1UL); + { +#line 25 + __obliv_c__condAssignKnown(& __obliv_c__cond28, & afternull, 1UL, (widest_t )((_Bool )1)); + } + { + + } + } + } + } + } + } + } + } +#line 15 + __cil_tmp17 = (int )1; +#line 15 + __cil_tmp18 = (int )i; +#line 15 + __cil_tmp19 = __cil_tmp18 + __cil_tmp17; +#line 15 + i = (int )__cil_tmp19; + } +#line 33 + return (ob); +} +} +#line 36 "mutual.oc" +void addString(__obliv_c__bool const *__obliv_c__en , __obliv_c__char *src , __obliv_c__char *dest ) +{ + int i ; + int __cil_tmp4 ; + int __cil_tmp5 ; + __obliv_c__char *__cil_tmp6 ; + __obliv_c__char *__cil_tmp7 ; + int __cil_tmp8 ; + int __cil_tmp9 ; + int __cil_tmp10 ; + + { +#line 49 + memset((void *)(& i), 0, sizeof(int )); +#line 38 + i = 0; +#line 38 + while (1) { + { +#line 38 + __cil_tmp4 = (int )10; +#line 38 + __cil_tmp5 = (int )i; +#line 38 + if (! (__cil_tmp5 < __cil_tmp4)) { +#line 38 + break; + } + } +#line 39 + __cil_tmp6 = dest + i; +#line 39 + __cil_tmp7 = src + i; +#line 39 + __obliv_c__condAssign(__obliv_c__en, (__obliv_c__char *)__cil_tmp6, (__obliv_c__char *)__cil_tmp7, + 8UL); +#line 38 + __cil_tmp8 = (int )1; +#line 38 + __cil_tmp9 = (int )i; +#line 38 + __cil_tmp10 = __cil_tmp9 + __cil_tmp8; +#line 38 + i = (int )__cil_tmp10; + } +#line 40 + return; +} +} +#line 42 "mutual.oc" +void readString(__obliv_c__char *dest , int n , char const *src , int party ) +{ + OblivInputs specs[45] ; + int i ; + unsigned long __cil_tmp7 ; + unsigned long __cil_tmp8 ; + OblivInputs *__cil_tmp9 ; + size_t __cil_tmp10 ; + + { +#line 49 + memset((void *)(& specs), 0, sizeof(OblivInputs [45])); +#line 49 + memset((void *)(& i), 0, sizeof(int )); +#line 47 + __cil_tmp7 = 0 * 24UL; +#line 47 + __cil_tmp8 = (unsigned long )(specs) + __cil_tmp7; +#line 47 + __cil_tmp9 = (OblivInputs *)__cil_tmp8; +#line 47 + __cil_tmp10 = (size_t )n; +#line 47 + feedOblivInputs(__cil_tmp9, __cil_tmp10, party); +#line 48 + return; +} +} +#line 49 "mutual.oc" +void mutualFriends(void *args ) +{ + protocolIO *io ; + int size1 ; + int size2 ; + int i ; + int j ; + obool match[45] ; + __obliv_c__char friends1[45][10] ; + __obliv_c__char friends2[45][10] ; + __obliv_c__char commonFriends[45][10] ; + __obliv_c__int commonSize ; + obool tmp ; + _Bool pubMatch[45] ; + unsigned long __cil_tmp14 ; + unsigned long __cil_tmp15 ; + int __cil_tmp16 ; + unsigned long __cil_tmp17 ; + unsigned long __cil_tmp18 ; + int __cil_tmp19 ; + int __cil_tmp20 ; + int __cil_tmp21 ; + int __cil_tmp22 ; + int __cil_tmp23 ; + unsigned long __cil_tmp24 ; + unsigned long __cil_tmp25 ; + unsigned long __cil_tmp26 ; + unsigned long __cil_tmp27 ; + unsigned long __cil_tmp28 ; + unsigned long __cil_tmp29 ; + unsigned long __cil_tmp30 ; + unsigned long __cil_tmp31 ; + unsigned long __cil_tmp32 ; + unsigned long __cil_tmp33 ; + char __cil_tmp34 ; + int __cil_tmp35 ; + int __cil_tmp36 ; + int __cil_tmp37 ; + int __cil_tmp38 ; + int __cil_tmp39 ; + int __cil_tmp40 ; + int __cil_tmp41 ; + int __cil_tmp42 ; + unsigned long __cil_tmp43 ; + unsigned long __cil_tmp44 ; + int __cil_tmp45 ; + int __cil_tmp46 ; + int __cil_tmp47 ; + int __cil_tmp48 ; + int __cil_tmp49 ; + int __cil_tmp50 ; + int __cil_tmp51 ; + unsigned long __cil_tmp52 ; + unsigned long __cil_tmp53 ; + unsigned long __cil_tmp54 ; + unsigned long __cil_tmp55 ; + unsigned long __cil_tmp56 ; + unsigned long __cil_tmp57 ; + unsigned long __cil_tmp58 ; + unsigned long __cil_tmp59 ; + unsigned long __cil_tmp60 ; + unsigned long __cil_tmp61 ; + char __cil_tmp62 ; + int __cil_tmp63 ; + int __cil_tmp64 ; + int __cil_tmp65 ; + int __cil_tmp66 ; + int __cil_tmp67 ; + int __cil_tmp68 ; + int __cil_tmp69 ; + int __cil_tmp70 ; + int __cil_tmp71 ; + int __cil_tmp72 ; + __obliv_c__int __cil_tmp73 ; + unsigned long __cil_tmp74 ; + unsigned long __cil_tmp75 ; + obool __cil_tmp76 ; + __obliv_c__int __cil_tmp77 ; + unsigned long __cil_tmp78 ; + unsigned long __cil_tmp79 ; + unsigned long __cil_tmp80 ; + unsigned long __cil_tmp81 ; + __obliv_c__char *__cil_tmp82 ; + unsigned long __cil_tmp83 ; + unsigned long __cil_tmp84 ; + unsigned long __cil_tmp85 ; + unsigned long __cil_tmp86 ; + __obliv_c__char *__cil_tmp87 ; + __obliv_c__int __cil_tmp88 ; + __obliv_c__int __cil_tmp89 ; + __obliv_c__int __cil_tmp90 ; + unsigned long __cil_tmp91 ; + unsigned long __cil_tmp92 ; + unsigned long __cil_tmp93 ; + unsigned long __cil_tmp94 ; + __obliv_c__char *__cil_tmp95 ; + unsigned long __cil_tmp96 ; + unsigned long __cil_tmp97 ; + unsigned long __cil_tmp98 ; + unsigned long __cil_tmp99 ; + __obliv_c__char *__cil_tmp100 ; + int __cil_tmp101 ; + int __cil_tmp102 ; + int __cil_tmp103 ; + int __cil_tmp104 ; + int __cil_tmp105 ; + int __cil_tmp106 ; + int __cil_tmp107 ; + int __cil_tmp108 ; + int __cil_tmp109 ; + int __cil_tmp110 ; + int __cil_tmp111 ; + unsigned long __cil_tmp112 ; + unsigned long __cil_tmp113 ; + _Bool __cil_tmp114 ; + int __cil_tmp115 ; + int __cil_tmp116 ; + int __cil_tmp117 ; + int __cil_tmp118 ; + int __cil_tmp119 ; + int __cil_tmp120 ; + int __cil_tmp121 ; + int __cil_tmp122 ; + int __cil_tmp123 ; + int __cil_tmp124 ; + unsigned long __cil_tmp125 ; + unsigned long __cil_tmp126 ; + int *__cil_tmp127 ; + int __cil_tmp128 ; + int __cil_tmp129 ; + int __cil_tmp130 ; + int __cil_tmp131 ; + unsigned long __cil_tmp132 ; + unsigned long __cil_tmp133 ; + unsigned long __cil_tmp134 ; + unsigned long __cil_tmp135 ; + unsigned long __cil_tmp136 ; + unsigned long __cil_tmp137 ; + char *__cil_tmp138 ; + unsigned long __cil_tmp139 ; + unsigned long __cil_tmp140 ; + unsigned long __cil_tmp141 ; + unsigned long __cil_tmp142 ; + __obliv_c__char __cil_tmp143 ; + int __cil_tmp144 ; + int __cil_tmp145 ; + int __cil_tmp146 ; + int __cil_tmp147 ; + int __cil_tmp148 ; + int __cil_tmp149 ; + __obliv_c__bool __obliv_c__cond150 ; + __obliv_c__bool __obliv_c__cond151 ; + __obliv_c__bool __obliv_c__cond152 ; + obool __cil_tmp153 ; + __obliv_c__bool __obliv_c__cond154 ; + __obliv_c__bool __obliv_c__cond155 ; + __obliv_c__bool __obliv_c__cond156 ; + __obliv_c__int __cil_tmp157 ; + + { +#line 49 + memset((void *)(& io), 0, sizeof(protocolIO *)); +#line 49 + memset((void *)(& size1), 0, sizeof(int )); +#line 49 + memset((void *)(& size2), 0, sizeof(int )); +#line 49 + memset((void *)(& i), 0, sizeof(int )); +#line 49 + memset((void *)(& j), 0, sizeof(int )); +#line 49 + memset((void *)(& match), 0, sizeof(obool [45])); +#line 49 + memset((void *)(& friends1), 0, sizeof(__obliv_c__char [45][10])); +#line 49 + memset((void *)(& friends2), 0, sizeof(__obliv_c__char [45][10])); +#line 49 + memset((void *)(& commonFriends), 0, sizeof(__obliv_c__char [45][10])); +#line 49 + memset((void *)(& commonSize), 0, sizeof(__obliv_c__int )); +#line 49 + memset((void *)(& tmp), 0, sizeof(obool )); +#line 49 + memset((void *)(& pubMatch), 0, sizeof(_Bool [45])); +#line 50 + io = (protocolIO *)args; +#line 58 + __cil_tmp14 = (unsigned long )io; +#line 58 + __cil_tmp15 = __cil_tmp14 + 452; +#line 58 + __cil_tmp16 = *((int *)__cil_tmp15); +#line 58 + size1 = ocBroadcastInt(1, __cil_tmp16); +#line 59 + __cil_tmp17 = (unsigned long )io; +#line 59 + __cil_tmp18 = __cil_tmp17 + 452; +#line 59 + __cil_tmp19 = *((int *)__cil_tmp18); +#line 59 + size2 = ocBroadcastInt(2, __cil_tmp19); +#line 60 + i = 0; +#line 60 + while (1) { + { +#line 60 + __cil_tmp20 = (int )size1; +#line 60 + __cil_tmp21 = (int )i; +#line 60 + if (! (__cil_tmp21 < __cil_tmp20)) { +#line 60 + break; + } + } +#line 61 + j = 0; +#line 61 + while (1) { + { +#line 61 + __cil_tmp22 = (int )10; +#line 61 + __cil_tmp23 = (int )j; +#line 61 + if (! (__cil_tmp23 < __cil_tmp22)) { +#line 61 + break; + } + } +#line 62 + __cil_tmp24 = j * 104UL; +#line 62 + __cil_tmp25 = i * 1040UL; +#line 62 + __cil_tmp26 = __cil_tmp25 + __cil_tmp24; +#line 62 + __cil_tmp27 = (unsigned long )(friends1) + __cil_tmp26; +#line 62 + __cil_tmp28 = j * 1UL; +#line 62 + __cil_tmp29 = i * 10UL; +#line 62 + __cil_tmp30 = __cil_tmp29 + __cil_tmp28; +#line 62 + __cil_tmp31 = 0 + __cil_tmp30; +#line 62 + __cil_tmp32 = (unsigned long )io; +#line 62 + __cil_tmp33 = __cil_tmp32 + __cil_tmp31; +#line 62 + __cil_tmp34 = *((char *)__cil_tmp33); +#line 62 + *((__obliv_c__char *)__cil_tmp27) = feedOblivChar(__cil_tmp34, 1); +#line 61 + __cil_tmp35 = (int )1; +#line 61 + __cil_tmp36 = (int )j; +#line 61 + __cil_tmp37 = __cil_tmp36 + __cil_tmp35; +#line 61 + j = (int )__cil_tmp37; + } +#line 60 + __cil_tmp38 = (int )1; +#line 60 + __cil_tmp39 = (int )i; +#line 60 + __cil_tmp40 = __cil_tmp39 + __cil_tmp38; +#line 60 + i = (int )__cil_tmp40; + } +#line 65 + i = 0; +#line 65 + while (1) { + { +#line 65 + __cil_tmp41 = (int )45; +#line 65 + __cil_tmp42 = (int )i; +#line 65 + if (! (__cil_tmp42 < __cil_tmp41)) { +#line 65 + break; + } + } +#line 66 + __cil_tmp43 = i * 13UL; +#line 66 + __cil_tmp44 = (unsigned long )(match) + __cil_tmp43; +#line 66 + __obliv_c__setSignedKnown(& *((obool *)__cil_tmp44), 1UL, (widest_t )((_Bool )0)); +#line 65 + __cil_tmp45 = (int )1; +#line 65 + __cil_tmp46 = (int )i; +#line 65 + __cil_tmp47 = __cil_tmp46 + __cil_tmp45; +#line 65 + i = (int )__cil_tmp47; + } +#line 67 + i = 0; +#line 67 + while (1) { + { +#line 67 + __cil_tmp48 = (int )size2; +#line 67 + __cil_tmp49 = (int )i; +#line 67 + if (! (__cil_tmp49 < __cil_tmp48)) { +#line 67 + break; + } + } +#line 68 + j = 0; +#line 68 + while (1) { + { +#line 68 + __cil_tmp50 = (int )10; +#line 68 + __cil_tmp51 = (int )j; +#line 68 + if (! (__cil_tmp51 < __cil_tmp50)) { +#line 68 + break; + } + } +#line 69 + __cil_tmp52 = j * 104UL; +#line 69 + __cil_tmp53 = i * 1040UL; +#line 69 + __cil_tmp54 = __cil_tmp53 + __cil_tmp52; +#line 69 + __cil_tmp55 = (unsigned long )(friends2) + __cil_tmp54; +#line 69 + __cil_tmp56 = j * 1UL; +#line 69 + __cil_tmp57 = i * 10UL; +#line 69 + __cil_tmp58 = __cil_tmp57 + __cil_tmp56; +#line 69 + __cil_tmp59 = 0 + __cil_tmp58; +#line 69 + __cil_tmp60 = (unsigned long )io; +#line 69 + __cil_tmp61 = __cil_tmp60 + __cil_tmp59; +#line 69 + __cil_tmp62 = *((char *)__cil_tmp61); +#line 69 + *((__obliv_c__char *)__cil_tmp55) = feedOblivChar(__cil_tmp62, 2); +#line 68 + __cil_tmp63 = (int )1; +#line 68 + __cil_tmp64 = (int )j; +#line 68 + __cil_tmp65 = __cil_tmp64 + __cil_tmp63; +#line 68 + j = (int )__cil_tmp65; + } +#line 67 + __cil_tmp66 = (int )1; +#line 67 + __cil_tmp67 = (int )i; +#line 67 + __cil_tmp68 = __cil_tmp67 + __cil_tmp66; +#line 67 + i = (int )__cil_tmp68; + } +#line 71 + i = 0; +#line 71 + while (1) { + { +#line 71 + __cil_tmp69 = (int )size1; +#line 71 + __cil_tmp70 = (int )i; +#line 71 + if (! (__cil_tmp70 < __cil_tmp69)) { +#line 71 + break; + } + } +#line 72 + j = 0; +#line 72 + while (1) { + { +#line 72 + __cil_tmp71 = (int )size2; +#line 72 + __cil_tmp72 = (int )j; +#line 72 + if (! (__cil_tmp72 < __cil_tmp71)) { +#line 72 + break; + } + } + { +#line 73 + __obliv_c__setSignedKnown(& __cil_tmp73, 32UL, (widest_t )((int )0)); +#line 73 + __cil_tmp74 = j * 13UL; +#line 73 + __cil_tmp75 = (unsigned long )(match) + __cil_tmp74; +#line 73 + __cil_tmp76 = *((obool *)__cil_tmp75); +#line 73 + __obliv_c__setZeroExtend(& __cil_tmp77, 32UL, & __cil_tmp76, 1UL); + { +#line 73 + __obliv_c__setEqualTo(& __obliv_c__cond150, & __cil_tmp77, & __cil_tmp73, 32UL); +#line 73 + __obliv_c__setBitAnd((struct OblivBit *)(& __obliv_c__cond151), (struct OblivBit const *)(& __obliv_c__cond150), + (struct OblivBit const *)(& __obliv_c__trueCond)); +#line 73 + __obliv_c__setNotEqual(& __obliv_c__cond152, & __obliv_c__cond151, & __obliv_c__trueCond, + 1UL); + { +#line 74 + __cil_tmp78 = 0 * 104UL; +#line 74 + __cil_tmp79 = i * 1040UL; +#line 74 + __cil_tmp80 = __cil_tmp79 + __cil_tmp78; +#line 74 + __cil_tmp81 = (unsigned long )(friends1) + __cil_tmp80; +#line 74 + __cil_tmp82 = (__obliv_c__char *)__cil_tmp81; +#line 74 + __cil_tmp83 = 0 * 104UL; +#line 74 + __cil_tmp84 = j * 1040UL; +#line 74 + __cil_tmp85 = __cil_tmp84 + __cil_tmp83; +#line 74 + __cil_tmp86 = (unsigned long )(friends2) + __cil_tmp85; +#line 74 + __cil_tmp87 = (__obliv_c__char *)__cil_tmp86; +#line 74 + __cil_tmp153 = oblivStrCmp(& __obliv_c__cond151, __cil_tmp82, __cil_tmp87); +#line 74 + tmp = __cil_tmp153; + { +#line 74 + __obliv_c__cond154 = tmp; +#line 74 + __obliv_c__setBitAnd((struct OblivBit *)(& __obliv_c__cond155), (struct OblivBit const *)(& __obliv_c__cond154), + (struct OblivBit const *)(& __obliv_c__cond151)); +#line 74 + __obliv_c__setNotEqual(& __obliv_c__cond156, & __obliv_c__cond155, & __obliv_c__cond151, + 1UL); + { +#line 75 + __obliv_c__setSignedKnown(& __cil_tmp88, 32UL, (widest_t )((int )1)); +#line 75 + __obliv_c__setSignExtend(& __cil_tmp89, 32UL, & commonSize, 32UL); +#line 75 + __obliv_c__setPlainAdd(& __cil_tmp90, & __cil_tmp89, & __cil_tmp88, 32UL); +#line 75 + __obliv_c__setSignExtend(& __cil_tmp157, 32UL, & __cil_tmp90, 32UL); +#line 75 + __obliv_c__condAssign(& __obliv_c__cond155, & commonSize, & __cil_tmp157, 32UL); +#line 77 + __cil_tmp91 = 0 * 104UL; +#line 77 + __cil_tmp92 = i * 1040UL; +#line 77 + __cil_tmp93 = __cil_tmp92 + __cil_tmp91; +#line 77 + __cil_tmp94 = (unsigned long )(friends1) + __cil_tmp93; +#line 77 + __cil_tmp95 = (__obliv_c__char *)__cil_tmp94; +#line 77 + __cil_tmp96 = 0 * 104UL; +#line 77 + __cil_tmp97 = i * 1040UL; +#line 77 + __cil_tmp98 = __cil_tmp97 + __cil_tmp96; +#line 77 + __cil_tmp99 = (unsigned long )(commonFriends) + __cil_tmp98; +#line 77 + __cil_tmp100 = (__obliv_c__char *)__cil_tmp99; +#line 77 + addString(& __obliv_c__cond155, __cil_tmp95, __cil_tmp100); + } + { + + } + } + } + { + + } + } + } +#line 72 + __cil_tmp101 = (int )1; +#line 72 + __cil_tmp102 = (int )j; +#line 72 + __cil_tmp103 = __cil_tmp102 + __cil_tmp101; +#line 72 + j = (int )__cil_tmp103; + } +#line 71 + __cil_tmp104 = (int )1; +#line 71 + __cil_tmp105 = (int )i; +#line 71 + __cil_tmp106 = __cil_tmp105 + __cil_tmp104; +#line 71 + i = (int )__cil_tmp106; + } +#line 80 + j = 0; +#line 83 + i = 0; +#line 83 + while (1) { + { +#line 83 + __cil_tmp107 = (int )45; +#line 83 + __cil_tmp108 = (int )i; +#line 83 + if (! (__cil_tmp108 < __cil_tmp107)) { +#line 83 + break; + } + } +#line 86 + i = 0; +#line 86 + while (1) { + { +#line 86 + __cil_tmp109 = (int )45; +#line 86 + __cil_tmp110 = (int )i; +#line 86 + if (! (__cil_tmp110 < __cil_tmp109)) { +#line 86 + break; + } + } + { +#line 87 + __cil_tmp111 = (int )1; +#line 87 + __cil_tmp112 = i * 1UL; +#line 87 + __cil_tmp113 = (unsigned long )(pubMatch) + __cil_tmp112; +#line 87 + __cil_tmp114 = *((_Bool *)__cil_tmp113); +#line 87 + __cil_tmp115 = (int )__cil_tmp114; +#line 87 + if (__cil_tmp115 == __cil_tmp111) { +#line 89 + __cil_tmp116 = (int )1; +#line 89 + __cil_tmp117 = (int )j; +#line 89 + __cil_tmp118 = __cil_tmp117 + __cil_tmp116; +#line 89 + j = (int )__cil_tmp118; + } + } +#line 86 + __cil_tmp119 = (int )1; +#line 86 + __cil_tmp120 = (int )i; +#line 86 + __cil_tmp121 = __cil_tmp120 + __cil_tmp119; +#line 86 + i = (int )__cil_tmp121; + } +#line 83 + __cil_tmp122 = (int )1; +#line 83 + __cil_tmp123 = (int )i; +#line 83 + __cil_tmp124 = __cil_tmp123 + __cil_tmp122; +#line 83 + i = (int )__cil_tmp124; + } +#line 91 + __cil_tmp125 = (unsigned long )io; +#line 91 + __cil_tmp126 = __cil_tmp125 + 908; +#line 91 + __cil_tmp127 = (int *)__cil_tmp126; +#line 91 + revealOblivInt(__cil_tmp127, commonSize, 0); +#line 92 + i = 0; +#line 92 + while (1) { + { +#line 92 + __cil_tmp128 = (int )45; +#line 92 + __cil_tmp129 = (int )i; +#line 92 + if (! (__cil_tmp129 < __cil_tmp128)) { +#line 92 + break; + } + } +#line 93 + j = 0; +#line 93 + while (1) { + { +#line 93 + __cil_tmp130 = (int )10; +#line 93 + __cil_tmp131 = (int )j; +#line 93 + if (! (__cil_tmp131 < __cil_tmp130)) { +#line 93 + break; + } + } +#line 94 + __cil_tmp132 = j * 1UL; +#line 94 + __cil_tmp133 = i * 10UL; +#line 94 + __cil_tmp134 = __cil_tmp133 + __cil_tmp132; +#line 94 + __cil_tmp135 = 456 + __cil_tmp134; +#line 94 + __cil_tmp136 = (unsigned long )io; +#line 94 + __cil_tmp137 = __cil_tmp136 + __cil_tmp135; +#line 94 + __cil_tmp138 = (char *)__cil_tmp137; +#line 94 + __cil_tmp139 = j * 104UL; +#line 94 + __cil_tmp140 = i * 1040UL; +#line 94 + __cil_tmp141 = __cil_tmp140 + __cil_tmp139; +#line 94 + __cil_tmp142 = (unsigned long )(commonFriends) + __cil_tmp141; +#line 94 + __cil_tmp143 = *((__obliv_c__char *)__cil_tmp142); +#line 94 + revealOblivChar(__cil_tmp138, __cil_tmp143, 0); +#line 93 + __cil_tmp144 = (int )1; +#line 93 + __cil_tmp145 = (int )j; +#line 93 + __cil_tmp146 = __cil_tmp145 + __cil_tmp144; +#line 93 + j = (int )__cil_tmp146; + } +#line 92 + __cil_tmp147 = (int )1; +#line 92 + __cil_tmp148 = (int )i; +#line 92 + __cil_tmp149 = __cil_tmp148 + __cil_tmp147; +#line 92 + i = (int )__cil_tmp149; + } +#line 96 + return; +} +} diff --git a/test/oblivc/mutual/mutual.oc.cil.i b/test/oblivc/mutual/mutual.oc.cil.i new file mode 100644 index 000000000..9c556552b --- /dev/null +++ b/test/oblivc/mutual/mutual.oc.cil.i @@ -0,0 +1,4517 @@ +# 1 "mutual.oc.cil.c" +# 1 "" +# 1 "" +# 1 "mutual.oc.cil.c" +# 150 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" +typedef long ptrdiff_t; +# 212 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" +typedef unsigned long size_t; +# 324 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" +typedef int wchar_t; +# 37 "/usr/include/stdint.h" +typedef signed char int8_t; +# 38 "/usr/include/stdint.h" +typedef short int16_t; +# 39 "/usr/include/stdint.h" +typedef int int32_t; +# 41 "/usr/include/stdint.h" +typedef long int64_t; +# 49 "/usr/include/stdint.h" +typedef unsigned char uint8_t; +# 50 "/usr/include/stdint.h" +typedef unsigned short uint16_t; +# 52 "/usr/include/stdint.h" +typedef unsigned int uint32_t; +# 56 "/usr/include/stdint.h" +typedef unsigned long uint64_t; +# 66 "/usr/include/stdint.h" +typedef signed char int_least8_t; +# 67 "/usr/include/stdint.h" +typedef short int_least16_t; +# 68 "/usr/include/stdint.h" +typedef int int_least32_t; +# 70 "/usr/include/stdint.h" +typedef long int_least64_t; +# 77 "/usr/include/stdint.h" +typedef unsigned char uint_least8_t; +# 78 "/usr/include/stdint.h" +typedef unsigned short uint_least16_t; +# 79 "/usr/include/stdint.h" +typedef unsigned int uint_least32_t; +# 81 "/usr/include/stdint.h" +typedef unsigned long uint_least64_t; +# 91 "/usr/include/stdint.h" +typedef signed char int_fast8_t; +# 93 "/usr/include/stdint.h" +typedef long int_fast16_t; +# 94 "/usr/include/stdint.h" +typedef long int_fast32_t; +# 95 "/usr/include/stdint.h" +typedef long int_fast64_t; +# 104 "/usr/include/stdint.h" +typedef unsigned char uint_fast8_t; +# 106 "/usr/include/stdint.h" +typedef unsigned long uint_fast16_t; +# 107 "/usr/include/stdint.h" +typedef unsigned long uint_fast32_t; +# 108 "/usr/include/stdint.h" +typedef unsigned long uint_fast64_t; +# 120 "/usr/include/stdint.h" +typedef long intptr_t; +# 123 "/usr/include/stdint.h" +typedef unsigned long uintptr_t; +# 135 "/usr/include/stdint.h" +typedef long intmax_t; +# 136 "/usr/include/stdint.h" +typedef unsigned long uintmax_t; +# 67 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" +struct __anonstruct___wait_terminated_1 { + unsigned int __w_termsig : 7 ; + unsigned int __w_coredump : 1 ; + unsigned int __w_retcode : 8 ; + unsigned int : 16 ; +}; +# 67 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" +struct __anonstruct___wait_stopped_2 { + unsigned int __w_stopval : 8 ; + unsigned int __w_stopsig : 8 ; + unsigned int : 16 ; +}; +# 67 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" +union wait { + int w_status ; + struct __anonstruct___wait_terminated_1 __wait_terminated ; + struct __anonstruct___wait_stopped_2 __wait_stopped ; +}; +# 68 "/usr/include/stdlib.h" +union __anonunion___WAIT_STATUS_3 { + union wait *__uptr ; + int *__iptr ; +}; +# 68 "/usr/include/stdlib.h" +typedef union __anonunion___WAIT_STATUS_3 __attribute__((__transparent_union__)) __WAIT_STATUS; +# 98 "/usr/include/stdlib.h" +struct __anonstruct_div_t_4 { + int quot ; + int rem ; +}; +# 98 "/usr/include/stdlib.h" +typedef struct __anonstruct_div_t_4 div_t; +# 106 "/usr/include/stdlib.h" +struct __anonstruct_ldiv_t_5 { + long quot ; + long rem ; +}; +# 106 "/usr/include/stdlib.h" +typedef struct __anonstruct_ldiv_t_5 ldiv_t; +# 118 "/usr/include/stdlib.h" +struct __anonstruct_lldiv_t_6 { + long long quot ; + long long rem ; +}; +# 118 "/usr/include/stdlib.h" +typedef struct __anonstruct_lldiv_t_6 lldiv_t; +# 31 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned char __u_char; +# 32 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned short __u_short; +# 33 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __u_int; +# 34 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __u_long; +# 37 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef signed char __int8_t; +# 38 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned char __uint8_t; +# 39 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef short __int16_t; +# 40 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned short __uint16_t; +# 41 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef int __int32_t; +# 42 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __uint32_t; +# 44 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __int64_t; +# 45 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __uint64_t; +# 53 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __quad_t; +# 54 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __u_quad_t; +# 134 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __dev_t; +# 135 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __uid_t; +# 136 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __gid_t; +# 137 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __ino_t; +# 138 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __ino64_t; +# 139 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __mode_t; +# 140 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __nlink_t; +# 141 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __off_t; +# 142 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __off64_t; +# 143 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef int __pid_t; +# 144 "/usr/include/x86_64-linux-gnu/bits/types.h" +struct __anonstruct___fsid_t_7 { + int __val[2] ; +}; +# 144 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef struct __anonstruct___fsid_t_7 __fsid_t; +# 145 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __clock_t; +# 146 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __rlim_t; +# 147 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __rlim64_t; +# 148 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __id_t; +# 149 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __time_t; +# 150 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __useconds_t; +# 151 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __suseconds_t; +# 153 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef int __daddr_t; +# 154 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __swblk_t; +# 155 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef int __key_t; +# 158 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef int __clockid_t; +# 161 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef void *__timer_t; +# 164 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __blksize_t; +# 169 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __blkcnt_t; +# 170 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __blkcnt64_t; +# 173 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __fsblkcnt_t; +# 174 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __fsblkcnt64_t; +# 177 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __fsfilcnt_t; +# 178 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned long __fsfilcnt64_t; +# 180 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __ssize_t; +# 184 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef __off64_t __loff_t; +# 185 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef __quad_t *__qaddr_t; +# 186 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef char *__caddr_t; +# 189 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef long __intptr_t; +# 192 "/usr/include/x86_64-linux-gnu/bits/types.h" +typedef unsigned int __socklen_t; +# 34 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __u_char u_char; +# 35 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __u_short u_short; +# 36 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __u_int u_int; +# 37 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __u_long u_long; +# 38 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __quad_t quad_t; +# 39 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __u_quad_t u_quad_t; +# 40 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __fsid_t fsid_t; +# 45 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __loff_t loff_t; +# 49 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __ino_t ino_t; +# 61 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __dev_t dev_t; +# 66 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __gid_t gid_t; +# 71 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __mode_t mode_t; +# 76 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __nlink_t nlink_t; +# 81 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __uid_t uid_t; +# 87 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __off_t off_t; +# 99 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __pid_t pid_t; +# 105 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __id_t id_t; +# 110 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __ssize_t ssize_t; +# 116 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __daddr_t daddr_t; +# 117 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __caddr_t caddr_t; +# 123 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __key_t key_t; +# 60 "/usr/include/time.h" +typedef __clock_t clock_t; +# 76 "/usr/include/time.h" +typedef __time_t time_t; +# 92 "/usr/include/time.h" +typedef __clockid_t clockid_t; +# 104 "/usr/include/time.h" +typedef __timer_t timer_t; +# 151 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef unsigned long ulong; +# 152 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef unsigned short ushort; +# 153 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef unsigned int uint; +# 201 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef unsigned char u_int8_t; +# 202 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef unsigned short u_int16_t; +# 203 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef unsigned int u_int32_t; +# 204 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef unsigned long u_int64_t; +# 206 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef int register_t; +# 24 "/usr/include/x86_64-linux-gnu/bits/sigset.h" +typedef int __sig_atomic_t; +# 29 "/usr/include/x86_64-linux-gnu/bits/sigset.h" +struct __anonstruct___sigset_t_8 { + unsigned long __val[(unsigned long )1024 / (unsigned long )((unsigned long )8 * (unsigned long )sizeof(unsigned long ))] ; +}; +# 29 "/usr/include/x86_64-linux-gnu/bits/sigset.h" +typedef struct __anonstruct___sigset_t_8 __sigset_t; +# 38 "/usr/include/x86_64-linux-gnu/sys/select.h" +typedef __sigset_t sigset_t; +# 120 "/usr/include/time.h" +struct timespec { + __time_t tv_sec ; + long tv_nsec ; +}; +# 31 "/usr/include/x86_64-linux-gnu/bits/time.h" +struct timeval { + __time_t tv_sec ; + __suseconds_t tv_usec ; +}; +# 49 "/usr/include/x86_64-linux-gnu/sys/select.h" +typedef __suseconds_t suseconds_t; +# 55 "/usr/include/x86_64-linux-gnu/sys/select.h" +typedef long __fd_mask; +# 65 "/usr/include/x86_64-linux-gnu/sys/select.h" +struct __anonstruct_fd_set_9 { + __fd_mask __fds_bits[(int )1024 / (int )((int )8 * (int )((int )sizeof(__fd_mask )))] ; +}; +# 65 "/usr/include/x86_64-linux-gnu/sys/select.h" +typedef struct __anonstruct_fd_set_9 fd_set; +# 83 "/usr/include/x86_64-linux-gnu/sys/select.h" +typedef __fd_mask fd_mask; +# 229 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __blksize_t blksize_t; +# 236 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __blkcnt_t blkcnt_t; +# 240 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __fsblkcnt_t fsblkcnt_t; +# 244 "/usr/include/x86_64-linux-gnu/sys/types.h" +typedef __fsfilcnt_t fsfilcnt_t; +# 50 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef unsigned long pthread_t; +# 53 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_attr_t_10 { + char __size[56] ; + long __align ; +}; +# 53 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_attr_t_10 pthread_attr_t; +# 61 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +struct __pthread_internal_list { + struct __pthread_internal_list *__prev ; + struct __pthread_internal_list *__next ; +}; +# 61 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef struct __pthread_internal_list __pthread_list_t; +# 76 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +struct __pthread_mutex_s { + int __lock ; + unsigned int __count ; + int __owner ; + unsigned int __nusers ; + int __kind ; + int __spins ; + __pthread_list_t __list ; +}; +# 76 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_mutex_t_11 { + struct __pthread_mutex_s __data ; + char __size[40] ; + long __align ; +}; +# 76 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_mutex_t_11 pthread_mutex_t; +# 106 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_mutexattr_t_12 { + char __size[4] ; + int __align ; +}; +# 106 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_mutexattr_t_12 pthread_mutexattr_t; +# 115 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +struct __anonstruct___data_14 { + int __lock ; + unsigned int __futex ; + unsigned long long __total_seq ; + unsigned long long __wakeup_seq ; + unsigned long long __woken_seq ; + void *__mutex ; + unsigned int __nwaiters ; + unsigned int __broadcast_seq ; +}; +# 115 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_cond_t_13 { + struct __anonstruct___data_14 __data ; + char __size[48] ; + long long __align ; +}; +# 115 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_cond_t_13 pthread_cond_t; +# 132 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_condattr_t_15 { + char __size[4] ; + int __align ; +}; +# 132 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_condattr_t_15 pthread_condattr_t; +# 140 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef unsigned int pthread_key_t; +# 144 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef int pthread_once_t; +# 150 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +struct __anonstruct___data_17 { + int __lock ; + unsigned int __nr_readers ; + unsigned int __readers_wakeup ; + unsigned int __writer_wakeup ; + unsigned int __nr_readers_queued ; + unsigned int __nr_writers_queued ; + int __writer ; + int __shared ; + unsigned long __pad1 ; + unsigned long __pad2 ; + unsigned int __flags ; +}; +# 150 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_rwlock_t_16 { + struct __anonstruct___data_17 __data ; + char __size[56] ; + long __align ; +}; +# 150 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_rwlock_t_16 pthread_rwlock_t; +# 191 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_rwlockattr_t_18 { + char __size[8] ; + long __align ; +}; +# 191 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_rwlockattr_t_18 pthread_rwlockattr_t; +# 201 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef int volatile pthread_spinlock_t; +# 206 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_barrier_t_19 { + char __size[32] ; + long __align ; +}; +# 206 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_barrier_t_19 pthread_barrier_t; +# 212 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +union __anonunion_pthread_barrierattr_t_20 { + char __size[4] ; + int __align ; +}; +# 212 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" +typedef union __anonunion_pthread_barrierattr_t_20 pthread_barrierattr_t; +# 349 "/usr/include/stdlib.h" +struct random_data { + int32_t *fptr ; + int32_t *rptr ; + int32_t *state ; + int rand_type ; + int rand_deg ; + int rand_sep ; + int32_t *end_ptr ; +}; +# 418 "/usr/include/stdlib.h" +struct drand48_data { + unsigned short __x[3] ; + unsigned short __old_x[3] ; + unsigned short __c ; + unsigned short __init ; + unsigned long long __a ; +}; +# 742 "/usr/include/stdlib.h" +typedef int (*__compar_fn_t)(void const * , void const * ); +# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stdarg.h" +typedef __builtin_va_list __gnuc_va_list; +# 102 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stdarg.h" +typedef __gnuc_va_list va_list; +# 28 "/usr/include/xlocale.h" +struct __locale_data; +# 28 "/usr/include/xlocale.h" +struct __locale_struct { + struct __locale_data *__locales[13] ; + unsigned short const *__ctype_b ; + int const *__ctype_tolower ; + int const *__ctype_toupper ; + char const *__names[13] ; +}; +# 28 "/usr/include/xlocale.h" +typedef struct __locale_struct *__locale_t; +# 43 "/usr/include/xlocale.h" +typedef __locale_t locale_t; +# 78 "/usr/include/gpg-error.h" +enum __anonenum_gpg_err_source_t_21 { + GPG_ERR_SOURCE_UNKNOWN = 0, + GPG_ERR_SOURCE_GCRYPT = 1, + GPG_ERR_SOURCE_GPG = 2, + GPG_ERR_SOURCE_GPGSM = 3, + GPG_ERR_SOURCE_GPGAGENT = 4, + GPG_ERR_SOURCE_PINENTRY = 5, + GPG_ERR_SOURCE_SCD = 6, + GPG_ERR_SOURCE_GPGME = 7, + GPG_ERR_SOURCE_KEYBOX = 8, + GPG_ERR_SOURCE_KSBA = 9, + GPG_ERR_SOURCE_DIRMNGR = 10, + GPG_ERR_SOURCE_GSTI = 11, + GPG_ERR_SOURCE_GPA = 12, + GPG_ERR_SOURCE_KLEO = 13, + GPG_ERR_SOURCE_G13 = 14, + GPG_ERR_SOURCE_ANY = 31, + GPG_ERR_SOURCE_USER_1 = 32, + GPG_ERR_SOURCE_USER_2 = 33, + GPG_ERR_SOURCE_USER_3 = 34, + GPG_ERR_SOURCE_USER_4 = 35, + GPG_ERR_SOURCE_DIM = 128 +} ; +# 78 "/usr/include/gpg-error.h" +typedef enum __anonenum_gpg_err_source_t_21 gpg_err_source_t; +# 110 "/usr/include/gpg-error.h" +enum __anonenum_gpg_err_code_t_22 { + GPG_ERR_NO_ERROR = 0, + GPG_ERR_GENERAL = 1, + GPG_ERR_UNKNOWN_PACKET = 2, + GPG_ERR_UNKNOWN_VERSION = 3, + GPG_ERR_PUBKEY_ALGO = 4, + GPG_ERR_DIGEST_ALGO = 5, + GPG_ERR_BAD_PUBKEY = 6, + GPG_ERR_BAD_SECKEY = 7, + GPG_ERR_BAD_SIGNATURE = 8, + GPG_ERR_NO_PUBKEY = 9, + GPG_ERR_CHECKSUM = 10, + GPG_ERR_BAD_PASSPHRASE = 11, + GPG_ERR_CIPHER_ALGO = 12, + GPG_ERR_KEYRING_OPEN = 13, + GPG_ERR_INV_PACKET = 14, + GPG_ERR_INV_ARMOR = 15, + GPG_ERR_NO_USER_ID = 16, + GPG_ERR_NO_SECKEY = 17, + GPG_ERR_WRONG_SECKEY = 18, + GPG_ERR_BAD_KEY = 19, + GPG_ERR_COMPR_ALGO = 20, + GPG_ERR_NO_PRIME = 21, + GPG_ERR_NO_ENCODING_METHOD = 22, + GPG_ERR_NO_ENCRYPTION_SCHEME = 23, + GPG_ERR_NO_SIGNATURE_SCHEME = 24, + GPG_ERR_INV_ATTR = 25, + GPG_ERR_NO_VALUE = 26, + GPG_ERR_NOT_FOUND = 27, + GPG_ERR_VALUE_NOT_FOUND = 28, + GPG_ERR_SYNTAX = 29, + GPG_ERR_BAD_MPI = 30, + GPG_ERR_INV_PASSPHRASE = 31, + GPG_ERR_SIG_CLASS = 32, + GPG_ERR_RESOURCE_LIMIT = 33, + GPG_ERR_INV_KEYRING = 34, + GPG_ERR_TRUSTDB = 35, + GPG_ERR_BAD_CERT = 36, + GPG_ERR_INV_USER_ID = 37, + GPG_ERR_UNEXPECTED = 38, + GPG_ERR_TIME_CONFLICT = 39, + GPG_ERR_KEYSERVER = 40, + GPG_ERR_WRONG_PUBKEY_ALGO = 41, + GPG_ERR_TRIBUTE_TO_D_A = 42, + GPG_ERR_WEAK_KEY = 43, + GPG_ERR_INV_KEYLEN = 44, + GPG_ERR_INV_ARG = 45, + GPG_ERR_BAD_URI = 46, + GPG_ERR_INV_URI = 47, + GPG_ERR_NETWORK = 48, + GPG_ERR_UNKNOWN_HOST = 49, + GPG_ERR_SELFTEST_FAILED = 50, + GPG_ERR_NOT_ENCRYPTED = 51, + GPG_ERR_NOT_PROCESSED = 52, + GPG_ERR_UNUSABLE_PUBKEY = 53, + GPG_ERR_UNUSABLE_SECKEY = 54, + GPG_ERR_INV_VALUE = 55, + GPG_ERR_BAD_CERT_CHAIN = 56, + GPG_ERR_MISSING_CERT = 57, + GPG_ERR_NO_DATA = 58, + GPG_ERR_BUG = 59, + GPG_ERR_NOT_SUPPORTED = 60, + GPG_ERR_INV_OP = 61, + GPG_ERR_TIMEOUT = 62, + GPG_ERR_INTERNAL = 63, + GPG_ERR_EOF_GCRYPT = 64, + GPG_ERR_INV_OBJ = 65, + GPG_ERR_TOO_SHORT = 66, + GPG_ERR_TOO_LARGE = 67, + GPG_ERR_NO_OBJ = 68, + GPG_ERR_NOT_IMPLEMENTED = 69, + GPG_ERR_CONFLICT = 70, + GPG_ERR_INV_CIPHER_MODE = 71, + GPG_ERR_INV_FLAG = 72, + GPG_ERR_INV_HANDLE = 73, + GPG_ERR_TRUNCATED = 74, + GPG_ERR_INCOMPLETE_LINE = 75, + GPG_ERR_INV_RESPONSE = 76, + GPG_ERR_NO_AGENT = 77, + GPG_ERR_AGENT = 78, + GPG_ERR_INV_DATA = 79, + GPG_ERR_ASSUAN_SERVER_FAULT = 80, + GPG_ERR_ASSUAN = 81, + GPG_ERR_INV_SESSION_KEY = 82, + GPG_ERR_INV_SEXP = 83, + GPG_ERR_UNSUPPORTED_ALGORITHM = 84, + GPG_ERR_NO_PIN_ENTRY = 85, + GPG_ERR_PIN_ENTRY = 86, + GPG_ERR_BAD_PIN = 87, + GPG_ERR_INV_NAME = 88, + GPG_ERR_BAD_DATA = 89, + GPG_ERR_INV_PARAMETER = 90, + GPG_ERR_WRONG_CARD = 91, + GPG_ERR_NO_DIRMNGR = 92, + GPG_ERR_DIRMNGR = 93, + GPG_ERR_CERT_REVOKED = 94, + GPG_ERR_NO_CRL_KNOWN = 95, + GPG_ERR_CRL_TOO_OLD = 96, + GPG_ERR_LINE_TOO_LONG = 97, + GPG_ERR_NOT_TRUSTED = 98, + GPG_ERR_CANCELED = 99, + GPG_ERR_BAD_CA_CERT = 100, + GPG_ERR_CERT_EXPIRED = 101, + GPG_ERR_CERT_TOO_YOUNG = 102, + GPG_ERR_UNSUPPORTED_CERT = 103, + GPG_ERR_UNKNOWN_SEXP = 104, + GPG_ERR_UNSUPPORTED_PROTECTION = 105, + GPG_ERR_CORRUPTED_PROTECTION = 106, + GPG_ERR_AMBIGUOUS_NAME = 107, + GPG_ERR_CARD = 108, + GPG_ERR_CARD_RESET = 109, + GPG_ERR_CARD_REMOVED = 110, + GPG_ERR_INV_CARD = 111, + GPG_ERR_CARD_NOT_PRESENT = 112, + GPG_ERR_NO_PKCS15_APP = 113, + GPG_ERR_NOT_CONFIRMED = 114, + GPG_ERR_CONFIGURATION = 115, + GPG_ERR_NO_POLICY_MATCH = 116, + GPG_ERR_INV_INDEX = 117, + GPG_ERR_INV_ID = 118, + GPG_ERR_NO_SCDAEMON = 119, + GPG_ERR_SCDAEMON = 120, + GPG_ERR_UNSUPPORTED_PROTOCOL = 121, + GPG_ERR_BAD_PIN_METHOD = 122, + GPG_ERR_CARD_NOT_INITIALIZED = 123, + GPG_ERR_UNSUPPORTED_OPERATION = 124, + GPG_ERR_WRONG_KEY_USAGE = 125, + GPG_ERR_NOTHING_FOUND = 126, + GPG_ERR_WRONG_BLOB_TYPE = 127, + GPG_ERR_MISSING_VALUE = 128, + GPG_ERR_HARDWARE = 129, + GPG_ERR_PIN_BLOCKED = 130, + GPG_ERR_USE_CONDITIONS = 131, + GPG_ERR_PIN_NOT_SYNCED = 132, + GPG_ERR_INV_CRL = 133, + GPG_ERR_BAD_BER = 134, + GPG_ERR_INV_BER = 135, + GPG_ERR_ELEMENT_NOT_FOUND = 136, + GPG_ERR_IDENTIFIER_NOT_FOUND = 137, + GPG_ERR_INV_TAG = 138, + GPG_ERR_INV_LENGTH = 139, + GPG_ERR_INV_KEYINFO = 140, + GPG_ERR_UNEXPECTED_TAG = 141, + GPG_ERR_NOT_DER_ENCODED = 142, + GPG_ERR_NO_CMS_OBJ = 143, + GPG_ERR_INV_CMS_OBJ = 144, + GPG_ERR_UNKNOWN_CMS_OBJ = 145, + GPG_ERR_UNSUPPORTED_CMS_OBJ = 146, + GPG_ERR_UNSUPPORTED_ENCODING = 147, + GPG_ERR_UNSUPPORTED_CMS_VERSION = 148, + GPG_ERR_UNKNOWN_ALGORITHM = 149, + GPG_ERR_INV_ENGINE = 150, + GPG_ERR_PUBKEY_NOT_TRUSTED = 151, + GPG_ERR_DECRYPT_FAILED = 152, + GPG_ERR_KEY_EXPIRED = 153, + GPG_ERR_SIG_EXPIRED = 154, + GPG_ERR_ENCODING_PROBLEM = 155, + GPG_ERR_INV_STATE = 156, + GPG_ERR_DUP_VALUE = 157, + GPG_ERR_MISSING_ACTION = 158, + GPG_ERR_MODULE_NOT_FOUND = 159, + GPG_ERR_INV_OID_STRING = 160, + GPG_ERR_INV_TIME = 161, + GPG_ERR_INV_CRL_OBJ = 162, + GPG_ERR_UNSUPPORTED_CRL_VERSION = 163, + GPG_ERR_INV_CERT_OBJ = 164, + GPG_ERR_UNKNOWN_NAME = 165, + GPG_ERR_LOCALE_PROBLEM = 166, + GPG_ERR_NOT_LOCKED = 167, + GPG_ERR_PROTOCOL_VIOLATION = 168, + GPG_ERR_INV_MAC = 169, + GPG_ERR_INV_REQUEST = 170, + GPG_ERR_UNKNOWN_EXTN = 171, + GPG_ERR_UNKNOWN_CRIT_EXTN = 172, + GPG_ERR_LOCKED = 173, + GPG_ERR_UNKNOWN_OPTION = 174, + GPG_ERR_UNKNOWN_COMMAND = 175, + GPG_ERR_NOT_OPERATIONAL = 176, + GPG_ERR_NO_PASSPHRASE = 177, + GPG_ERR_NO_PIN = 178, + GPG_ERR_NOT_ENABLED = 179, + GPG_ERR_NO_ENGINE = 180, + GPG_ERR_MISSING_KEY = 181, + GPG_ERR_TOO_MANY = 182, + GPG_ERR_LIMIT_REACHED = 183, + GPG_ERR_NOT_INITIALIZED = 184, + GPG_ERR_MISSING_ISSUER_CERT = 185, + GPG_ERR_FULLY_CANCELED = 198, + GPG_ERR_UNFINISHED = 199, + GPG_ERR_BUFFER_TOO_SHORT = 200, + GPG_ERR_SEXP_INV_LEN_SPEC = 201, + GPG_ERR_SEXP_STRING_TOO_LONG = 202, + GPG_ERR_SEXP_UNMATCHED_PAREN = 203, + GPG_ERR_SEXP_NOT_CANONICAL = 204, + GPG_ERR_SEXP_BAD_CHARACTER = 205, + GPG_ERR_SEXP_BAD_QUOTATION = 206, + GPG_ERR_SEXP_ZERO_PREFIX = 207, + GPG_ERR_SEXP_NESTED_DH = 208, + GPG_ERR_SEXP_UNMATCHED_DH = 209, + GPG_ERR_SEXP_UNEXPECTED_PUNC = 210, + GPG_ERR_SEXP_BAD_HEX_CHAR = 211, + GPG_ERR_SEXP_ODD_HEX_NUMBERS = 212, + GPG_ERR_SEXP_BAD_OCT_CHAR = 213, + GPG_ERR_ASS_GENERAL = 257, + GPG_ERR_ASS_ACCEPT_FAILED = 258, + GPG_ERR_ASS_CONNECT_FAILED = 259, + GPG_ERR_ASS_INV_RESPONSE = 260, + GPG_ERR_ASS_INV_VALUE = 261, + GPG_ERR_ASS_INCOMPLETE_LINE = 262, + GPG_ERR_ASS_LINE_TOO_LONG = 263, + GPG_ERR_ASS_NESTED_COMMANDS = 264, + GPG_ERR_ASS_NO_DATA_CB = 265, + GPG_ERR_ASS_NO_INQUIRE_CB = 266, + GPG_ERR_ASS_NOT_A_SERVER = 267, + GPG_ERR_ASS_NOT_A_CLIENT = 268, + GPG_ERR_ASS_SERVER_START = 269, + GPG_ERR_ASS_READ_ERROR = 270, + GPG_ERR_ASS_WRITE_ERROR = 271, + GPG_ERR_ASS_TOO_MUCH_DATA = 273, + GPG_ERR_ASS_UNEXPECTED_CMD = 274, + GPG_ERR_ASS_UNKNOWN_CMD = 275, + GPG_ERR_ASS_SYNTAX = 276, + GPG_ERR_ASS_CANCELED = 277, + GPG_ERR_ASS_NO_INPUT = 278, + GPG_ERR_ASS_NO_OUTPUT = 279, + GPG_ERR_ASS_PARAMETER = 280, + GPG_ERR_ASS_UNKNOWN_INQUIRE = 281, + GPG_ERR_USER_1 = 1024, + GPG_ERR_USER_2 = 1025, + GPG_ERR_USER_3 = 1026, + GPG_ERR_USER_4 = 1027, + GPG_ERR_USER_5 = 1028, + GPG_ERR_USER_6 = 1029, + GPG_ERR_USER_7 = 1030, + GPG_ERR_USER_8 = 1031, + GPG_ERR_USER_9 = 1032, + GPG_ERR_USER_10 = 1033, + GPG_ERR_USER_11 = 1034, + GPG_ERR_USER_12 = 1035, + GPG_ERR_USER_13 = 1036, + GPG_ERR_USER_14 = 1037, + GPG_ERR_USER_15 = 1038, + GPG_ERR_USER_16 = 1039, + GPG_ERR_MISSING_ERRNO = 16381, + GPG_ERR_UNKNOWN_ERRNO = 16382, + GPG_ERR_EOF = 16383, + GPG_ERR_E2BIG = 32768, + GPG_ERR_EACCES = 32769, + GPG_ERR_EADDRINUSE = 32770, + GPG_ERR_EADDRNOTAVAIL = 32771, + GPG_ERR_EADV = 32772, + GPG_ERR_EAFNOSUPPORT = 32773, + GPG_ERR_EAGAIN = 32774, + GPG_ERR_EALREADY = 32775, + GPG_ERR_EAUTH = 32776, + GPG_ERR_EBACKGROUND = 32777, + GPG_ERR_EBADE = 32778, + GPG_ERR_EBADF = 32779, + GPG_ERR_EBADFD = 32780, + GPG_ERR_EBADMSG = 32781, + GPG_ERR_EBADR = 32782, + GPG_ERR_EBADRPC = 32783, + GPG_ERR_EBADRQC = 32784, + GPG_ERR_EBADSLT = 32785, + GPG_ERR_EBFONT = 32786, + GPG_ERR_EBUSY = 32787, + GPG_ERR_ECANCELED = 32788, + GPG_ERR_ECHILD = 32789, + GPG_ERR_ECHRNG = 32790, + GPG_ERR_ECOMM = 32791, + GPG_ERR_ECONNABORTED = 32792, + GPG_ERR_ECONNREFUSED = 32793, + GPG_ERR_ECONNRESET = 32794, + GPG_ERR_ED = 32795, + GPG_ERR_EDEADLK = 32796, + GPG_ERR_EDEADLOCK = 32797, + GPG_ERR_EDESTADDRREQ = 32798, + GPG_ERR_EDIED = 32799, + GPG_ERR_EDOM = 32800, + GPG_ERR_EDOTDOT = 32801, + GPG_ERR_EDQUOT = 32802, + GPG_ERR_EEXIST = 32803, + GPG_ERR_EFAULT = 32804, + GPG_ERR_EFBIG = 32805, + GPG_ERR_EFTYPE = 32806, + GPG_ERR_EGRATUITOUS = 32807, + GPG_ERR_EGREGIOUS = 32808, + GPG_ERR_EHOSTDOWN = 32809, + GPG_ERR_EHOSTUNREACH = 32810, + GPG_ERR_EIDRM = 32811, + GPG_ERR_EIEIO = 32812, + GPG_ERR_EILSEQ = 32813, + GPG_ERR_EINPROGRESS = 32814, + GPG_ERR_EINTR = 32815, + GPG_ERR_EINVAL = 32816, + GPG_ERR_EIO = 32817, + GPG_ERR_EISCONN = 32818, + GPG_ERR_EISDIR = 32819, + GPG_ERR_EISNAM = 32820, + GPG_ERR_EL2HLT = 32821, + GPG_ERR_EL2NSYNC = 32822, + GPG_ERR_EL3HLT = 32823, + GPG_ERR_EL3RST = 32824, + GPG_ERR_ELIBACC = 32825, + GPG_ERR_ELIBBAD = 32826, + GPG_ERR_ELIBEXEC = 32827, + GPG_ERR_ELIBMAX = 32828, + GPG_ERR_ELIBSCN = 32829, + GPG_ERR_ELNRNG = 32830, + GPG_ERR_ELOOP = 32831, + GPG_ERR_EMEDIUMTYPE = 32832, + GPG_ERR_EMFILE = 32833, + GPG_ERR_EMLINK = 32834, + GPG_ERR_EMSGSIZE = 32835, + GPG_ERR_EMULTIHOP = 32836, + GPG_ERR_ENAMETOOLONG = 32837, + GPG_ERR_ENAVAIL = 32838, + GPG_ERR_ENEEDAUTH = 32839, + GPG_ERR_ENETDOWN = 32840, + GPG_ERR_ENETRESET = 32841, + GPG_ERR_ENETUNREACH = 32842, + GPG_ERR_ENFILE = 32843, + GPG_ERR_ENOANO = 32844, + GPG_ERR_ENOBUFS = 32845, + GPG_ERR_ENOCSI = 32846, + GPG_ERR_ENODATA = 32847, + GPG_ERR_ENODEV = 32848, + GPG_ERR_ENOENT = 32849, + GPG_ERR_ENOEXEC = 32850, + GPG_ERR_ENOLCK = 32851, + GPG_ERR_ENOLINK = 32852, + GPG_ERR_ENOMEDIUM = 32853, + GPG_ERR_ENOMEM = 32854, + GPG_ERR_ENOMSG = 32855, + GPG_ERR_ENONET = 32856, + GPG_ERR_ENOPKG = 32857, + GPG_ERR_ENOPROTOOPT = 32858, + GPG_ERR_ENOSPC = 32859, + GPG_ERR_ENOSR = 32860, + GPG_ERR_ENOSTR = 32861, + GPG_ERR_ENOSYS = 32862, + GPG_ERR_ENOTBLK = 32863, + GPG_ERR_ENOTCONN = 32864, + GPG_ERR_ENOTDIR = 32865, + GPG_ERR_ENOTEMPTY = 32866, + GPG_ERR_ENOTNAM = 32867, + GPG_ERR_ENOTSOCK = 32868, + GPG_ERR_ENOTSUP = 32869, + GPG_ERR_ENOTTY = 32870, + GPG_ERR_ENOTUNIQ = 32871, + GPG_ERR_ENXIO = 32872, + GPG_ERR_EOPNOTSUPP = 32873, + GPG_ERR_EOVERFLOW = 32874, + GPG_ERR_EPERM = 32875, + GPG_ERR_EPFNOSUPPORT = 32876, + GPG_ERR_EPIPE = 32877, + GPG_ERR_EPROCLIM = 32878, + GPG_ERR_EPROCUNAVAIL = 32879, + GPG_ERR_EPROGMISMATCH = 32880, + GPG_ERR_EPROGUNAVAIL = 32881, + GPG_ERR_EPROTO = 32882, + GPG_ERR_EPROTONOSUPPORT = 32883, + GPG_ERR_EPROTOTYPE = 32884, + GPG_ERR_ERANGE = 32885, + GPG_ERR_EREMCHG = 32886, + GPG_ERR_EREMOTE = 32887, + GPG_ERR_EREMOTEIO = 32888, + GPG_ERR_ERESTART = 32889, + GPG_ERR_EROFS = 32890, + GPG_ERR_ERPCMISMATCH = 32891, + GPG_ERR_ESHUTDOWN = 32892, + GPG_ERR_ESOCKTNOSUPPORT = 32893, + GPG_ERR_ESPIPE = 32894, + GPG_ERR_ESRCH = 32895, + GPG_ERR_ESRMNT = 32896, + GPG_ERR_ESTALE = 32897, + GPG_ERR_ESTRPIPE = 32898, + GPG_ERR_ETIME = 32899, + GPG_ERR_ETIMEDOUT = 32900, + GPG_ERR_ETOOMANYREFS = 32901, + GPG_ERR_ETXTBSY = 32902, + GPG_ERR_EUCLEAN = 32903, + GPG_ERR_EUNATCH = 32904, + GPG_ERR_EUSERS = 32905, + GPG_ERR_EWOULDBLOCK = 32906, + GPG_ERR_EXDEV = 32907, + GPG_ERR_EXFULL = 32908, + GPG_ERR_CODE_DIM = 65536 +} ; +# 110 "/usr/include/gpg-error.h" +typedef enum __anonenum_gpg_err_code_t_22 gpg_err_code_t; +# 513 "/usr/include/gpg-error.h" +typedef unsigned int gpg_error_t; +# 44 "/usr/include/x86_64-linux-gnu/bits/uio.h" +struct iovec { + void *iov_base ; + size_t iov_len ; +}; +# 35 "/usr/include/x86_64-linux-gnu/bits/socket.h" +typedef __socklen_t socklen_t; +# 40 "/usr/include/x86_64-linux-gnu/bits/socket.h" +enum __socket_type { + SOCK_STREAM = 1, + SOCK_DGRAM = 2, + SOCK_RAW = 3, + SOCK_RDM = 4, + SOCK_SEQPACKET = 5, + SOCK_DCCP = 6, + SOCK_PACKET = 10, + SOCK_CLOEXEC = 524288, + SOCK_NONBLOCK = 2048 +} ; +# 29 "/usr/include/x86_64-linux-gnu/bits/sockaddr.h" +typedef unsigned short sa_family_t; +# 180 "/usr/include/x86_64-linux-gnu/bits/socket.h" +struct sockaddr { + sa_family_t sa_family ; + char sa_data[14] ; +}; +# 193 "/usr/include/x86_64-linux-gnu/bits/socket.h" +struct sockaddr_storage { + sa_family_t ss_family ; + unsigned long __ss_align ; + char __ss_padding[(unsigned long )128 - (unsigned long )((unsigned long )2 * (unsigned long )sizeof(unsigned long ))] ; +}; +# 202 "/usr/include/x86_64-linux-gnu/bits/socket.h" +enum __anonenum_23 { + MSG_OOB = 1, + MSG_PEEK = 2, + MSG_DONTROUTE = 4, + MSG_CTRUNC = 8, + MSG_PROXY = 16, + MSG_TRUNC = 32, + MSG_DONTWAIT = 64, + MSG_EOR = 128, + MSG_WAITALL = 256, + MSG_FIN = 512, + MSG_SYN = 1024, + MSG_CONFIRM = 2048, + MSG_RST = 4096, + MSG_ERRQUEUE = 8192, + MSG_NOSIGNAL = 16384, + MSG_MORE = 32768, + MSG_WAITFORONE = 65536, + MSG_CMSG_CLOEXEC = 1073741824 +} ; +# 253 "/usr/include/x86_64-linux-gnu/bits/socket.h" +struct msghdr { + void *msg_name ; + socklen_t msg_namelen ; + struct iovec *msg_iov ; + size_t msg_iovlen ; + void *msg_control ; + size_t msg_controllen ; + int msg_flags ; +}; +# 280 "/usr/include/x86_64-linux-gnu/bits/socket.h" +struct cmsghdr { + size_t cmsg_len ; + int cmsg_level ; + int cmsg_type ; + unsigned char __cmsg_data[] ; +}; +# 337 "/usr/include/x86_64-linux-gnu/bits/socket.h" +enum __anonenum_24 { + SCM_RIGHTS = 1 +} ; +# 417 "/usr/include/x86_64-linux-gnu/bits/socket.h" +struct linger { + int l_onoff ; + int l_linger ; +}; +# 431 "/usr/include/x86_64-linux-gnu/bits/socket.h" +struct mmsghdr; +# 45 "/usr/include/x86_64-linux-gnu/sys/socket.h" +struct osockaddr { + unsigned short sa_family ; + unsigned char sa_data[14] ; +}; +# 54 "/usr/include/x86_64-linux-gnu/sys/socket.h" +enum __anonenum_25 { + SHUT_RD = 0, + SHUT_WR = 1, + SHUT_RDWR = 2 +} ; +# 57 "/usr/include/x86_64-linux-gnu/sys/time.h" +struct timezone { + int tz_minuteswest ; + int tz_dsttime ; +}; +# 63 "/usr/include/x86_64-linux-gnu/sys/time.h" +typedef struct timezone * __restrict __timezone_ptr_t; +# 93 "/usr/include/x86_64-linux-gnu/sys/time.h" +enum __itimer_which { + ITIMER_REAL = 0, + ITIMER_VIRTUAL = 1, + ITIMER_PROF = 2 +} ; +# 109 "/usr/include/x86_64-linux-gnu/sys/time.h" +struct itimerval { + struct timeval it_interval ; + struct timeval it_value ; +}; +# 122 "/usr/include/x86_64-linux-gnu/sys/time.h" +typedef int __itimer_which_t; +# 47 "/usr/include/gcrypt.h" +typedef socklen_t gcry_socklen_t; +# 117 "/usr/include/gcrypt.h" +typedef gpg_error_t gcry_error_t; +# 118 "/usr/include/gcrypt.h" +typedef gpg_err_code_t gcry_err_code_t; +# 119 "/usr/include/gcrypt.h" +typedef gpg_err_source_t gcry_err_source_t; +# 179 "/usr/include/gcrypt.h" +enum gcry_thread_option { + _GCRY_THREAD_OPTION_DUMMY = 0 +} __attribute__((__deprecated__)) ; +# 197 "/usr/include/gcrypt.h" +struct gcry_thread_cbs { + unsigned int option ; + int (*init)(void) ; + int (*mutex_init)(void **priv ) ; + int (*mutex_destroy)(void **priv ) ; + int (*mutex_lock)(void **priv ) ; + int (*mutex_unlock)(void **priv ) ; + ssize_t (*read)(int fd , void *buf , size_t nbytes ) ; + ssize_t (*write)(int fd , void const *buf , size_t nbytes ) ; + ssize_t (*select)(int nfd , fd_set *rset , fd_set *wset , fd_set *eset , struct timeval *timeout ) ; + ssize_t (*waitpid)(pid_t pid , int *status , int options ) ; + int (*accept)(int s , struct sockaddr *addr , gcry_socklen_t *length_ptr ) ; + int (*connect)(int s , struct sockaddr *addr , gcry_socklen_t length ) ; + int (*sendmsg)(int s , struct msghdr const *msg , int flags ) ; + int (*recvmsg)(int s , struct msghdr *msg , int flags ) ; +}; +# 343 "/usr/include/gcrypt.h" +struct gcry_mpi; +# 343 "/usr/include/gcrypt.h" +struct gcry_mpi; +# 344 "/usr/include/gcrypt.h" +typedef struct gcry_mpi *gcry_mpi_t; +# 347 "/usr/include/gcrypt.h" +typedef struct gcry_mpi * __attribute__((__deprecated__)) GCRY_MPI; +# 348 "/usr/include/gcrypt.h" +typedef struct gcry_mpi * __attribute__((__deprecated__)) GcryMPI; +# 359 "/usr/include/gcrypt.h" +enum gcry_ctl_cmds { + GCRYCTL_SET_KEY = 1, + GCRYCTL_SET_IV = 2, + GCRYCTL_CFB_SYNC = 3, + GCRYCTL_RESET = 4, + GCRYCTL_FINALIZE = 5, + GCRYCTL_GET_KEYLEN = 6, + GCRYCTL_GET_BLKLEN = 7, + GCRYCTL_TEST_ALGO = 8, + GCRYCTL_IS_SECURE = 9, + GCRYCTL_GET_ASNOID = 10, + GCRYCTL_ENABLE_ALGO = 11, + GCRYCTL_DISABLE_ALGO = 12, + GCRYCTL_DUMP_RANDOM_STATS = 13, + GCRYCTL_DUMP_SECMEM_STATS = 14, + GCRYCTL_GET_ALGO_NPKEY = 15, + GCRYCTL_GET_ALGO_NSKEY = 16, + GCRYCTL_GET_ALGO_NSIGN = 17, + GCRYCTL_GET_ALGO_NENCR = 18, + GCRYCTL_SET_VERBOSITY = 19, + GCRYCTL_SET_DEBUG_FLAGS = 20, + GCRYCTL_CLEAR_DEBUG_FLAGS = 21, + GCRYCTL_USE_SECURE_RNDPOOL = 22, + GCRYCTL_DUMP_MEMORY_STATS = 23, + GCRYCTL_INIT_SECMEM = 24, + GCRYCTL_TERM_SECMEM = 25, + GCRYCTL_DISABLE_SECMEM_WARN = 27, + GCRYCTL_SUSPEND_SECMEM_WARN = 28, + GCRYCTL_RESUME_SECMEM_WARN = 29, + GCRYCTL_DROP_PRIVS = 30, + GCRYCTL_ENABLE_M_GUARD = 31, + GCRYCTL_START_DUMP = 32, + GCRYCTL_STOP_DUMP = 33, + GCRYCTL_GET_ALGO_USAGE = 34, + GCRYCTL_IS_ALGO_ENABLED = 35, + GCRYCTL_DISABLE_INTERNAL_LOCKING = 36, + GCRYCTL_DISABLE_SECMEM = 37, + GCRYCTL_INITIALIZATION_FINISHED = 38, + GCRYCTL_INITIALIZATION_FINISHED_P = 39, + GCRYCTL_ANY_INITIALIZATION_P = 40, + GCRYCTL_SET_CBC_CTS = 41, + GCRYCTL_SET_CBC_MAC = 42, + GCRYCTL_SET_CTR = 43, + GCRYCTL_ENABLE_QUICK_RANDOM = 44, + GCRYCTL_SET_RANDOM_SEED_FILE = 45, + GCRYCTL_UPDATE_RANDOM_SEED_FILE = 46, + GCRYCTL_SET_THREAD_CBS = 47, + GCRYCTL_FAST_POLL = 48, + GCRYCTL_SET_RANDOM_DAEMON_SOCKET = 49, + GCRYCTL_USE_RANDOM_DAEMON = 50, + GCRYCTL_FAKED_RANDOM_P = 51, + GCRYCTL_SET_RNDEGD_SOCKET = 52, + GCRYCTL_PRINT_CONFIG = 53, + GCRYCTL_OPERATIONAL_P = 54, + GCRYCTL_FIPS_MODE_P = 55, + GCRYCTL_FORCE_FIPS_MODE = 56, + GCRYCTL_SELFTEST = 57, + GCRYCTL_DISABLE_HWF = 63 +} ; +# 429 "/usr/include/gcrypt.h" +struct gcry_sexp; +# 429 "/usr/include/gcrypt.h" +struct gcry_sexp; +# 430 "/usr/include/gcrypt.h" +typedef struct gcry_sexp *gcry_sexp_t; +# 433 "/usr/include/gcrypt.h" +typedef struct gcry_sexp * __attribute__((__deprecated__)) GCRY_SEXP; +# 434 "/usr/include/gcrypt.h" +typedef struct gcry_sexp * __attribute__((__deprecated__)) GcrySexp; +# 438 "/usr/include/gcrypt.h" +enum gcry_sexp_format { + GCRYSEXP_FMT_DEFAULT = 0, + GCRYSEXP_FMT_CANON = 1, + GCRYSEXP_FMT_BASE64 = 2, + GCRYSEXP_FMT_ADVANCED = 3 +} ; +# 561 "/usr/include/gcrypt.h" +enum gcry_mpi_format { + GCRYMPI_FMT_NONE = 0, + GCRYMPI_FMT_STD = 1, + GCRYMPI_FMT_PGP = 2, + GCRYMPI_FMT_SSH = 3, + GCRYMPI_FMT_HEX = 4, + GCRYMPI_FMT_USG = 5 +} ; +# 572 "/usr/include/gcrypt.h" +enum gcry_mpi_flag { + GCRYMPI_FLAG_SECURE = 1, + GCRYMPI_FLAG_OPAQUE = 2 +} ; +# 801 "/usr/include/gcrypt.h" +struct gcry_cipher_handle; +# 801 "/usr/include/gcrypt.h" +struct gcry_cipher_handle; +# 802 "/usr/include/gcrypt.h" +typedef struct gcry_cipher_handle *gcry_cipher_hd_t; +# 805 "/usr/include/gcrypt.h" +typedef struct gcry_cipher_handle * __attribute__((__deprecated__)) GCRY_CIPHER_HD; +# 806 "/usr/include/gcrypt.h" +typedef struct gcry_cipher_handle * __attribute__((__deprecated__)) GcryCipherHd; +# 811 "/usr/include/gcrypt.h" +enum gcry_cipher_algos { + GCRY_CIPHER_NONE = 0, + GCRY_CIPHER_IDEA = 1, + GCRY_CIPHER_3DES = 2, + GCRY_CIPHER_CAST5 = 3, + GCRY_CIPHER_BLOWFISH = 4, + GCRY_CIPHER_SAFER_SK128 = 5, + GCRY_CIPHER_DES_SK = 6, + GCRY_CIPHER_AES = 7, + GCRY_CIPHER_AES192 = 8, + GCRY_CIPHER_AES256 = 9, + GCRY_CIPHER_TWOFISH = 10, + GCRY_CIPHER_ARCFOUR = 301, + GCRY_CIPHER_DES = 302, + GCRY_CIPHER_TWOFISH128 = 303, + GCRY_CIPHER_SERPENT128 = 304, + GCRY_CIPHER_SERPENT192 = 305, + GCRY_CIPHER_SERPENT256 = 306, + GCRY_CIPHER_RFC2268_40 = 307, + GCRY_CIPHER_RFC2268_128 = 308, + GCRY_CIPHER_SEED = 309, + GCRY_CIPHER_CAMELLIA128 = 310, + GCRY_CIPHER_CAMELLIA192 = 311, + GCRY_CIPHER_CAMELLIA256 = 312 +} ; +# 849 "/usr/include/gcrypt.h" +enum gcry_cipher_modes { + GCRY_CIPHER_MODE_NONE = 0, + GCRY_CIPHER_MODE_ECB = 1, + GCRY_CIPHER_MODE_CFB = 2, + GCRY_CIPHER_MODE_CBC = 3, + GCRY_CIPHER_MODE_STREAM = 4, + GCRY_CIPHER_MODE_OFB = 5, + GCRY_CIPHER_MODE_CTR = 6, + GCRY_CIPHER_MODE_AESWRAP = 7 +} ; +# 862 "/usr/include/gcrypt.h" +enum gcry_cipher_flags { + GCRY_CIPHER_SECURE = 1, + GCRY_CIPHER_ENABLE_SYNC = 2, + GCRY_CIPHER_CBC_CTS = 4, + GCRY_CIPHER_CBC_MAC = 8 +} ; +# 970 "/usr/include/gcrypt.h" +enum gcry_pk_algos { + GCRY_PK_RSA = 1, + GCRY_PK_RSA_E = 2, + GCRY_PK_RSA_S = 3, + GCRY_PK_ELG_E = 16, + GCRY_PK_DSA = 17, + GCRY_PK_ELG = 20, + GCRY_PK_ECDSA = 301, + GCRY_PK_ECDH = 302 +} ; +# 1070 "/usr/include/gcrypt.h" +enum gcry_md_algos { + GCRY_MD_NONE = 0, + GCRY_MD_MD5 = 1, + GCRY_MD_SHA1 = 2, + GCRY_MD_RMD160 = 3, + GCRY_MD_MD2 = 5, + GCRY_MD_TIGER = 6, + GCRY_MD_HAVAL = 7, + GCRY_MD_SHA256 = 8, + GCRY_MD_SHA384 = 9, + GCRY_MD_SHA512 = 10, + GCRY_MD_SHA224 = 11, + GCRY_MD_MD4 = 301, + GCRY_MD_CRC32 = 302, + GCRY_MD_CRC32_RFC1510 = 303, + GCRY_MD_CRC24_RFC2440 = 304, + GCRY_MD_WHIRLPOOL = 305, + GCRY_MD_TIGER1 = 306, + GCRY_MD_TIGER2 = 307 +} ; +# 1093 "/usr/include/gcrypt.h" +enum gcry_md_flags { + GCRY_MD_FLAG_SECURE = 1, + GCRY_MD_FLAG_HMAC = 2 +} ; +# 1100 "/usr/include/gcrypt.h" +struct gcry_md_context; +# 1100 "/usr/include/gcrypt.h" +struct gcry_md_context; +# 1105 "/usr/include/gcrypt.h" +struct gcry_md_handle { + struct gcry_md_context *ctx ; + int bufpos ; + int bufsize ; + unsigned char buf[1] ; +}; +# 1105 "/usr/include/gcrypt.h" +typedef struct gcry_md_handle *gcry_md_hd_t; +# 1118 "/usr/include/gcrypt.h" +typedef struct gcry_md_handle * __attribute__((__deprecated__)) GCRY_MD_HD; +# 1119 "/usr/include/gcrypt.h" +typedef struct gcry_md_handle * __attribute__((__deprecated__)) GcryMDHd; +# 1256 "/usr/include/gcrypt.h" +enum gcry_ac_id { + GCRY_AC_RSA = 1, + GCRY_AC_DSA = 17, + GCRY_AC_ELG = 20, + GCRY_AC_ELG_E = 16 +} ; +# 1256 "/usr/include/gcrypt.h" +typedef enum gcry_ac_id __attribute__((__deprecated__)) gcry_ac_id_t; +# 1266 "/usr/include/gcrypt.h" +enum gcry_ac_key_type { + GCRY_AC_KEY_SECRET = 0, + GCRY_AC_KEY_PUBLIC = 1 +} ; +# 1266 "/usr/include/gcrypt.h" +typedef enum gcry_ac_key_type __attribute__((__deprecated__)) gcry_ac_key_type_t; +# 1274 "/usr/include/gcrypt.h" +enum gcry_ac_em { + GCRY_AC_EME_PKCS_V1_5 = 0, + GCRY_AC_EMSA_PKCS_V1_5 = 1 +} ; +# 1274 "/usr/include/gcrypt.h" +typedef enum gcry_ac_em __attribute__((__deprecated__)) gcry_ac_em_t; +# 1282 "/usr/include/gcrypt.h" +enum gcry_ac_scheme { + GCRY_AC_ES_PKCS_V1_5 = 0, + GCRY_AC_SSA_PKCS_V1_5 = 1 +} ; +# 1282 "/usr/include/gcrypt.h" +typedef enum gcry_ac_scheme __attribute__((__deprecated__)) gcry_ac_scheme_t; +# 1295 "/usr/include/gcrypt.h" +struct gcry_ac_data; +# 1295 "/usr/include/gcrypt.h" +typedef struct gcry_ac_data * __attribute__((__deprecated__)) gcry_ac_data_t; +# 1299 "/usr/include/gcrypt.h" +struct gcry_ac_key; +# 1299 "/usr/include/gcrypt.h" +typedef struct gcry_ac_key * __attribute__((__deprecated__)) gcry_ac_key_t; +# 1303 "/usr/include/gcrypt.h" +struct gcry_ac_key_pair; +# 1303 "/usr/include/gcrypt.h" +typedef struct gcry_ac_key_pair * __attribute__((__deprecated__)) gcry_ac_key_pair_t; +# 1307 "/usr/include/gcrypt.h" +struct gcry_ac_handle; +# 1307 "/usr/include/gcrypt.h" +typedef struct gcry_ac_handle * __attribute__((__deprecated__)) gcry_ac_handle_t; +# 1309 "/usr/include/gcrypt.h" +typedef gpg_error_t (* __attribute__((__deprecated__)) gcry_ac_data_read_cb_t)(void *opaque , + unsigned char *buffer , + size_t *buffer_n ); +# 1314 "/usr/include/gcrypt.h" +typedef gpg_error_t (* __attribute__((__deprecated__)) gcry_ac_data_write_cb_t)(void *opaque , + unsigned char *buffer , + size_t buffer_n ); +# 1319 "/usr/include/gcrypt.h" +enum __anonenum_gcry_ac_io_mode_t_26 { + GCRY_AC_IO_READABLE = 0, + GCRY_AC_IO_WRITABLE = 1 +} ; +# 1319 "/usr/include/gcrypt.h" +typedef enum __anonenum_gcry_ac_io_mode_t_26 __attribute__((__deprecated__)) gcry_ac_io_mode_t; +# 1326 "/usr/include/gcrypt.h" +enum __anonenum_gcry_ac_io_type_t_27 { + GCRY_AC_IO_STRING = 0, + GCRY_AC_IO_CALLBACK = 1 +} ; +# 1326 "/usr/include/gcrypt.h" +typedef enum __anonenum_gcry_ac_io_type_t_27 __attribute__((__deprecated__)) gcry_ac_io_type_t; +# 1333 "/usr/include/gcrypt.h" +struct __anonstruct_callback_30 { + gpg_error_t (* __attribute__((__deprecated__)) cb)(void *opaque , unsigned char *buffer , + size_t *buffer_n ) ; + void *opaque ; +}; +# 1333 "/usr/include/gcrypt.h" +struct __anonstruct_string_31 { + unsigned char *data ; + size_t data_n ; +}; +# 1333 "/usr/include/gcrypt.h" +union __anonunion_readable_29 { + struct __anonstruct_callback_30 callback ; + struct __anonstruct_string_31 string ; + void *opaque ; +}; +# 1333 "/usr/include/gcrypt.h" +struct __anonstruct_callback_33 { + gpg_error_t (* __attribute__((__deprecated__)) cb)(void *opaque , unsigned char *buffer , + size_t buffer_n ) ; + void *opaque ; +}; +# 1333 "/usr/include/gcrypt.h" +struct __anonstruct_string_34 { + unsigned char **data ; + size_t *data_n ; +}; +# 1333 "/usr/include/gcrypt.h" +union __anonunion_writable_32 { + struct __anonstruct_callback_33 callback ; + struct __anonstruct_string_34 string ; + void *opaque ; +}; +# 1333 "/usr/include/gcrypt.h" +union __anonunion_io_28 { + union __anonunion_readable_29 readable ; + union __anonunion_writable_32 writable ; +}; +# 1333 "/usr/include/gcrypt.h" +struct gcry_ac_io { + gcry_ac_io_mode_t mode __attribute__((__deprecated__)) ; + gcry_ac_io_type_t type __attribute__((__deprecated__)) ; + union __anonunion_io_28 io __attribute__((__deprecated__)) ; +}; +# 1333 "/usr/include/gcrypt.h" +typedef struct gcry_ac_io __attribute__((__deprecated__)) gcry_ac_io_t; +# 1375 "/usr/include/gcrypt.h" +struct gcry_ac_key_spec_rsa { + gcry_mpi_t e ; +}; +# 1375 "/usr/include/gcrypt.h" +typedef struct gcry_ac_key_spec_rsa __attribute__((__deprecated__)) gcry_ac_key_spec_rsa_t; +# 1382 "/usr/include/gcrypt.h" +struct gcry_ac_eme_pkcs_v1_5 { + size_t key_size ; +}; +# 1382 "/usr/include/gcrypt.h" +typedef struct gcry_ac_eme_pkcs_v1_5 __attribute__((__deprecated__)) gcry_ac_eme_pkcs_v1_5_t; +# 1387 "/usr/include/gcrypt.h" +typedef enum gcry_md_algos __attribute__((__deprecated__)) gcry_md_algo_t; +# 1391 "/usr/include/gcrypt.h" +struct gcry_ac_emsa_pkcs_v1_5 { + gcry_md_algo_t md ; + size_t em_n ; +}; +# 1391 "/usr/include/gcrypt.h" +typedef struct gcry_ac_emsa_pkcs_v1_5 __attribute__((__deprecated__)) gcry_ac_emsa_pkcs_v1_5_t; +# 1399 "/usr/include/gcrypt.h" +struct gcry_ac_ssa_pkcs_v1_5 { + gcry_md_algo_t md ; +}; +# 1399 "/usr/include/gcrypt.h" +typedef struct gcry_ac_ssa_pkcs_v1_5 __attribute__((__deprecated__)) gcry_ac_ssa_pkcs_v1_5_t; +# 1668 "/usr/include/gcrypt.h" +enum gcry_kdf_algos { + GCRY_KDF_NONE = 0, + GCRY_KDF_SIMPLE_S2K = 16, + GCRY_KDF_SALTED_S2K = 17, + GCRY_KDF_ITERSALTED_S2K = 19, + GCRY_KDF_PBKDF1 = 33, + GCRY_KDF_PBKDF2 = 34 +} ; +# 1698 "/usr/include/gcrypt.h" +enum gcry_random_level { + GCRY_WEAK_RANDOM = 0, + GCRY_STRONG_RANDOM = 1, + GCRY_VERY_STRONG_RANDOM = 2 +} ; +# 1698 "/usr/include/gcrypt.h" +typedef enum gcry_random_level gcry_random_level_t; +# 1762 "/usr/include/gcrypt.h" +typedef int (*gcry_prime_check_func_t)(void *arg , int mode , gcry_mpi_t candidate ); +# 1815 "/usr/include/gcrypt.h" +enum gcry_log_levels { + GCRY_LOG_CONT = 0, + GCRY_LOG_INFO = 10, + GCRY_LOG_WARN = 20, + GCRY_LOG_ERROR = 30, + GCRY_LOG_FATAL = 40, + GCRY_LOG_BUG = 50, + GCRY_LOG_DEBUG = 100 +} ; +# 1827 "/usr/include/gcrypt.h" +typedef void (*gcry_handler_progress_t)(void * , char const * , int , int , int ); +# 1830 "/usr/include/gcrypt.h" +typedef void *(*gcry_handler_alloc_t)(size_t n ); +# 1833 "/usr/include/gcrypt.h" +typedef int (*gcry_handler_secure_check_t)(void const * ); +# 1836 "/usr/include/gcrypt.h" +typedef void *(*gcry_handler_realloc_t)(void *p , size_t n ); +# 1839 "/usr/include/gcrypt.h" +typedef void (*gcry_handler_free_t)(void * ); +# 1842 "/usr/include/gcrypt.h" +typedef int (*gcry_handler_no_mem_t)(void * , size_t , unsigned int ); +# 1845 "/usr/include/gcrypt.h" +typedef void (*gcry_handler_error_t)(void * , int , char const * ); +# 1848 "/usr/include/gcrypt.h" +typedef void (*gcry_handler_log_t)(void * , int , char const * , va_list ); +# 43 "/usr/include/gcrypt-module.h" +struct gcry_module; +# 43 "/usr/include/gcrypt-module.h" +typedef struct gcry_module *gcry_module_t; +# 48 "/usr/include/gcrypt-module.h" +typedef gcry_err_code_t (*gcry_cipher_setkey_t)(void *c , unsigned char const *key , + unsigned int keylen ); +# 53 "/usr/include/gcrypt-module.h" +typedef void (*gcry_cipher_encrypt_t)(void *c , unsigned char *outbuf , unsigned char const *inbuf ); +# 58 "/usr/include/gcrypt-module.h" +typedef void (*gcry_cipher_decrypt_t)(void *c , unsigned char *outbuf , unsigned char const *inbuf ); +# 63 "/usr/include/gcrypt-module.h" +typedef void (*gcry_cipher_stencrypt_t)(void *c , unsigned char *outbuf , unsigned char const *inbuf , + unsigned int n ); +# 69 "/usr/include/gcrypt-module.h" +typedef void (*gcry_cipher_stdecrypt_t)(void *c , unsigned char *outbuf , unsigned char const *inbuf , + unsigned int n ); +# 74 "/usr/include/gcrypt-module.h" +struct gcry_cipher_oid_spec { + char const *oid ; + int mode ; +}; +# 74 "/usr/include/gcrypt-module.h" +typedef struct gcry_cipher_oid_spec gcry_cipher_oid_spec_t; +# 81 "/usr/include/gcrypt-module.h" +struct gcry_cipher_spec { + char const *name ; + char const **aliases ; + gcry_cipher_oid_spec_t *oids ; + size_t blocksize ; + size_t keylen ; + size_t contextsize ; + gcry_err_code_t (*setkey)(void *c , unsigned char const *key , unsigned int keylen ) ; + void (*encrypt)(void *c , unsigned char *outbuf , unsigned char const *inbuf ) ; + void (*decrypt)(void *c , unsigned char *outbuf , unsigned char const *inbuf ) ; + void (*stencrypt)(void *c , unsigned char *outbuf , unsigned char const *inbuf , + unsigned int n ) ; + void (*stdecrypt)(void *c , unsigned char *outbuf , unsigned char const *inbuf , + unsigned int n ) ; +}; +# 81 "/usr/include/gcrypt-module.h" +typedef struct gcry_cipher_spec gcry_cipher_spec_t; +# 113 "/usr/include/gcrypt-module.h" +typedef gcry_err_code_t (*gcry_pk_generate_t)(int algo , unsigned int nbits , unsigned long use_e , + gcry_mpi_t *skey , gcry_mpi_t **retfactors ); +# 120 "/usr/include/gcrypt-module.h" +typedef gcry_err_code_t (*gcry_pk_check_secret_key_t)(int algo , gcry_mpi_t *skey ); +# 124 "/usr/include/gcrypt-module.h" +typedef gcry_err_code_t (*gcry_pk_encrypt_t)(int algo , gcry_mpi_t *resarr , gcry_mpi_t data , + gcry_mpi_t *pkey , int flags ); +# 131 "/usr/include/gcrypt-module.h" +typedef gcry_err_code_t (*gcry_pk_decrypt_t)(int algo , gcry_mpi_t *result , gcry_mpi_t *data , + gcry_mpi_t *skey , int flags ); +# 138 "/usr/include/gcrypt-module.h" +typedef gcry_err_code_t (*gcry_pk_sign_t)(int algo , gcry_mpi_t *resarr , gcry_mpi_t data , + gcry_mpi_t *skey ); +# 144 "/usr/include/gcrypt-module.h" +typedef gcry_err_code_t (*gcry_pk_verify_t)(int algo , gcry_mpi_t hash , gcry_mpi_t *data , + gcry_mpi_t *pkey , int (*cmp)(void * , + gcry_mpi_t ) , + void *opaquev ); +# 152 "/usr/include/gcrypt-module.h" +typedef unsigned int (*gcry_pk_get_nbits_t)(int algo , gcry_mpi_t *pkey ); +# 155 "/usr/include/gcrypt-module.h" +struct gcry_pk_spec { + char const *name ; + char const **aliases ; + char const *elements_pkey ; + char const *elements_skey ; + char const *elements_enc ; + char const *elements_sig ; + char const *elements_grip ; + int use ; + gcry_err_code_t (*generate)(int algo , unsigned int nbits , unsigned long use_e , + gcry_mpi_t *skey , gcry_mpi_t **retfactors ) ; + gcry_err_code_t (*check_secret_key)(int algo , gcry_mpi_t *skey ) ; + gcry_err_code_t (*encrypt)(int algo , gcry_mpi_t *resarr , gcry_mpi_t data , gcry_mpi_t *pkey , + int flags ) ; + gcry_err_code_t (*decrypt)(int algo , gcry_mpi_t *result , gcry_mpi_t *data , gcry_mpi_t *skey , + int flags ) ; + gcry_err_code_t (*sign)(int algo , gcry_mpi_t *resarr , gcry_mpi_t data , gcry_mpi_t *skey ) ; + gcry_err_code_t (*verify)(int algo , gcry_mpi_t hash , gcry_mpi_t *data , gcry_mpi_t *pkey , + int (*cmp)(void * , gcry_mpi_t ) , void *opaquev ) ; + unsigned int (*get_nbits)(int algo , gcry_mpi_t *pkey ) ; +}; +# 155 "/usr/include/gcrypt-module.h" +typedef struct gcry_pk_spec gcry_pk_spec_t; +# 190 "/usr/include/gcrypt-module.h" +typedef void (*gcry_md_init_t)(void *c ); +# 193 "/usr/include/gcrypt-module.h" +typedef void (*gcry_md_write_t)(void *c , void const *buf , size_t nbytes ); +# 196 "/usr/include/gcrypt-module.h" +typedef void (*gcry_md_final_t)(void *c ); +# 199 "/usr/include/gcrypt-module.h" +typedef unsigned char *(*gcry_md_read_t)(void *c ); +# 201 "/usr/include/gcrypt-module.h" +struct gcry_md_oid_spec { + char const *oidstring ; +}; +# 201 "/usr/include/gcrypt-module.h" +typedef struct gcry_md_oid_spec gcry_md_oid_spec_t; +# 207 "/usr/include/gcrypt-module.h" +struct gcry_md_spec { + char const *name ; + unsigned char *asnoid ; + int asnlen ; + gcry_md_oid_spec_t *oids ; + int mdlen ; + void (*init)(void *c ) ; + void (*write)(void *c , void const *buf , size_t nbytes ) ; + void (*final)(void *c ) ; + unsigned char *(*read)(void *c ) ; + size_t contextsize ; +}; +# 207 "/usr/include/gcrypt-module.h" +typedef struct gcry_md_spec gcry_md_spec_t; +# 9 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef long long widest_t; +# 17 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct ProtocolDesc; +# 17 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef struct ProtocolDesc ProtocolDesc; +# 18 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct OblivInputs; +# 18 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef struct OblivInputs OblivInputs; +# 19 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct OblivBit; +# 19 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef struct OblivBit OblivBit; +# 28 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef char yao_key_t[11]; +# 30 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct ProtocolTransport; +# 30 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct __anonstruct_debug_36 { + unsigned int mulCount ; + unsigned int xorCount ; +}; +# 30 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +union __anonunion____missing_field_name_35 { + struct __anonstruct_debug_36 debug ; +}; +# 30 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct ProtocolDesc { + int partyCount ; + int thisParty ; + struct ProtocolTransport *trans ; + union __anonunion____missing_field_name_35 __annonCompField1 ; + void (*feedOblivInputs)(ProtocolDesc * , OblivInputs * , size_t , int ) ; + _Bool (*revealOblivBits)(ProtocolDesc * , widest_t * , OblivBit const * , size_t , + int ) ; + void (*setBitAnd)(ProtocolDesc * , OblivBit * , OblivBit const * , OblivBit const * ) ; + void (*setBitOr)(ProtocolDesc * , OblivBit * , OblivBit const * , OblivBit const * ) ; + void (*setBitXor)(ProtocolDesc * , OblivBit * , OblivBit const * , OblivBit const * ) ; + void (*setBitNot)(ProtocolDesc * , OblivBit * , OblivBit const * ) ; + void (*flipBit)(ProtocolDesc * , OblivBit * ) ; + void *extra ; +}; +# 52 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct __anonstruct_OTsender_37 { + void *sender ; + void (*send)(void * , char const * , char const * , int n , int len ) ; + void (*release)(void * ) ; +}; +# 52 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef struct __anonstruct_OTsender_37 OTsender; +# 58 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct __anonstruct_OTrecver_38 { + void *recver ; + void (*recv)(void * , char * , _Bool const * , int n , int len ) ; + void (*release)(void * ) ; +}; +# 58 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef struct __anonstruct_OTrecver_38 OTrecver; +# 64 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +union __anonunion____missing_field_name_39 { + OTsender sender ; + OTrecver recver ; +}; +# 64 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct YaoProtocolDesc { + yao_key_t R ; + yao_key_t I ; + uint64_t gcount ; + unsigned int icount ; + unsigned int ocount ; + void (*nonFreeGate)(struct ProtocolDesc * , OblivBit * , char , OblivBit const * , + OblivBit const * ) ; + union __anonunion____missing_field_name_39 __annonCompField2 ; +}; +# 64 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef struct YaoProtocolDesc YaoProtocolDesc; +# 73 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef struct ProtocolTransport ProtocolTransport; +# 77 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct ProtocolTransport { + int maxParties ; + int maxChannels ; + int curChannel ; + ProtocolTransport *(*subtransport)(ProtocolTransport * , int ) ; + int (*send)(ProtocolTransport * , int , void const * , size_t ) ; + int (*recv)(ProtocolTransport * , int , void * , size_t ) ; + void (*cleanup)(ProtocolTransport * ) ; +}; +# 85 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +struct OblivInputs { + unsigned long long src ; + struct OblivBit *dest ; + size_t size ; +}; +# 92 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef void (*protocol_run)(void * ); +# 12 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct __anonstruct_yao_41 { + yao_key_t w ; + _Bool inverted ; +}; +# 12 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +union __anonunion____missing_field_name_40 { + _Bool knownValue ; + struct __anonstruct_yao_41 yao ; +}; +# 12 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct OblivBit { + _Bool unknown ; + union __anonunion____missing_field_name_40 __annonCompField3 ; +}; +# 12 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +typedef struct OblivBit OblivBit___0; +# 33 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct __anonstruct___obliv_c__bool_42 { + OblivBit___0 bits[1] ; +}; +# 33 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +typedef struct __anonstruct___obliv_c__bool_42 __obliv_c__bool; +# 34 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct __anonstruct___obliv_c__char_43 { + OblivBit___0 bits[(unsigned long )8 * (unsigned long )sizeof(char )] ; +}; +# 34 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +typedef struct __anonstruct___obliv_c__char_43 __obliv_c__char; +# 35 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct __anonstruct___obliv_c__int_44 { + OblivBit___0 bits[(unsigned long )8 * (unsigned long )sizeof(int )] ; +}; +# 35 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +typedef struct __anonstruct___obliv_c__int_44 __obliv_c__int; +# 36 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct __anonstruct___obliv_c__short_45 { + OblivBit___0 bits[(unsigned long )8 * (unsigned long )sizeof(short )] ; +}; +# 36 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +typedef struct __anonstruct___obliv_c__short_45 __obliv_c__short; +# 37 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct __anonstruct___obliv_c__long_46 { + OblivBit___0 bits[(unsigned long )8 * (unsigned long )sizeof(long )] ; +}; +# 37 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +typedef struct __anonstruct___obliv_c__long_46 __obliv_c__long; +# 38 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +struct __anonstruct___obliv_c__lLong_47 { + OblivBit___0 bits[(unsigned long )8 * (unsigned long )sizeof(long long )] ; +}; +# 38 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +typedef struct __anonstruct___obliv_c__lLong_47 __obliv_c__lLong; +# 45 "/usr/include/stdio.h" +struct _IO_FILE; +# 45 "/usr/include/stdio.h" +struct _IO_FILE; +# 49 "/usr/include/stdio.h" +typedef struct _IO_FILE FILE; +# 65 "/usr/include/stdio.h" +typedef struct _IO_FILE __FILE; +# 83 "/usr/include/wchar.h" +union __anonunion___value_49 { + unsigned int __wch ; + char __wchb[4] ; +}; +# 83 "/usr/include/wchar.h" +struct __anonstruct___mbstate_t_48 { + int __count ; + union __anonunion___value_49 __value ; +}; +# 83 "/usr/include/wchar.h" +typedef struct __anonstruct___mbstate_t_48 __mbstate_t; +# 22 "/usr/include/_G_config.h" +struct __anonstruct__G_fpos_t_50 { + __off_t __pos ; + __mbstate_t __state ; +}; +# 22 "/usr/include/_G_config.h" +typedef struct __anonstruct__G_fpos_t_50 _G_fpos_t; +# 27 "/usr/include/_G_config.h" +struct __anonstruct__G_fpos64_t_51 { + __off64_t __pos ; + __mbstate_t __state ; +}; +# 27 "/usr/include/_G_config.h" +typedef struct __anonstruct__G_fpos64_t_51 _G_fpos64_t; +# 53 "/usr/include/_G_config.h" +typedef short _G_int16_t; +# 54 "/usr/include/_G_config.h" +typedef int _G_int32_t; +# 55 "/usr/include/_G_config.h" +typedef unsigned short _G_uint16_t; +# 56 "/usr/include/_G_config.h" +typedef unsigned int _G_uint32_t; +# 172 "/usr/include/libio.h" +struct _IO_jump_t; +# 172 "/usr/include/libio.h" +struct _IO_jump_t; +# 172 "/usr/include/libio.h" +struct _IO_FILE; +# 182 "/usr/include/libio.h" +typedef void _IO_lock_t; +# 188 "/usr/include/libio.h" +struct _IO_marker { + struct _IO_marker *_next ; + struct _IO_FILE *_sbuf ; + int _pos ; +}; +# 208 "/usr/include/libio.h" +enum __codecvt_result { + __codecvt_ok = 0, + __codecvt_partial = 1, + __codecvt_error = 2, + __codecvt_noconv = 3 +} ; +# 273 "/usr/include/libio.h" +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 )((unsigned long )((unsigned long )15 * (unsigned long )sizeof(int )) - (unsigned long )((unsigned long )4 * (unsigned long )sizeof(void *))) - (unsigned long )sizeof(size_t )] ; +}; +# 343 "/usr/include/libio.h" +typedef struct _IO_FILE _IO_FILE; +# 346 "/usr/include/libio.h" +struct _IO_FILE_plus; +# 346 "/usr/include/libio.h" +struct _IO_FILE_plus; +# 366 "/usr/include/libio.h" +typedef __ssize_t __io_read_fn(void *__cookie , char *__buf , size_t __nbytes ); +# 374 "/usr/include/libio.h" +typedef __ssize_t __io_write_fn(void *__cookie , char const *__buf , size_t __n ); +# 383 "/usr/include/libio.h" +typedef int __io_seek_fn(void *__cookie , __off64_t *__pos , int __w ); +# 386 "/usr/include/libio.h" +typedef int __io_close_fn(void *__cookie ); +# 111 "/usr/include/stdio.h" +typedef _G_fpos_t fpos_t; +# 7 "./mutual.h" +typedef char *string; +# 8 "./mutual.h" +struct protocolIO { + char mine[45][10] ; + int size ; + char common[45][10] ; + int commonSize ; +}; +# 8 "./mutual.h" +typedef struct protocolIO protocolIO; +# 7 "mutual.oc" +typedef __obliv_c__bool obool; +# 3 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern __attribute__((__nothrow__)) void *( __attribute__((__nonnull__(1), __leaf__)) memset)(void *__s , + int __c , + unsigned long __n ) ; +# 140 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) size_t ( __attribute__((__leaf__)) __ctype_get_mb_cur_max)(void) ; +# 145 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) double ( __attribute__((__nonnull__(1), __leaf__)) atof)(char const *__nptr ) __attribute__((__pure__)) ; +# 148 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) atoi)(char const *__nptr ) __attribute__((__pure__)) ; +# 151 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) long ( __attribute__((__nonnull__(1), __leaf__)) atol)(char const *__nptr ) __attribute__((__pure__)) ; +# 158 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) long long ( __attribute__((__nonnull__(1), __leaf__)) atoll)(char const *__nptr ) __attribute__((__pure__)) ; +# 165 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) double ( __attribute__((__nonnull__(1), __leaf__)) strtod)(char const * __restrict __nptr , + char ** __restrict __endptr ) ; +# 173 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) float ( __attribute__((__nonnull__(1), __leaf__)) strtof)(char const * __restrict __nptr , + char ** __restrict __endptr ) ; +# 176 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) long double ( __attribute__((__nonnull__(1), +__leaf__)) strtold)(char const * __restrict __nptr , char ** __restrict __endptr ) ; +# 184 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) long ( __attribute__((__nonnull__(1), __leaf__)) strtol)(char const * __restrict __nptr , + char ** __restrict __endptr , + int __base ) ; +# 188 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) unsigned long ( __attribute__((__nonnull__(1), +__leaf__)) strtoul)(char const * __restrict __nptr , char ** __restrict __endptr , + int __base ) ; +# 196 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) long long ( __attribute__((__nonnull__(1), __leaf__)) strtoq)(char const * __restrict __nptr , + char ** __restrict __endptr , + int __base ) ; +# 201 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) unsigned long long ( __attribute__((__nonnull__(1), +__leaf__)) strtouq)(char const * __restrict __nptr , char ** __restrict __endptr , + int __base ) ; +# 210 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) long long ( __attribute__((__nonnull__(1), __leaf__)) strtoll)(char const * __restrict __nptr , + char ** __restrict __endptr , + int __base ) ; +# 215 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) unsigned long long ( __attribute__((__nonnull__(1), +__leaf__)) strtoull)(char const * __restrict __nptr , char ** __restrict __endptr , + int __base ) ; +# 311 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) l64a)(long __n ) ; +# 314 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) long ( __attribute__((__nonnull__(1), __leaf__)) a64l)(char const *__s ) __attribute__((__pure__)) ; +# 107 "/usr/include/x86_64-linux-gnu/sys/select.h" +extern int select(int __nfds , fd_set * __restrict __readfds , fd_set * __restrict __writefds , + fd_set * __restrict __exceptfds , struct timeval * __restrict __timeout ) ; +# 119 "/usr/include/x86_64-linux-gnu/sys/select.h" +extern int pselect(int __nfds , fd_set * __restrict __readfds , fd_set * __restrict __writefds , + fd_set * __restrict __exceptfds , struct timespec const * __restrict __timeout , + __sigset_t const * __restrict __sigmask ) ; +# 33 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" +extern __attribute__((__nothrow__)) unsigned int ( __attribute__((__leaf__)) gnu_dev_major)(unsigned long long __dev ) __attribute__((__const__)) ; +# 36 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" +extern __attribute__((__nothrow__)) unsigned int ( __attribute__((__leaf__)) gnu_dev_minor)(unsigned long long __dev ) __attribute__((__const__)) ; +# 39 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" +extern __attribute__((__nothrow__)) unsigned long long ( __attribute__((__leaf__)) gnu_dev_makedev)(unsigned int __major , + unsigned int __minor ) __attribute__((__const__)) ; +# 327 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) long ( __attribute__((__leaf__)) random)(void) ; +# 330 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) srandom)(unsigned int __seed ) ; +# 336 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(2), __leaf__)) initstate)(unsigned int __seed , + char *__statebuf , + size_t __statelen ) ; +# 341 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) setstate)(char *__statebuf ) ; +# 360 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) random_r)(struct random_data * __restrict __buf , + int32_t * __restrict __result ) ; +# 363 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(2), __leaf__)) srandom_r)(unsigned int __seed , + struct random_data *__buf ) ; +# 366 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(2,4), __leaf__)) initstate_r)(unsigned int __seed , + char * __restrict __statebuf , + size_t __statelen , + struct random_data * __restrict __buf ) ; +# 371 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) setstate_r)(char * __restrict __statebuf , + struct random_data * __restrict __buf ) ; +# 380 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) rand)(void) ; +# 382 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) srand)(unsigned int __seed ) ; +# 387 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) rand_r)(unsigned int *__seed ) ; +# 395 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) double ( __attribute__((__leaf__)) drand48)(void) ; +# 396 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) double ( __attribute__((__nonnull__(1), __leaf__)) erand48)(unsigned short *__xsubi ) ; +# 399 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) long ( __attribute__((__leaf__)) lrand48)(void) ; +# 400 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) long ( __attribute__((__nonnull__(1), __leaf__)) nrand48)(unsigned short *__xsubi ) ; +# 404 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) long ( __attribute__((__leaf__)) mrand48)(void) ; +# 405 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) long ( __attribute__((__nonnull__(1), __leaf__)) jrand48)(unsigned short *__xsubi ) ; +# 409 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) srand48)(long __seedval ) ; +# 410 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) unsigned short *( __attribute__((__nonnull__(1), +__leaf__)) seed48)(unsigned short *__seed16v ) ; +# 412 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__nonnull__(1), __leaf__)) lcong48)(unsigned short *__param ) ; +# 428 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) drand48_r)(struct drand48_data * __restrict __buffer , + double * __restrict __result ) ; +# 430 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) erand48_r)(unsigned short *__xsubi , + struct drand48_data * __restrict __buffer , + double * __restrict __result ) ; +# 435 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) lrand48_r)(struct drand48_data * __restrict __buffer , + long * __restrict __result ) ; +# 438 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) nrand48_r)(unsigned short *__xsubi , + struct drand48_data * __restrict __buffer , + long * __restrict __result ) ; +# 444 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) mrand48_r)(struct drand48_data * __restrict __buffer , + long * __restrict __result ) ; +# 447 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) jrand48_r)(unsigned short *__xsubi , + struct drand48_data * __restrict __buffer , + long * __restrict __result ) ; +# 453 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(2), __leaf__)) srand48_r)(long __seedval , + struct drand48_data *__buffer ) ; +# 456 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) seed48_r)(unsigned short *__seed16v , + struct drand48_data *__buffer ) ; +# 459 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) lcong48_r)(unsigned short *__param , + struct drand48_data *__buffer ) ; +# 471 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) void *( __attribute__((__leaf__)) malloc)(size_t __size ) __attribute__((__malloc__)) ; +# 473 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) void *( __attribute__((__leaf__)) calloc)(size_t __nmemb , + size_t __size ) __attribute__((__malloc__)) ; +# 485 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) void *( __attribute__((__warn_unused_result__, +__leaf__)) realloc)(void *__ptr , size_t __size ) ; +# 488 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) free)(void *__ptr ) ; +# 493 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) cfree)(void *__ptr ) ; +# 33 "/usr/include/alloca.h" +extern __attribute__((__nothrow__)) void *( __attribute__((__leaf__)) alloca)(size_t __size ) ; +# 503 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) void *( __attribute__((__leaf__)) valloc)(size_t __size ) __attribute__((__malloc__)) ; +# 508 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) posix_memalign)(void **__memptr , + size_t __alignment , + size_t __size ) ; +# 514 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__, __noreturn__)) void ( __attribute__((__leaf__)) abort)(void) ; +# 518 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) atexit)(void (*__func)(void) ) ; +# 536 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) on_exit)(void (*__func)(int __status , + void *__arg ) , + void *__arg ) ; +# 544 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__, __noreturn__)) void ( __attribute__((__leaf__)) exit)(int __status ) ; +# 560 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__, __noreturn__)) void ( __attribute__((__leaf__)) _Exit)(int __status ) ; +# 567 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) getenv)(char const *__name ) ; +# 572 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) __secure_getenv)(char const *__name ) ; +# 579 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) putenv)(char *__string ) ; +# 585 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(2), __leaf__)) setenv)(char const *__name , + char const *__value , + int __replace ) ; +# 589 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) unsetenv)(char const *__name ) ; +# 596 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) clearenv)(void) ; +# 606 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) mktemp)(char *__template ) ; +# 620 "/usr/include/stdlib.h" +extern int ( __attribute__((__nonnull__(1))) mkstemp)(char *__template ) ; +# 642 "/usr/include/stdlib.h" +extern int ( __attribute__((__nonnull__(1))) mkstemps)(char *__template , int __suffixlen ) ; +# 663 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) mkdtemp)(char *__template ) ; +# 717 "/usr/include/stdlib.h" +extern int system(char const *__command ) ; +# 734 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) realpath)(char const * __restrict __name , + char * __restrict __resolved ) ; +# 755 "/usr/include/stdlib.h" +extern void *( __attribute__((__nonnull__(1,2,5))) bsearch)(void const *__key , + void const *__base , + size_t __nmemb , size_t __size , + int (*__compar)(void const * , + void const * ) ) ; +# 761 "/usr/include/stdlib.h" +extern void ( __attribute__((__nonnull__(1,4))) qsort)(void *__base , size_t __nmemb , + size_t __size , int (*__compar)(void const * , + void const * ) ) ; +# 771 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) abs)(int __x ) __attribute__((__const__)) ; +# 772 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) long ( __attribute__((__leaf__)) labs)(long __x ) __attribute__((__const__)) ; +# 776 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) long long ( __attribute__((__leaf__)) llabs)(long long __x ) __attribute__((__const__)) ; +# 785 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) div_t ( __attribute__((__leaf__)) div)(int __numer , + int __denom ) __attribute__((__const__)) ; +# 787 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) ldiv_t ( __attribute__((__leaf__)) ldiv)(long __numer , + long __denom ) __attribute__((__const__)) ; +# 793 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) lldiv_t ( __attribute__((__leaf__)) lldiv)(long long __numer , + long long __denom ) __attribute__((__const__)) ; +# 808 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(3,4), __leaf__)) ecvt)(double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign ) ; +# 814 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(3,4), __leaf__)) fcvt)(double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign ) ; +# 820 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(3), __leaf__)) gcvt)(double __value , + int __ndigit , + char *__buf ) ; +# 826 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(3,4), __leaf__)) qecvt)(long double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign ) ; +# 829 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(3,4), __leaf__)) qfcvt)(long double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign ) ; +# 832 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(3), __leaf__)) qgcvt)(long double __value , + int __ndigit , + char *__buf ) ; +# 838 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(3,4,5), __leaf__)) ecvt_r)(double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign , + char * __restrict __buf , + size_t __len ) ; +# 841 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(3,4,5), __leaf__)) fcvt_r)(double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign , + char * __restrict __buf , + size_t __len ) ; +# 845 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(3,4,5), __leaf__)) qecvt_r)(long double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign , + char * __restrict __buf , + size_t __len ) ; +# 849 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(3,4,5), __leaf__)) qfcvt_r)(long double __value , + int __ndigit , + int * __restrict __decpt , + int * __restrict __sign , + char * __restrict __buf , + size_t __len ) ; +# 860 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) mblen)(char const *__s , + size_t __n ) ; +# 863 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) mbtowc)(wchar_t * __restrict __pwc , + char const * __restrict __s , + size_t __n ) ; +# 867 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) wctomb)(char *__s , + wchar_t __wchar ) ; +# 871 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) size_t ( __attribute__((__leaf__)) mbstowcs)(wchar_t * __restrict __pwcs , + char const * __restrict __s , + size_t __n ) ; +# 874 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) size_t ( __attribute__((__leaf__)) wcstombs)(char * __restrict __s , + wchar_t const * __restrict __pwcs , + size_t __n ) ; +# 885 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) rpmatch)(char const *__response ) ; +# 896 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2,3), __leaf__)) getsubopt)(char ** __restrict __optionp , + char * const * __restrict __tokens , + char ** __restrict __valuep ) ; +# 948 "/usr/include/stdlib.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) getloadavg)(double *__loadavg , + int __nelem ) ; +# 44 "/usr/include/string.h" +extern __attribute__((__nothrow__)) void *( __attribute__((__nonnull__(1,2), __leaf__)) memcpy)(void * __restrict __dest , + void const * __restrict __src , + size_t __n ) ; +# 49 "/usr/include/string.h" +extern __attribute__((__nothrow__)) void *( __attribute__((__nonnull__(1,2), __leaf__)) memmove)(void *__dest , + void const *__src , + size_t __n ) ; +# 57 "/usr/include/string.h" +extern __attribute__((__nothrow__)) void *( __attribute__((__nonnull__(1,2), __leaf__)) memccpy)(void * __restrict __dest , + void const * __restrict __src , + int __c , + size_t __n ) ; +# 68 "/usr/include/string.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) memcmp)(void const *__s1 , + void const *__s2 , + size_t __n ) __attribute__((__pure__)) ; +# 95 "/usr/include/string.h" +extern __attribute__((__nothrow__)) void *( __attribute__((__nonnull__(1), __leaf__)) memchr)(void const *__s , + int __c , + size_t __n ) __attribute__((__pure__)) ; +# 128 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) strcpy)(char * __restrict __dest , + char const * __restrict __src ) ; +# 131 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) strncpy)(char * __restrict __dest , + char const * __restrict __src , + size_t __n ) ; +# 136 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) strcat)(char * __restrict __dest , + char const * __restrict __src ) ; +# 139 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) strncat)(char * __restrict __dest , + char const * __restrict __src , + size_t __n ) ; +# 143 "/usr/include/string.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) strcmp)(char const *__s1 , + char const *__s2 ) __attribute__((__pure__)) ; +# 146 "/usr/include/string.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) strncmp)(char const *__s1 , + char const *__s2 , + size_t __n ) __attribute__((__pure__)) ; +# 150 "/usr/include/string.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) strcoll)(char const *__s1 , + char const *__s2 ) __attribute__((__pure__)) ; +# 153 "/usr/include/string.h" +extern __attribute__((__nothrow__)) size_t ( __attribute__((__nonnull__(2), __leaf__)) strxfrm)(char * __restrict __dest , + char const * __restrict __src , + size_t __n ) ; +# 165 "/usr/include/string.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2,3), __leaf__)) strcoll_l)(char const *__s1 , + char const *__s2 , + __locale_t __l ) __attribute__((__pure__)) ; +# 168 "/usr/include/string.h" +extern __attribute__((__nothrow__)) size_t ( __attribute__((__nonnull__(2,4), __leaf__)) strxfrm_l)(char *__dest , + char const *__src , + size_t __n , + __locale_t __l ) ; +# 175 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) strdup)(char const *__s ) __attribute__((__malloc__)) ; +# 183 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) strndup)(char const *__string , + size_t __n ) __attribute__((__malloc__)) ; +# 235 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) strchr)(char const *__s , + int __c ) __attribute__((__pure__)) ; +# 262 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) strrchr)(char const *__s , + int __c ) __attribute__((__pure__)) ; +# 284 "/usr/include/string.h" +extern __attribute__((__nothrow__)) size_t ( __attribute__((__nonnull__(1,2), __leaf__)) strcspn)(char const *__s , + char const *__reject ) __attribute__((__pure__)) ; +# 288 "/usr/include/string.h" +extern __attribute__((__nothrow__)) size_t ( __attribute__((__nonnull__(1,2), __leaf__)) strspn)(char const *__s , + char const *__accept ) __attribute__((__pure__)) ; +# 314 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) strpbrk)(char const *__s , + char const *__accept ) __attribute__((__pure__)) ; +# 342 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) strstr)(char const *__haystack , + char const *__needle ) __attribute__((__pure__)) ; +# 348 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(2), __leaf__)) strtok)(char * __restrict __s , + char const * __restrict __delim ) ; +# 354 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(2,3), __leaf__)) __strtok_r)(char * __restrict __s , + char const * __restrict __delim , + char ** __restrict __save_ptr ) ; +# 359 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(2,3), __leaf__)) strtok_r)(char * __restrict __s , + char const * __restrict __delim , + char ** __restrict __save_ptr ) ; +# 399 "/usr/include/string.h" +extern __attribute__((__nothrow__)) size_t ( __attribute__((__nonnull__(1), __leaf__)) strlen)(char const *__s ) __attribute__((__pure__)) ; +# 406 "/usr/include/string.h" +extern __attribute__((__nothrow__)) size_t ( __attribute__((__nonnull__(1), __leaf__)) strnlen)(char const *__string , + size_t __maxlen ) __attribute__((__pure__)) ; +# 413 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) strerror)(int __errnum ) ; +# 427 "/usr/include/string.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(2), __leaf__)) strerror_r)(int __errnum , + char *__buf , + size_t __buflen ) __asm__("__xpg_strerror_r") ; +# 445 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) strerror_l)(int __errnum , + __locale_t __l ) ; +# 451 "/usr/include/string.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__nonnull__(1), __leaf__)) __bzero)(void *__s , + size_t __n ) ; +# 455 "/usr/include/string.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__nonnull__(1,2), __leaf__)) bcopy)(void const *__src , + void *__dest , + size_t __n ) ; +# 459 "/usr/include/string.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__nonnull__(1), __leaf__)) bzero)(void *__s , + size_t __n ) ; +# 462 "/usr/include/string.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) bcmp)(void const *__s1 , + void const *__s2 , + size_t __n ) __attribute__((__pure__)) ; +# 489 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) index)(char const *__s , + int __c ) __attribute__((__pure__)) ; +# 517 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1), __leaf__)) rindex)(char const *__s , + int __c ) __attribute__((__pure__)) ; +# 523 "/usr/include/string.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) ffs)(int __i ) __attribute__((__const__)) ; +# 536 "/usr/include/string.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) strcasecmp)(char const *__s1 , + char const *__s2 ) __attribute__((__pure__)) ; +# 540 "/usr/include/string.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1,2), __leaf__)) strncasecmp)(char const *__s1 , + char const *__s2 , + size_t __n ) __attribute__((__pure__)) ; +# 559 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) strsep)(char ** __restrict __stringp , + char const * __restrict __delim ) ; +# 566 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) strsignal)(int __sig ) ; +# 569 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) __stpcpy)(char * __restrict __dest , + char const * __restrict __src ) ; +# 571 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) stpcpy)(char * __restrict __dest , + char const * __restrict __src ) ; +# 576 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) __stpncpy)(char * __restrict __dest , + char const * __restrict __src , + size_t __n ) ; +# 579 "/usr/include/string.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__nonnull__(1,2), __leaf__)) stpncpy)(char * __restrict __dest , + char const * __restrict __src , + size_t __n ) ; +# 551 "/usr/include/gpg-error.h" +extern gpg_error_t gpg_err_init(void) __attribute__((__constructor__)) ; +# 562 "/usr/include/gpg-error.h" +extern void gpg_err_deinit(int mode ) ; +# 569 "/usr/include/gpg-error.h" +__inline static gpg_error_t gpg_err_make(gpg_err_source_t source , gpg_err_code_t code ) +{ + unsigned int tmp ; + unsigned int __cil_tmp4 ; + unsigned int __cil_tmp5 ; + unsigned int __cil_tmp6 ; + unsigned int __cil_tmp7 ; + unsigned int __cil_tmp8 ; + unsigned int __cil_tmp9 ; + int __cil_tmp10 ; + unsigned int __cil_tmp11 ; + unsigned int __cil_tmp12 ; + unsigned int __cil_tmp13 ; + unsigned int __cil_tmp14 ; + unsigned int __cil_tmp15 ; + unsigned int __cil_tmp16 ; + + { +# 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(unsigned int )); + { +# 572 "/usr/include/gpg-error.h" + __cil_tmp4 = (unsigned int )0; +# 572 "/usr/include/gpg-error.h" + __cil_tmp5 = (unsigned int )code; +# 572 "/usr/include/gpg-error.h" + if (__cil_tmp5 == __cil_tmp4) { +# 572 "/usr/include/gpg-error.h" + tmp = (unsigned int )0; + } else { +# 572 "/usr/include/gpg-error.h" + __cil_tmp6 = (unsigned int )65535; +# 572 "/usr/include/gpg-error.h" + __cil_tmp7 = (unsigned int )code; +# 572 "/usr/include/gpg-error.h" + __cil_tmp8 = __cil_tmp7 & __cil_tmp6; +# 572 "/usr/include/gpg-error.h" + __cil_tmp9 = (unsigned int )__cil_tmp8; +# 572 "/usr/include/gpg-error.h" + __cil_tmp10 = (int )24; +# 572 "/usr/include/gpg-error.h" + __cil_tmp11 = (unsigned int )127; +# 572 "/usr/include/gpg-error.h" + __cil_tmp12 = (unsigned int )source; +# 572 "/usr/include/gpg-error.h" + __cil_tmp13 = __cil_tmp12 & __cil_tmp11; +# 572 "/usr/include/gpg-error.h" + __cil_tmp14 = (unsigned int )__cil_tmp13; +# 572 "/usr/include/gpg-error.h" + __cil_tmp15 = __cil_tmp14 << __cil_tmp10; +# 572 "/usr/include/gpg-error.h" + __cil_tmp16 = (unsigned int )__cil_tmp15; +# 572 "/usr/include/gpg-error.h" + tmp = __cil_tmp16 | __cil_tmp9; + } + } +# 572 "/usr/include/gpg-error.h" + return (tmp); +} +} +# 584 "/usr/include/gpg-error.h" +__inline static gpg_error_t gpg_error(gpg_err_code_t code ) +{ + gpg_error_t tmp ; + gpg_err_source_t __cil_tmp3 ; + + { +# 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gpg_error_t )); +# 587 "/usr/include/gpg-error.h" + __cil_tmp3 = (gpg_err_source_t )0; +# 587 "/usr/include/gpg-error.h" + tmp = gpg_err_make(__cil_tmp3, code); +# 587 "/usr/include/gpg-error.h" + return (tmp); +} +} +# 592 "/usr/include/gpg-error.h" +__inline static gpg_err_code_t gpg_err_code(gpg_error_t err ) +{ + unsigned int __cil_tmp2 ; + unsigned int __cil_tmp3 ; + unsigned int __cil_tmp4 ; + + { + { +# 595 "/usr/include/gpg-error.h" + __cil_tmp2 = (unsigned int )65535; +# 595 "/usr/include/gpg-error.h" + __cil_tmp3 = (unsigned int )err; +# 595 "/usr/include/gpg-error.h" + __cil_tmp4 = __cil_tmp3 & __cil_tmp2; +# 595 "/usr/include/gpg-error.h" + return ((gpg_err_code_t )__cil_tmp4); + } +} +} +# 600 "/usr/include/gpg-error.h" +__inline static gpg_err_source_t gpg_err_source(gpg_error_t err ) +{ + unsigned int __cil_tmp2 ; + int __cil_tmp3 ; + gpg_error_t __cil_tmp4 ; + gpg_error_t __cil_tmp5 ; + unsigned int __cil_tmp6 ; + unsigned int __cil_tmp7 ; + + { + { +# 603 "/usr/include/gpg-error.h" + __cil_tmp2 = (unsigned int )127; +# 603 "/usr/include/gpg-error.h" + __cil_tmp3 = (int )24; +# 603 "/usr/include/gpg-error.h" + __cil_tmp4 = (gpg_error_t )err; +# 603 "/usr/include/gpg-error.h" + __cil_tmp5 = __cil_tmp4 >> __cil_tmp3; +# 603 "/usr/include/gpg-error.h" + __cil_tmp6 = (unsigned int )__cil_tmp5; +# 603 "/usr/include/gpg-error.h" + __cil_tmp7 = __cil_tmp6 & __cil_tmp2; +# 603 "/usr/include/gpg-error.h" + return ((gpg_err_source_t )__cil_tmp7); + } +} +} +# 612 "/usr/include/gpg-error.h" +extern char const *gpg_strerror(gpg_error_t err ) ; +# 621 "/usr/include/gpg-error.h" +extern int gpg_strerror_r(gpg_error_t err , char *buf , size_t buflen ) ; +# 625 "/usr/include/gpg-error.h" +extern char const *gpg_strsource(gpg_error_t err ) ; +# 633 "/usr/include/gpg-error.h" +extern gpg_err_code_t gpg_err_code_from_errno(int err ) ; +# 638 "/usr/include/gpg-error.h" +extern int gpg_err_code_to_errno(gpg_err_code_t code ) ; +# 644 "/usr/include/gpg-error.h" +extern gpg_err_code_t gpg_err_code_from_syserror(void) ; +# 649 "/usr/include/gpg-error.h" +extern void gpg_err_set_errno(int err ) ; +# 654 "/usr/include/gpg-error.h" +__inline static gpg_error_t gpg_err_make_from_errno(gpg_err_source_t source , int err ) +{ + gpg_err_code_t tmp ; + gpg_error_t tmp___0 ; + + { +# 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gpg_err_code_t )); +# 49 "mutual.oc" + memset((void *)(& tmp___0), 0, sizeof(gpg_error_t )); +# 657 "/usr/include/gpg-error.h" + tmp = gpg_err_code_from_errno(err); +# 657 "/usr/include/gpg-error.h" + tmp___0 = gpg_err_make(source, tmp); +# 657 "/usr/include/gpg-error.h" + return (tmp___0); +} +} +# 661 "/usr/include/gpg-error.h" +__inline static gpg_error_t gpg_error_from_errno(int err ) +{ + gpg_err_code_t tmp ; + gpg_error_t tmp___0 ; + + { +# 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gpg_err_code_t )); +# 49 "mutual.oc" + memset((void *)(& tmp___0), 0, sizeof(gpg_error_t )); +# 664 "/usr/include/gpg-error.h" + tmp = gpg_err_code_from_errno(err); +# 664 "/usr/include/gpg-error.h" + tmp___0 = gpg_error(tmp); +# 664 "/usr/include/gpg-error.h" + return (tmp___0); +} +} +# 667 "/usr/include/gpg-error.h" +__inline static gpg_error_t gpg_error_from_syserror(void) +{ + gpg_err_code_t tmp ; + gpg_error_t tmp___0 ; + + { +# 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gpg_err_code_t )); +# 49 "mutual.oc" + memset((void *)(& tmp___0), 0, sizeof(gpg_error_t )); +# 670 "/usr/include/gpg-error.h" + tmp = gpg_err_code_from_syserror(); +# 670 "/usr/include/gpg-error.h" + tmp___0 = gpg_error(tmp); +# 670 "/usr/include/gpg-error.h" + return (tmp___0); +} +} +# 58 "/usr/include/x86_64-linux-gnu/bits/uio.h" +extern __attribute__((__nothrow__)) ssize_t ( __attribute__((__leaf__)) process_vm_readv)(pid_t __pid , + struct iovec const *__lvec , + unsigned long __liovcnt , + struct iovec const *__rvec , + unsigned long __riovcnt , + unsigned long __flags ) ; +# 66 "/usr/include/x86_64-linux-gnu/bits/uio.h" +extern __attribute__((__nothrow__)) ssize_t ( __attribute__((__leaf__)) process_vm_writev)(pid_t __pid , + struct iovec const *__lvec , + unsigned long __liovcnt , + struct iovec const *__rvec , + unsigned long __riovcnt , + unsigned long __flags ) ; +# 40 "/usr/include/x86_64-linux-gnu/sys/uio.h" +extern ssize_t readv(int __fd , struct iovec const *__iovec , int __count ) ; +# 51 "/usr/include/x86_64-linux-gnu/sys/uio.h" +extern ssize_t writev(int __fd , struct iovec const *__iovec , int __count ) ; +# 66 "/usr/include/x86_64-linux-gnu/sys/uio.h" +extern ssize_t preadv(int __fd , struct iovec const *__iovec , int __count , __off_t __offset ) ; +# 78 "/usr/include/x86_64-linux-gnu/sys/uio.h" +extern ssize_t pwritev(int __fd , struct iovec const *__iovec , int __count , __off_t __offset ) ; +# 310 "/usr/include/x86_64-linux-gnu/bits/socket.h" +extern __attribute__((__nothrow__)) struct cmsghdr *( __attribute__((__leaf__)) __cmsg_nxthdr)(struct msghdr *__mhdr , + struct cmsghdr *__cmsg ) ; +# 431 "/usr/include/x86_64-linux-gnu/bits/socket.h" +extern int recvmmsg(int __fd , struct mmsghdr *__vmessages , unsigned int __vlen , + int __flags , struct timespec const *__tmo ) ; +# 439 "/usr/include/x86_64-linux-gnu/bits/socket.h" +extern int sendmmsg(int __fd , struct mmsghdr *__vmessages , unsigned int __vlen , + int __flags ) ; +# 105 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) socket)(int __domain , + int __type , + int __protocol ) ; +# 111 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) socketpair)(int __domain , + int __type , + int __protocol , + int *__fds ) ; +# 115 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) bind)(int __fd , + struct sockaddr const *__addr , + socklen_t __len ) ; +# 119 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) getsockname)(int __fd , + struct sockaddr * __restrict __addr , + socklen_t * __restrict __len ) ; +# 129 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern int connect(int __fd , struct sockaddr const *__addr , socklen_t __len ) ; +# 133 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) getpeername)(int __fd , + struct sockaddr * __restrict __addr , + socklen_t * __restrict __len ) ; +# 141 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern ssize_t send(int __fd , void const *__buf , size_t __n , int __flags ) ; +# 148 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern ssize_t recv(int __fd , void *__buf , size_t __n , int __flags ) ; +# 155 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern ssize_t sendto(int __fd , void const *__buf , size_t __n , int __flags , + struct sockaddr const *__addr , socklen_t __addr_len ) ; +# 166 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern ssize_t recvfrom(int __fd , void * __restrict __buf , size_t __n , int __flags , + struct sockaddr * __restrict __addr , socklen_t * __restrict __addr_len ) ; +# 176 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern ssize_t sendmsg(int __fd , struct msghdr const *__message , int __flags ) ; +# 184 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern ssize_t recvmsg(int __fd , struct msghdr *__message , int __flags ) ; +# 190 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) getsockopt)(int __fd , + int __level , + int __optname , + void * __restrict __optval , + socklen_t * __restrict __optlen ) ; +# 197 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) setsockopt)(int __fd , + int __level , + int __optname , + void const *__optval , + socklen_t __optlen ) ; +# 204 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) listen)(int __fd , + int __n ) ; +# 214 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern int accept(int __fd , struct sockaddr * __restrict __addr , socklen_t * __restrict __addr_len ) ; +# 232 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) shutdown)(int __fd , + int __how ) ; +# 237 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) sockatmark)(int __fd ) ; +# 245 "/usr/include/x86_64-linux-gnu/sys/socket.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) isfdtype)(int __fd , + int __fdtype ) ; +# 73 "/usr/include/x86_64-linux-gnu/sys/time.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) gettimeofday)(struct timeval * __restrict __tv , + __timezone_ptr_t __tz ) ; +# 79 "/usr/include/x86_64-linux-gnu/sys/time.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) settimeofday)(struct timeval const *__tv , + struct timezone const *__tz ) ; +# 87 "/usr/include/x86_64-linux-gnu/sys/time.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) adjtime)(struct timeval const *__delta , + struct timeval *__olddelta ) ; +# 127 "/usr/include/x86_64-linux-gnu/sys/time.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) getitimer)(__itimer_which_t __which , + struct itimerval *__value ) ; +# 133 "/usr/include/x86_64-linux-gnu/sys/time.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) setitimer)(__itimer_which_t __which , + struct itimerval const * __restrict __new , + struct itimerval * __restrict __old ) ; +# 140 "/usr/include/x86_64-linux-gnu/sys/time.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) utimes)(char const *__file , + struct timeval const *__tvp ) ; +# 145 "/usr/include/x86_64-linux-gnu/sys/time.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__nonnull__(1), __leaf__)) lutimes)(char const *__file , + struct timeval const *__tvp ) ; +# 149 "/usr/include/x86_64-linux-gnu/sys/time.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) futimes)(int __fd , + struct timeval const *__tvp ) ; +# 121 "/usr/include/gcrypt.h" +__inline static gcry_error_t gcry_err_make(gcry_err_source_t source , gcry_err_code_t code ) +{ + gpg_error_t tmp ; + + { +# 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gpg_error_t )); +# 124 "/usr/include/gcrypt.h" + tmp = gpg_err_make(source, code); +# 124 "/usr/include/gcrypt.h" + return (tmp); +} +} +# 133 "/usr/include/gcrypt.h" +__inline static gcry_error_t gcry_error(gcry_err_code_t code ) +{ + gcry_error_t tmp ; + gcry_err_source_t __cil_tmp3 ; + + { +# 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gcry_error_t )); +# 136 "/usr/include/gcrypt.h" + __cil_tmp3 = (gcry_err_source_t )32; +# 136 "/usr/include/gcrypt.h" + tmp = gcry_err_make(__cil_tmp3, code); +# 136 "/usr/include/gcrypt.h" + return (tmp); +} +} +# 139 "/usr/include/gcrypt.h" +__inline static gcry_err_code_t gcry_err_code(gcry_error_t err ) +{ + gpg_err_code_t tmp ; + + { +# 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gpg_err_code_t )); +# 142 "/usr/include/gcrypt.h" + tmp = gpg_err_code(err); +# 142 "/usr/include/gcrypt.h" + return (tmp); +} +} +# 146 "/usr/include/gcrypt.h" +__inline static gcry_err_source_t gcry_err_source(gcry_error_t err ) +{ + gpg_err_source_t tmp ; + + { +# 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(gpg_err_source_t )); +# 149 "/usr/include/gcrypt.h" + tmp = gpg_err_source(err); +# 149 "/usr/include/gcrypt.h" + return (tmp); +} +} +# 154 "/usr/include/gcrypt.h" +extern char const *gcry_strerror(gcry_error_t err ) ; +# 158 "/usr/include/gcrypt.h" +extern char const *gcry_strsource(gcry_error_t err ) ; +# 163 "/usr/include/gcrypt.h" +extern gcry_err_code_t gcry_err_code_from_errno(int err ) ; +# 167 "/usr/include/gcrypt.h" +extern int gcry_err_code_to_errno(gcry_err_code_t code ) ; +# 171 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_err_make_from_errno(gcry_err_source_t source , int err ) ; +# 174 "/usr/include/gcrypt.h" +extern gcry_err_code_t gcry_error_from_errno(int err ) ; +# 354 "/usr/include/gcrypt.h" +extern char const *gcry_check_version(char const *req_version ) ; +# 422 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_control(enum gcry_ctl_cmds CMD , ...) ; +# 449 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_sexp_new(gcry_sexp_t *retsexp , void const *buffer , size_t length , + int autodetect ) ; +# 455 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_sexp_create(gcry_sexp_t *retsexp , void *buffer , size_t length , + int autodetect , void (*freefnc)(void * ) ) ; +# 461 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_sexp_sscan(gcry_sexp_t *retsexp , size_t *erroff , char const *buffer , + size_t length ) ; +# 466 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_sexp_build(gcry_sexp_t *retsexp , size_t *erroff , char const *format + , ...) ; +# 471 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_sexp_build_array(gcry_sexp_t *retsexp , size_t *erroff , + char const *format , void **arg_list ) ; +# 475 "/usr/include/gcrypt.h" +extern void gcry_sexp_release(gcry_sexp_t sexp ) ; +# 479 "/usr/include/gcrypt.h" +extern size_t gcry_sexp_canon_len(unsigned char const *buffer , size_t length , + size_t *erroff , gcry_error_t *errcode ) ; +# 484 "/usr/include/gcrypt.h" +extern size_t gcry_sexp_sprint(gcry_sexp_t sexp , int mode , void *buffer , size_t maxlength ) ; +# 489 "/usr/include/gcrypt.h" +extern void gcry_sexp_dump(gcry_sexp_t const a ) ; +# 491 "/usr/include/gcrypt.h" +extern gcry_sexp_t gcry_sexp_cons(gcry_sexp_t const a , gcry_sexp_t const b ) ; +# 492 "/usr/include/gcrypt.h" +extern gcry_sexp_t gcry_sexp_alist(gcry_sexp_t const *array ) ; +# 493 "/usr/include/gcrypt.h" +extern gcry_sexp_t gcry_sexp_vlist(gcry_sexp_t const a , ...) ; +# 494 "/usr/include/gcrypt.h" +extern gcry_sexp_t gcry_sexp_append(gcry_sexp_t const a , gcry_sexp_t const n ) ; +# 495 "/usr/include/gcrypt.h" +extern gcry_sexp_t gcry_sexp_prepend(gcry_sexp_t const a , gcry_sexp_t const n ) ; +# 502 "/usr/include/gcrypt.h" +extern gcry_sexp_t gcry_sexp_find_token(gcry_sexp_t list , char const *tok , size_t toklen ) ; +# 506 "/usr/include/gcrypt.h" +extern int gcry_sexp_length(gcry_sexp_t const list ) ; +# 511 "/usr/include/gcrypt.h" +extern gcry_sexp_t gcry_sexp_nth(gcry_sexp_t const list , int number ) ; +# 516 "/usr/include/gcrypt.h" +extern gcry_sexp_t gcry_sexp_car(gcry_sexp_t const list ) ; +# 523 "/usr/include/gcrypt.h" +extern gcry_sexp_t gcry_sexp_cdr(gcry_sexp_t const list ) ; +# 525 "/usr/include/gcrypt.h" +extern gcry_sexp_t gcry_sexp_cadr(gcry_sexp_t const list ) ; +# 534 "/usr/include/gcrypt.h" +extern char const *gcry_sexp_nth_data(gcry_sexp_t const list , int number , size_t *datalen ) ; +# 542 "/usr/include/gcrypt.h" +extern char *gcry_sexp_nth_string(gcry_sexp_t list , int number ) ; +# 550 "/usr/include/gcrypt.h" +extern gcry_mpi_t gcry_sexp_nth_mpi(gcry_sexp_t list , int number , int mpifmt ) ; +# 583 "/usr/include/gcrypt.h" +extern gcry_mpi_t gcry_mpi_new(unsigned int nbits ) ; +# 586 "/usr/include/gcrypt.h" +extern gcry_mpi_t gcry_mpi_snew(unsigned int nbits ) ; +# 589 "/usr/include/gcrypt.h" +extern void gcry_mpi_release(gcry_mpi_t a ) ; +# 592 "/usr/include/gcrypt.h" +extern gcry_mpi_t gcry_mpi_copy(gcry_mpi_t const a ) ; +# 595 "/usr/include/gcrypt.h" +extern gcry_mpi_t gcry_mpi_set(gcry_mpi_t w , gcry_mpi_t const u ) ; +# 598 "/usr/include/gcrypt.h" +extern gcry_mpi_t gcry_mpi_set_ui(gcry_mpi_t w , unsigned long u ) ; +# 601 "/usr/include/gcrypt.h" +extern void gcry_mpi_swap(gcry_mpi_t a , gcry_mpi_t b ) ; +# 605 "/usr/include/gcrypt.h" +extern int gcry_mpi_cmp(gcry_mpi_t const u , gcry_mpi_t const v ) ; +# 610 "/usr/include/gcrypt.h" +extern int gcry_mpi_cmp_ui(gcry_mpi_t const u , unsigned long v ) ; +# 616 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_mpi_scan(gcry_mpi_t *ret_mpi , enum gcry_mpi_format format , + void const *buffer , size_t buflen , size_t *nscanned ) ; +# 625 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_mpi_print(enum gcry_mpi_format format , unsigned char *buffer , + size_t buflen , size_t *nwritten , gcry_mpi_t const a ) ; +# 634 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_mpi_aprint(enum gcry_mpi_format format , unsigned char **buffer , + size_t *nwritten , gcry_mpi_t const a ) ; +# 642 "/usr/include/gcrypt.h" +extern void gcry_mpi_dump(gcry_mpi_t const a ) ; +# 646 "/usr/include/gcrypt.h" +extern void gcry_mpi_add(gcry_mpi_t w , gcry_mpi_t u , gcry_mpi_t v ) ; +# 649 "/usr/include/gcrypt.h" +extern void gcry_mpi_add_ui(gcry_mpi_t w , gcry_mpi_t u , unsigned long v ) ; +# 652 "/usr/include/gcrypt.h" +extern void gcry_mpi_addm(gcry_mpi_t w , gcry_mpi_t u , gcry_mpi_t v , gcry_mpi_t m ) ; +# 655 "/usr/include/gcrypt.h" +extern void gcry_mpi_sub(gcry_mpi_t w , gcry_mpi_t u , gcry_mpi_t v ) ; +# 658 "/usr/include/gcrypt.h" +extern void gcry_mpi_sub_ui(gcry_mpi_t w , gcry_mpi_t u , unsigned long v ) ; +# 661 "/usr/include/gcrypt.h" +extern void gcry_mpi_subm(gcry_mpi_t w , gcry_mpi_t u , gcry_mpi_t v , gcry_mpi_t m ) ; +# 664 "/usr/include/gcrypt.h" +extern void gcry_mpi_mul(gcry_mpi_t w , gcry_mpi_t u , gcry_mpi_t v ) ; +# 667 "/usr/include/gcrypt.h" +extern void gcry_mpi_mul_ui(gcry_mpi_t w , gcry_mpi_t u , unsigned long v ) ; +# 670 "/usr/include/gcrypt.h" +extern void gcry_mpi_mulm(gcry_mpi_t w , gcry_mpi_t u , gcry_mpi_t v , gcry_mpi_t m ) ; +# 673 "/usr/include/gcrypt.h" +extern void gcry_mpi_mul_2exp(gcry_mpi_t w , gcry_mpi_t u , unsigned long cnt ) ; +# 677 "/usr/include/gcrypt.h" +extern void gcry_mpi_div(gcry_mpi_t q , gcry_mpi_t r , gcry_mpi_t dividend , gcry_mpi_t divisor , + int round ) ; +# 681 "/usr/include/gcrypt.h" +extern void gcry_mpi_mod(gcry_mpi_t r , gcry_mpi_t dividend , gcry_mpi_t divisor ) ; +# 684 "/usr/include/gcrypt.h" +extern void gcry_mpi_powm(gcry_mpi_t w , gcry_mpi_t const b , gcry_mpi_t const e , + gcry_mpi_t const m ) ; +# 690 "/usr/include/gcrypt.h" +extern int gcry_mpi_gcd(gcry_mpi_t g , gcry_mpi_t a , gcry_mpi_t b ) ; +# 694 "/usr/include/gcrypt.h" +extern int gcry_mpi_invm(gcry_mpi_t x , gcry_mpi_t a , gcry_mpi_t m ) ; +# 698 "/usr/include/gcrypt.h" +extern unsigned int gcry_mpi_get_nbits(gcry_mpi_t a ) ; +# 701 "/usr/include/gcrypt.h" +extern int gcry_mpi_test_bit(gcry_mpi_t a , unsigned int n ) ; +# 704 "/usr/include/gcrypt.h" +extern void gcry_mpi_set_bit(gcry_mpi_t a , unsigned int n ) ; +# 707 "/usr/include/gcrypt.h" +extern void gcry_mpi_clear_bit(gcry_mpi_t a , unsigned int n ) ; +# 710 "/usr/include/gcrypt.h" +extern void gcry_mpi_set_highbit(gcry_mpi_t a , unsigned int n ) ; +# 713 "/usr/include/gcrypt.h" +extern void gcry_mpi_clear_highbit(gcry_mpi_t a , unsigned int n ) ; +# 716 "/usr/include/gcrypt.h" +extern void gcry_mpi_rshift(gcry_mpi_t x , gcry_mpi_t a , unsigned int n ) ; +# 719 "/usr/include/gcrypt.h" +extern void gcry_mpi_lshift(gcry_mpi_t x , gcry_mpi_t a , unsigned int n ) ; +# 724 "/usr/include/gcrypt.h" +extern gcry_mpi_t gcry_mpi_set_opaque(gcry_mpi_t a , void *p , unsigned int nbits ) ; +# 729 "/usr/include/gcrypt.h" +extern void *gcry_mpi_get_opaque(gcry_mpi_t a , unsigned int *nbits ) ; +# 734 "/usr/include/gcrypt.h" +extern void gcry_mpi_set_flag(gcry_mpi_t a , enum gcry_mpi_flag flag ) ; +# 738 "/usr/include/gcrypt.h" +extern void gcry_mpi_clear_flag(gcry_mpi_t a , enum gcry_mpi_flag flag ) ; +# 741 "/usr/include/gcrypt.h" +extern int gcry_mpi_get_flag(gcry_mpi_t a , enum gcry_mpi_flag flag ) ; +# 873 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_cipher_open(gcry_cipher_hd_t *handle , int algo , int mode , + unsigned int flags ) ; +# 877 "/usr/include/gcrypt.h" +extern void gcry_cipher_close(gcry_cipher_hd_t h ) ; +# 880 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_cipher_ctl(gcry_cipher_hd_t h , int cmd , void *buffer , + size_t buflen ) ; +# 884 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_cipher_info(gcry_cipher_hd_t h , int what , void *buffer , + size_t *nbytes ) ; +# 888 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_cipher_algo_info(int algo , int what , void *buffer , size_t *nbytes ) ; +# 894 "/usr/include/gcrypt.h" +extern char const *gcry_cipher_algo_name(int algorithm ) __attribute__((__pure__)) ; +# 898 "/usr/include/gcrypt.h" +extern int gcry_cipher_map_name(char const *name ) __attribute__((__pure__)) ; +# 903 "/usr/include/gcrypt.h" +extern int gcry_cipher_mode_from_oid(char const *string ) __attribute__((__pure__)) ; +# 909 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_cipher_encrypt(gcry_cipher_hd_t h , void *out , size_t outsize , + void const *in , size_t inlen ) ; +# 914 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_cipher_decrypt(gcry_cipher_hd_t h , void *out , size_t outsize , + void const *in , size_t inlen ) ; +# 919 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_cipher_setkey(gcry_cipher_hd_t hd , void const *key , size_t keylen ) ; +# 924 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_cipher_setiv(gcry_cipher_hd_t hd , void const *iv , size_t ivlen ) ; +# 941 "/usr/include/gcrypt.h" +extern gpg_error_t gcry_cipher_setctr(gcry_cipher_hd_t hd , void const *ctr , size_t ctrlen ) ; +# 945 "/usr/include/gcrypt.h" +extern size_t gcry_cipher_get_algo_keylen(int algo ) ; +# 948 "/usr/include/gcrypt.h" +extern size_t gcry_cipher_get_algo_blklen(int algo ) ; +# 960 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_cipher_list(int *list , int *list_length ) ; +# 991 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_pk_encrypt(gcry_sexp_t *result , gcry_sexp_t data , gcry_sexp_t pkey ) ; +# 996 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_pk_decrypt(gcry_sexp_t *result , gcry_sexp_t data , gcry_sexp_t skey ) ; +# 1001 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_pk_sign(gcry_sexp_t *result , gcry_sexp_t data , gcry_sexp_t skey ) ; +# 1005 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_pk_verify(gcry_sexp_t sigval , gcry_sexp_t data , gcry_sexp_t pkey ) ; +# 1009 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_pk_testkey(gcry_sexp_t key ) ; +# 1014 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_pk_genkey(gcry_sexp_t *r_key , gcry_sexp_t s_parms ) ; +# 1017 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_pk_ctl(int cmd , void *buffer , size_t buflen ) ; +# 1020 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_pk_algo_info(int algo , int what , void *buffer , size_t *nbytes ) ; +# 1026 "/usr/include/gcrypt.h" +extern char const *gcry_pk_algo_name(int algorithm ) __attribute__((__pure__)) ; +# 1030 "/usr/include/gcrypt.h" +extern int gcry_pk_map_name(char const *name ) __attribute__((__pure__)) ; +# 1034 "/usr/include/gcrypt.h" +extern unsigned int gcry_pk_get_nbits(gcry_sexp_t key ) __attribute__((__pure__)) ; +# 1038 "/usr/include/gcrypt.h" +extern unsigned char *gcry_pk_get_keygrip(gcry_sexp_t key , unsigned char *array ) ; +# 1041 "/usr/include/gcrypt.h" +extern char const *gcry_pk_get_curve(gcry_sexp_t key , int iterator , unsigned int *r_nbits ) ; +# 1046 "/usr/include/gcrypt.h" +extern gcry_sexp_t gcry_pk_get_param(int algo , char const *name ) ; +# 1058 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_pk_list(int *list , int *list_length ) ; +# 1126 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_md_open(gcry_md_hd_t *h , int algo , unsigned int flags ) ; +# 1129 "/usr/include/gcrypt.h" +extern void gcry_md_close(gcry_md_hd_t hd ) ; +# 1132 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_md_enable(gcry_md_hd_t hd , int algo ) ; +# 1135 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_md_copy(gcry_md_hd_t *bhd , gcry_md_hd_t ahd ) ; +# 1138 "/usr/include/gcrypt.h" +extern void gcry_md_reset(gcry_md_hd_t hd ) ; +# 1141 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_md_ctl(gcry_md_hd_t hd , int cmd , void *buffer , size_t buflen ) ; +# 1147 "/usr/include/gcrypt.h" +extern void gcry_md_write(gcry_md_hd_t hd , void const *buffer , size_t length ) ; +# 1151 "/usr/include/gcrypt.h" +extern unsigned char *gcry_md_read(gcry_md_hd_t hd , int algo ) ; +# 1158 "/usr/include/gcrypt.h" +extern void gcry_md_hash_buffer(int algo , void *digest , void const *buffer , size_t length ) ; +# 1163 "/usr/include/gcrypt.h" +extern int gcry_md_get_algo(gcry_md_hd_t hd ) ; +# 1167 "/usr/include/gcrypt.h" +extern unsigned int gcry_md_get_algo_dlen(int algo ) ; +# 1171 "/usr/include/gcrypt.h" +extern int gcry_md_is_enabled(gcry_md_hd_t a , int algo ) ; +# 1174 "/usr/include/gcrypt.h" +extern int gcry_md_is_secure(gcry_md_hd_t a ) ; +# 1177 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_md_info(gcry_md_hd_t h , int what , void *buffer , size_t *nbytes ) ; +# 1181 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_md_algo_info(int algo , int what , void *buffer , size_t *nbytes ) ; +# 1187 "/usr/include/gcrypt.h" +extern char const *gcry_md_algo_name(int algo ) __attribute__((__pure__)) ; +# 1191 "/usr/include/gcrypt.h" +extern int gcry_md_map_name(char const *name ) __attribute__((__pure__)) ; +# 1195 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_md_setkey(gcry_md_hd_t hd , void const *key , size_t keylen ) ; +# 1200 "/usr/include/gcrypt.h" +extern void gcry_md_debug(gcry_md_hd_t hd , char const *suffix ) ; +# 1249 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_md_list(int *list , int *list_length ) ; +# 1407 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_new(gcry_ac_data_t *data ) __attribute__((__deprecated__)) ; +# 1411 "/usr/include/gcrypt.h" +extern void gcry_ac_data_destroy(gcry_ac_data_t data ) __attribute__((__deprecated__)) ; +# 1415 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_copy(gcry_ac_data_t *data_cp , gcry_ac_data_t data ) __attribute__((__deprecated__)) ; +# 1421 "/usr/include/gcrypt.h" +extern unsigned int gcry_ac_data_length(gcry_ac_data_t data ) __attribute__((__deprecated__)) ; +# 1425 "/usr/include/gcrypt.h" +extern void gcry_ac_data_clear(gcry_ac_data_t data ) __attribute__((__deprecated__)) ; +# 1433 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_set(gcry_ac_data_t data , unsigned int flags , char const *name , + gcry_mpi_t mpi ) __attribute__((__deprecated__)) ; +# 1440 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_get_name(gcry_ac_data_t data , unsigned int flags , + char const *name , gcry_mpi_t *mpi ) __attribute__((__deprecated__)) ; +# 1448 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_get_index(gcry_ac_data_t data , unsigned int flags , + unsigned int idx , char const **name , + gcry_mpi_t *mpi ) __attribute__((__deprecated__)) ; +# 1456 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_to_sexp(gcry_ac_data_t data , gcry_sexp_t *sexp , + char const **identifiers ) __attribute__((__deprecated__)) ; +# 1463 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_from_sexp(gcry_ac_data_t *data , gcry_sexp_t sexp , + char const **identifiers ) __attribute__((__deprecated__)) ; +# 1470 "/usr/include/gcrypt.h" +extern void gcry_ac_io_init(gcry_ac_io_t *ac_io , gcry_ac_io_mode_t mode , gcry_ac_io_type_t type + , ...) __attribute__((__deprecated__)) ; +# 1477 "/usr/include/gcrypt.h" +extern void gcry_ac_io_init_va(gcry_ac_io_t *ac_io , gcry_ac_io_mode_t mode , gcry_ac_io_type_t type , + va_list ap ) __attribute__((__deprecated__)) ; +# 1482 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_open(gcry_ac_handle_t *handle , gcry_ac_id_t algorithm , + unsigned int flags ) __attribute__((__deprecated__)) ; +# 1487 "/usr/include/gcrypt.h" +extern void gcry_ac_close(gcry_ac_handle_t handle ) __attribute__((__deprecated__)) ; +# 1491 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_key_init(gcry_ac_key_t *key , gcry_ac_handle_t handle , + gcry_ac_key_type_t type , gcry_ac_data_t data ) __attribute__((__deprecated__)) ; +# 1500 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_key_pair_generate(gcry_ac_handle_t handle , unsigned int nbits , + void *spec , gcry_ac_key_pair_t *key_pair , + gcry_mpi_t **misc_data ) __attribute__((__deprecated__)) ; +# 1507 "/usr/include/gcrypt.h" +extern gcry_ac_key_t gcry_ac_key_pair_extract(gcry_ac_key_pair_t key_pair , gcry_ac_key_type_t which ) __attribute__((__deprecated__)) ; +# 1512 "/usr/include/gcrypt.h" +extern gcry_ac_data_t gcry_ac_key_data_get(gcry_ac_key_t key ) __attribute__((__deprecated__)) ; +# 1516 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_key_test(gcry_ac_handle_t handle , gcry_ac_key_t key ) __attribute__((__deprecated__)) ; +# 1520 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_key_get_nbits(gcry_ac_handle_t handle , gcry_ac_key_t key , + unsigned int *nbits ) __attribute__((__deprecated__)) ; +# 1526 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_key_get_grip(gcry_ac_handle_t handle , gcry_ac_key_t key , + unsigned char *key_grip ) __attribute__((__deprecated__)) ; +# 1531 "/usr/include/gcrypt.h" +extern void gcry_ac_key_destroy(gcry_ac_key_t key ) __attribute__((__deprecated__)) ; +# 1535 "/usr/include/gcrypt.h" +extern void gcry_ac_key_pair_destroy(gcry_ac_key_pair_t key_pair ) __attribute__((__deprecated__)) ; +# 1541 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_encode(gcry_ac_em_t method , unsigned int flags , + void *options , gcry_ac_io_t *io_read , gcry_ac_io_t *io_write ) __attribute__((__deprecated__)) ; +# 1550 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_decode(gcry_ac_em_t method , unsigned int flags , + void *options , gcry_ac_io_t *io_read , gcry_ac_io_t *io_write ) __attribute__((__deprecated__)) ; +# 1559 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_encrypt(gcry_ac_handle_t handle , unsigned int flags , + gcry_ac_key_t key , gcry_mpi_t data_plain , + gcry_ac_data_t *data_encrypted ) __attribute__((__deprecated__)) ; +# 1569 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_decrypt(gcry_ac_handle_t handle , unsigned int flags , + gcry_ac_key_t key , gcry_mpi_t *data_plain , + gcry_ac_data_t data_encrypted ) __attribute__((__deprecated__)) ; +# 1578 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_sign(gcry_ac_handle_t handle , gcry_ac_key_t key , + gcry_mpi_t data , gcry_ac_data_t *data_signature ) __attribute__((__deprecated__)) ; +# 1587 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_verify(gcry_ac_handle_t handle , gcry_ac_key_t key , + gcry_mpi_t data , gcry_ac_data_t data_signature ) __attribute__((__deprecated__)) ; +# 1598 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_encrypt_scheme(gcry_ac_handle_t handle , gcry_ac_scheme_t scheme , + unsigned int flags , void *opts , + gcry_ac_key_t key , gcry_ac_io_t *io_message , + gcry_ac_io_t *io_cipher ) __attribute__((__deprecated__)) ; +# 1611 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_decrypt_scheme(gcry_ac_handle_t handle , gcry_ac_scheme_t scheme , + unsigned int flags , void *opts , + gcry_ac_key_t key , gcry_ac_io_t *io_cipher , + gcry_ac_io_t *io_message ) __attribute__((__deprecated__)) ; +# 1624 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_sign_scheme(gcry_ac_handle_t handle , gcry_ac_scheme_t scheme , + unsigned int flags , void *opts , gcry_ac_key_t key , + gcry_ac_io_t *io_message , gcry_ac_io_t *io_signature ) __attribute__((__deprecated__)) ; +# 1638 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_data_verify_scheme(gcry_ac_handle_t handle , gcry_ac_scheme_t scheme , + unsigned int flags , void *opts , gcry_ac_key_t key , + gcry_ac_io_t *io_message , gcry_ac_io_t *io_signature ) __attribute__((__deprecated__)) ; +# 1649 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_id_to_name(gcry_ac_id_t algorithm , char const **name ) __attribute__((__deprecated__)) ; +# 1655 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_ac_name_to_id(char const *name , gcry_ac_id_t *algorithm ) __attribute__((__deprecated__)) ; +# 1679 "/usr/include/gcrypt.h" +extern gpg_error_t gcry_kdf_derive(void const *passphrase , size_t passphraselen , + int algo , int subalgo , void const *salt , size_t saltlen , + unsigned long iterations , size_t keysize , void *keybuffer ) ; +# 1708 "/usr/include/gcrypt.h" +extern void gcry_randomize(void *buffer , size_t length , enum gcry_random_level level ) ; +# 1714 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_random_add_bytes(void const *buffer , size_t length , int quality ) ; +# 1725 "/usr/include/gcrypt.h" +extern void *gcry_random_bytes(size_t nbytes , enum gcry_random_level level ) __attribute__((__malloc__)) ; +# 1731 "/usr/include/gcrypt.h" +extern void *gcry_random_bytes_secure(size_t nbytes , enum gcry_random_level level ) __attribute__((__malloc__)) ; +# 1738 "/usr/include/gcrypt.h" +extern void gcry_mpi_randomize(gcry_mpi_t w , unsigned int nbits , enum gcry_random_level level ) ; +# 1743 "/usr/include/gcrypt.h" +extern void gcry_create_nonce(void *buffer , size_t length ) ; +# 1780 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_prime_generate(gcry_mpi_t *prime , unsigned int prime_bits , + unsigned int factor_bits , gcry_mpi_t **factors , + int (*cb_func)(void *arg , int mode , gcry_mpi_t candidate ) , + void *cb_arg , gcry_random_level_t random_level , + unsigned int flags ) ; +# 1793 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_prime_group_generator(gcry_mpi_t *r_g , gcry_mpi_t prime , + gcry_mpi_t *factors , gcry_mpi_t start_g ) ; +# 1800 "/usr/include/gcrypt.h" +extern void gcry_prime_release_factors(gcry_mpi_t *factors ) ; +# 1804 "/usr/include/gcrypt.h" +extern gcry_error_t gcry_prime_check(gcry_mpi_t x , unsigned int flags ) ; +# 1852 "/usr/include/gcrypt.h" +extern void gcry_set_progress_handler(void (*cb)(void * , char const * , int , + int , int ) , void *cb_data ) ; +# 1856 "/usr/include/gcrypt.h" +extern void gcry_set_allocation_handler(void *(*func_alloc)(size_t n ) , void *(*func_alloc_secure)(size_t n ) , + int (*func_secure_check)(void const * ) , + void *(*func_realloc)(void *p , size_t n ) , + void (*func_free)(void * ) ) ; +# 1865 "/usr/include/gcrypt.h" +extern void gcry_set_outofcore_handler(int (*h)(void * , size_t , unsigned int ) , + void *opaque ) ; +# 1869 "/usr/include/gcrypt.h" +extern void gcry_set_fatalerror_handler(void (*fnc)(void * , int , char const * ) , + void *opaque ) ; +# 1873 "/usr/include/gcrypt.h" +extern void gcry_set_log_handler(void (*f)(void * , int , char const * , va_list ) , + void *opaque ) ; +# 1876 "/usr/include/gcrypt.h" +extern void gcry_set_gettext_handler(char const *(*f)(char const * ) ) ; +# 1880 "/usr/include/gcrypt.h" +extern void *gcry_malloc(size_t n ) __attribute__((__malloc__)) ; +# 1881 "/usr/include/gcrypt.h" +extern void *gcry_calloc(size_t n , size_t m ) __attribute__((__malloc__)) ; +# 1882 "/usr/include/gcrypt.h" +extern void *gcry_malloc_secure(size_t n ) __attribute__((__malloc__)) ; +# 1883 "/usr/include/gcrypt.h" +extern void *gcry_calloc_secure(size_t n , size_t m ) __attribute__((__malloc__)) ; +# 1884 "/usr/include/gcrypt.h" +extern void *gcry_realloc(void *a , size_t n ) ; +# 1885 "/usr/include/gcrypt.h" +extern char *gcry_strdup(char const *string ) __attribute__((__malloc__)) ; +# 1886 "/usr/include/gcrypt.h" +extern void *gcry_xmalloc(size_t n ) __attribute__((__malloc__)) ; +# 1887 "/usr/include/gcrypt.h" +extern void *gcry_xcalloc(size_t n , size_t m ) __attribute__((__malloc__)) ; +# 1888 "/usr/include/gcrypt.h" +extern void *gcry_xmalloc_secure(size_t n ) __attribute__((__malloc__)) ; +# 1889 "/usr/include/gcrypt.h" +extern void *gcry_xcalloc_secure(size_t n , size_t m ) __attribute__((__malloc__)) ; +# 1890 "/usr/include/gcrypt.h" +extern void *gcry_xrealloc(void *a , size_t n ) ; +# 1891 "/usr/include/gcrypt.h" +extern char *gcry_xstrdup(char const *a ) __attribute__((__malloc__)) ; +# 1892 "/usr/include/gcrypt.h" +extern void gcry_free(void *a ) ; +# 1895 "/usr/include/gcrypt.h" +extern int gcry_is_secure(void const *a ) __attribute__((__pure__)) ; +# 99 "/usr/include/gcrypt-module.h" +extern gcry_error_t gcry_cipher_register(gcry_cipher_spec_t *cipher , int *algorithm_id , + gcry_module_t *module ) __attribute__((__deprecated__)) ; +# 107 "/usr/include/gcrypt-module.h" +extern void gcry_cipher_unregister(gcry_module_t module ) __attribute__((__deprecated__)) ; +# 177 "/usr/include/gcrypt-module.h" +extern gcry_error_t gcry_pk_register(gcry_pk_spec_t *pubkey , unsigned int *algorithm_id , + gcry_module_t *module ) __attribute__((__deprecated__)) ; +# 184 "/usr/include/gcrypt-module.h" +extern void gcry_pk_unregister(gcry_module_t module ) __attribute__((__deprecated__)) ; +# 224 "/usr/include/gcrypt-module.h" +extern gcry_error_t gcry_md_register(gcry_md_spec_t *digest , unsigned int *algorithm_id , + gcry_module_t *module ) __attribute__((__deprecated__)) ; +# 231 "/usr/include/gcrypt-module.h" +extern void gcry_md_unregister(gcry_module_t module ) __attribute__((__deprecated__)) ; +# 40 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +static struct __anonstruct___obliv_c__bool_42 const __obliv_c__trueCond = {{{(_Bool )0, {(_Bool )1}}}}; +# 44 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__assignBitKnown(OblivBit___0 *dest , _Bool value ) ; +# 45 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__copyBit(OblivBit___0 *dest , OblivBit___0 const *src ) ; +# 46 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern _Bool __obliv_c__bitIsKnown(_Bool *val , OblivBit___0 const *bit ) ; +# 49 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setBitAnd(OblivBit___0 *dest , OblivBit___0 const *a , OblivBit___0 const *b ) ; +# 50 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setBitOr(OblivBit___0 *dest , OblivBit___0 const *a , OblivBit___0 const *b ) ; +# 51 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setBitXor(OblivBit___0 *dest , OblivBit___0 const *a , OblivBit___0 const *b ) ; +# 52 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setBitNot(OblivBit___0 *dest , OblivBit___0 const *a ) ; +# 53 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__flipBit(OblivBit___0 *dest ) ; +# 58 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern int ocCurrentParty(void) ; +# 63 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setSignedKnown(void *dest , size_t size , long long value ) ; +# 65 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setUnsignedKnown(void *dest , size_t size , unsigned long long value ) ; +# 67 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setBitsKnown(OblivBit___0 *dest , _Bool const *value , size_t size ) ; +# 68 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__copyBits(OblivBit___0 *dest , OblivBit___0 const *src , size_t size ) ; +# 70 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern _Bool __obliv_c__allBitsKnown(OblivBit___0 const *bits , _Bool *dest , size_t size ) ; +# 72 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setBitwiseAnd(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +# 75 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setBitwiseOr(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +# 78 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setBitwiseXor(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +# 81 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setBitwiseNot(void *dest , void const *op , size_t size ) ; +# 82 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setBitwiseNotInPlace(void *dest , size_t size ) ; +# 83 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setLShift(void *vdest , void const *vsrc , size_t size , + unsigned int shiftAmt ) ; +# 85 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setRShiftSigned(void *vdest , void const *vsrc , size_t size , + unsigned int shiftAmt ) ; +# 87 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setRShiftUnsigned(void *vdest , void const *vsrc , size_t size , + unsigned int shiftAmt ) ; +# 89 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setRShift(void *vdest , void const *vsrc , size_t size , + unsigned int shiftAmt , _Bool isSigned ) ; +# 97 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setPlainAdd(void *vdest , void const *vop1 , void const *vop2 , + size_t size ) ; +# 100 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setPlainSub(void *vdest , void const *vop1 , void const *vop2 , + size_t size ) ; +# 103 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setBitsAdd(void *dest , void *carryOut , void const *op1 , + void const *op2 , void const *carryIn , size_t size ) ; +# 107 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setNeg(void *vdest , void const *vsrc , size_t n ) ; +# 108 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__condNeg(void const *vcond , void *vdest , void const *vsrc , + size_t n ) ; +# 112 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setMul(void *vdest , void const *vop1 , void const *vop2 , + size_t size ) ; +# 115 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setDivModUnsigned(void *vquot , void *vrem , void const *vop1 , + void const *vop2 , size_t size ) ; +# 118 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setDivModSigned(void *vquot , void *vrem , void const *vop1 , + void const *vop2 , size_t size ) ; +# 121 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setDivUnsigned(void *vdest , void const *vop1 , void const *vop2 , + size_t size ) ; +# 124 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setModUnsigned(void *vdest , void const *vop1 , void const *vop2 , + size_t size ) ; +# 127 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setDivSigned(void *vdest , void const *vop1 , void const *vop2 , + size_t size ) ; +# 130 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setModSigned(void *vdest , void const *vop1 , void const *vop2 , + size_t size ) ; +# 134 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setBitsSub(void *dest , void *borrowOut , void const *op1 , + void const *op2 , void const *borrowIn , size_t size ) ; +# 137 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setSignExtend(void *dest , size_t dsize , void const *src , + size_t ssize ) ; +# 139 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setZeroExtend(void *dest , size_t dsize , void const *src , + size_t ssize ) ; +# 141 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__ifThenElse(void *dest , void const *tsrc , void const *fsrc , + size_t size , void const *cond ) ; +# 144 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setLessThanUnit(OblivBit___0 *ltOut , OblivBit___0 const *op1 , + OblivBit___0 const *op2 , size_t size , OblivBit___0 const *ltIn ) ; +# 147 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setLessThanUnsigned(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +# 150 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setLessOrEqualUnsigned(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +# 153 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setLessThanSigned(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +# 156 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setLessOrEqualSigned(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +# 159 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setEqualTo(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +# 162 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setNotEqual(void *dest , void const *op1 , void const *op2 , + size_t size ) ; +# 165 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__setLogicalNot(void *dest , void const *op , size_t size ) ; +# 167 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__condAssign(void const *cond , void *dest , void const *src , + size_t size ) ; +# 170 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +__inline static void __obliv_c__condAssignKnown(void const *cond , void *dest , + size_t size , widest_t val ) +{ + OblivBit___0 ov[(unsigned long )8 * (unsigned long )sizeof(widest_t )] ; + unsigned long __cil_tmp6 ; + unsigned long __cil_tmp7 ; + OblivBit___0 *__cil_tmp8 ; + void *__cil_tmp9 ; + unsigned long __cil_tmp10 ; + unsigned long __cil_tmp11 ; + OblivBit___0 *__cil_tmp12 ; + void const *__cil_tmp13 ; + void const *__cil_tmp14 ; + + { +# 49 "mutual.oc" + memset((void *)(& ov), 0, sizeof(OblivBit___0 [(unsigned long )8 * (unsigned long )sizeof(widest_t )])); +# 175 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" + __cil_tmp6 = 0 * 13UL; +# 175 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" + __cil_tmp7 = (unsigned long )(ov) + __cil_tmp6; +# 175 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" + __cil_tmp8 = (OblivBit___0 *)__cil_tmp7; +# 175 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" + __cil_tmp9 = (void *)__cil_tmp8; +# 175 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" + __obliv_c__setSignedKnown(__cil_tmp9, size, val); +# 176 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" + __cil_tmp10 = 0 * 13UL; +# 176 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" + __cil_tmp11 = (unsigned long )(ov) + __cil_tmp10; +# 176 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" + __cil_tmp12 = (OblivBit___0 *)__cil_tmp11; +# 176 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" + __cil_tmp13 = (void const *)__cil_tmp12; +# 176 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" + __cil_tmp14 = (void const *)dest; +# 176 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" + __obliv_c__ifThenElse(dest, __cil_tmp13, __cil_tmp14, size, cond); +# 177 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" + return; +} +} +# 179 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__condAdd(void const *c , void *dest , void const *x , size_t size ) ; +# 182 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" +extern void __obliv_c__condSub(void const *c , void *dest , void const *x , size_t size ) ; +# 348 "/usr/include/libio.h" +extern struct _IO_FILE_plus _IO_2_1_stdin_ ; +# 349 "/usr/include/libio.h" +extern struct _IO_FILE_plus _IO_2_1_stdout_ ; +# 350 "/usr/include/libio.h" +extern struct _IO_FILE_plus _IO_2_1_stderr_ ; +# 418 "/usr/include/libio.h" +extern int __underflow(_IO_FILE * ) ; +# 419 "/usr/include/libio.h" +extern int __uflow(_IO_FILE * ) ; +# 420 "/usr/include/libio.h" +extern int __overflow(_IO_FILE * , int ) ; +# 462 "/usr/include/libio.h" +extern int _IO_getc(_IO_FILE *__fp ) ; +# 463 "/usr/include/libio.h" +extern int _IO_putc(int __c , _IO_FILE *__fp ) ; +# 464 "/usr/include/libio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) _IO_feof)(_IO_FILE *__fp ) ; +# 465 "/usr/include/libio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) _IO_ferror)(_IO_FILE *__fp ) ; +# 467 "/usr/include/libio.h" +extern int _IO_peekc_locked(_IO_FILE *__fp ) ; +# 473 "/usr/include/libio.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) _IO_flockfile)(_IO_FILE * ) ; +# 474 "/usr/include/libio.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) _IO_funlockfile)(_IO_FILE * ) ; +# 475 "/usr/include/libio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) _IO_ftrylockfile)(_IO_FILE * ) ; +# 492 "/usr/include/libio.h" +extern int _IO_vfscanf(_IO_FILE * __restrict , char const * __restrict , __gnuc_va_list , + int * __restrict ) ; +# 494 "/usr/include/libio.h" +extern int _IO_vfprintf(_IO_FILE * __restrict , char const * __restrict , __gnuc_va_list ) ; +# 496 "/usr/include/libio.h" +extern __ssize_t _IO_padn(_IO_FILE * , int , __ssize_t ) ; +# 497 "/usr/include/libio.h" +extern size_t _IO_sgetn(_IO_FILE * , void * , size_t ) ; +# 499 "/usr/include/libio.h" +extern __off64_t _IO_seekoff(_IO_FILE * , __off64_t , int , int ) ; +# 500 "/usr/include/libio.h" +extern __off64_t _IO_seekpos(_IO_FILE * , __off64_t , int ) ; +# 502 "/usr/include/libio.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) _IO_free_backup_area)(_IO_FILE * ) ; +# 169 "/usr/include/stdio.h" +extern struct _IO_FILE *stdin ; +# 170 "/usr/include/stdio.h" +extern struct _IO_FILE *stdout ; +# 171 "/usr/include/stdio.h" +extern struct _IO_FILE *stderr ; +# 179 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) remove)(char const *__filename ) ; +# 181 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) rename)(char const *__old , + char const *__new ) ; +# 186 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) renameat)(int __oldfd , + char const *__old , + int __newfd , + char const *__new ) ; +# 196 "/usr/include/stdio.h" +extern FILE *tmpfile(void) ; +# 210 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) tmpnam)(char *__s ) ; +# 216 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) tmpnam_r)(char *__s ) ; +# 228 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) tempnam)(char const *__dir , + char const *__pfx ) __attribute__((__malloc__)) ; +# 238 "/usr/include/stdio.h" +extern int fclose(FILE *__stream ) ; +# 243 "/usr/include/stdio.h" +extern int fflush(FILE *__stream ) ; +# 253 "/usr/include/stdio.h" +extern int fflush_unlocked(FILE *__stream ) ; +# 273 "/usr/include/stdio.h" +extern FILE *fopen(char const * __restrict __filename , char const * __restrict __modes ) ; +# 279 "/usr/include/stdio.h" +extern FILE *freopen(char const * __restrict __filename , char const * __restrict __modes , + FILE * __restrict __stream ) ; +# 307 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) FILE *( __attribute__((__leaf__)) fdopen)(int __fd , + char const *__modes ) ; +# 320 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) FILE *( __attribute__((__leaf__)) fmemopen)(void *__s , + size_t __len , + char const *__modes ) ; +# 326 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) FILE *( __attribute__((__leaf__)) open_memstream)(char **__bufloc , + size_t *__sizeloc ) ; +# 333 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) setbuf)(FILE * __restrict __stream , + char * __restrict __buf ) ; +# 337 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) setvbuf)(FILE * __restrict __stream , + char * __restrict __buf , + int __modes , + size_t __n ) ; +# 344 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) setbuffer)(FILE * __restrict __stream , + char * __restrict __buf , + size_t __size ) ; +# 348 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) setlinebuf)(FILE *__stream ) ; +# 357 "/usr/include/stdio.h" +extern int fprintf(FILE * __restrict __stream , char const * __restrict __format + , ...) ; +# 363 "/usr/include/stdio.h" +extern int printf(char const * __restrict __format , ...) ; +# 365 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int sprintf(char * __restrict __s , char const * __restrict __format + , ...) ; +# 372 "/usr/include/stdio.h" +extern int vfprintf(FILE * __restrict __s , char const * __restrict __format , + __gnuc_va_list __arg ) ; +# 378 "/usr/include/stdio.h" +extern int vprintf(char const * __restrict __format , __gnuc_va_list __arg ) ; +# 380 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int vsprintf(char * __restrict __s , char const * __restrict __format , + __gnuc_va_list __arg ) ; +# 387 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( snprintf)(char * __restrict __s , + size_t __maxlen , + char const * __restrict __format + , ...) ; +# 391 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( vsnprintf)(char * __restrict __s , + size_t __maxlen , + char const * __restrict __format , + __gnuc_va_list __arg ) ; +# 418 "/usr/include/stdio.h" +extern int ( vdprintf)(int __fd , char const * __restrict __fmt , + __gnuc_va_list __arg ) ; +# 421 "/usr/include/stdio.h" +extern int ( dprintf)(int __fd , char const * __restrict __fmt + , ...) ; +# 431 "/usr/include/stdio.h" +extern int fscanf(FILE * __restrict __stream , char const * __restrict __format + , ...) __asm__("__isoc99_fscanf") ; +# 437 "/usr/include/stdio.h" +extern int scanf(char const * __restrict __format , ...) __asm__("__isoc99_scanf") ; +# 439 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) sscanf)(char const * __restrict __s , + char const * __restrict __format + , ...) __asm__("__isoc99_sscanf") ; +# 477 "/usr/include/stdio.h" +extern int ( vfscanf)(FILE * __restrict __s , char const * __restrict __format , + __gnuc_va_list __arg ) __asm__("__isoc99_vfscanf") ; +# 485 "/usr/include/stdio.h" +extern int ( vscanf)(char const * __restrict __format , + __gnuc_va_list __arg ) __asm__("__isoc99_vscanf") ; +# 489 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) vsscanf)(char const * __restrict __s , + char const * __restrict __format , + __gnuc_va_list __arg ) __asm__("__isoc99_vsscanf") ; +# 537 "/usr/include/stdio.h" +extern int fgetc(FILE *__stream ) ; +# 538 "/usr/include/stdio.h" +extern int getc(FILE *__stream ) ; +# 544 "/usr/include/stdio.h" +extern int getchar(void) ; +# 556 "/usr/include/stdio.h" +extern int getc_unlocked(FILE *__stream ) ; +# 557 "/usr/include/stdio.h" +extern int getchar_unlocked(void) ; +# 567 "/usr/include/stdio.h" +extern int fgetc_unlocked(FILE *__stream ) ; +# 579 "/usr/include/stdio.h" +extern int fputc(int __c , FILE *__stream ) ; +# 580 "/usr/include/stdio.h" +extern int putc(int __c , FILE *__stream ) ; +# 586 "/usr/include/stdio.h" +extern int putchar(int __c ) ; +# 600 "/usr/include/stdio.h" +extern int fputc_unlocked(int __c , FILE *__stream ) ; +# 608 "/usr/include/stdio.h" +extern int putc_unlocked(int __c , FILE *__stream ) ; +# 609 "/usr/include/stdio.h" +extern int putchar_unlocked(int __c ) ; +# 616 "/usr/include/stdio.h" +extern int getw(FILE *__stream ) ; +# 619 "/usr/include/stdio.h" +extern int putw(int __w , FILE *__stream ) ; +# 628 "/usr/include/stdio.h" +extern char *fgets(char * __restrict __s , int __n , FILE * __restrict __stream ) ; +# 636 "/usr/include/stdio.h" +extern char *gets(char *__s ) ; +# 662 "/usr/include/stdio.h" +extern __ssize_t __getdelim(char ** __restrict __lineptr , size_t * __restrict __n , + int __delimiter , FILE * __restrict __stream ) ; +# 665 "/usr/include/stdio.h" +extern __ssize_t getdelim(char ** __restrict __lineptr , size_t * __restrict __n , + int __delimiter , FILE * __restrict __stream ) ; +# 675 "/usr/include/stdio.h" +extern __ssize_t getline(char ** __restrict __lineptr , size_t * __restrict __n , + FILE * __restrict __stream ) ; +# 686 "/usr/include/stdio.h" +extern int fputs(char const * __restrict __s , FILE * __restrict __stream ) ; +# 692 "/usr/include/stdio.h" +extern int puts(char const *__s ) ; +# 699 "/usr/include/stdio.h" +extern int ungetc(int __c , FILE *__stream ) ; +# 706 "/usr/include/stdio.h" +extern size_t fread(void * __restrict __ptr , size_t __size , size_t __n , FILE * __restrict __stream ) ; +# 712 "/usr/include/stdio.h" +extern size_t fwrite(void const * __restrict __ptr , size_t __size , size_t __n , + FILE * __restrict __s ) ; +# 734 "/usr/include/stdio.h" +extern size_t fread_unlocked(void * __restrict __ptr , size_t __size , size_t __n , + FILE * __restrict __stream ) ; +# 736 "/usr/include/stdio.h" +extern size_t fwrite_unlocked(void const * __restrict __ptr , size_t __size , size_t __n , + FILE * __restrict __stream ) ; +# 746 "/usr/include/stdio.h" +extern int fseek(FILE *__stream , long __off , int __whence ) ; +# 751 "/usr/include/stdio.h" +extern long ftell(FILE *__stream ) ; +# 756 "/usr/include/stdio.h" +extern void rewind(FILE *__stream ) ; +# 770 "/usr/include/stdio.h" +extern int fseeko(FILE *__stream , __off_t __off , int __whence ) ; +# 775 "/usr/include/stdio.h" +extern __off_t ftello(FILE *__stream ) ; +# 795 "/usr/include/stdio.h" +extern int fgetpos(FILE * __restrict __stream , fpos_t * __restrict __pos ) ; +# 800 "/usr/include/stdio.h" +extern int fsetpos(FILE *__stream , fpos_t const *__pos ) ; +# 823 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) clearerr)(FILE *__stream ) ; +# 825 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) feof)(FILE *__stream ) ; +# 827 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) ferror)(FILE *__stream ) ; +# 832 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) clearerr_unlocked)(FILE *__stream ) ; +# 833 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) feof_unlocked)(FILE *__stream ) ; +# 834 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) ferror_unlocked)(FILE *__stream ) ; +# 843 "/usr/include/stdio.h" +extern void perror(char const *__s ) ; +# 27 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" +extern int sys_nerr ; +# 28 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" +extern char const * const sys_errlist[] ; +# 855 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) fileno)(FILE *__stream ) ; +# 860 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) fileno_unlocked)(FILE *__stream ) ; +# 870 "/usr/include/stdio.h" +extern FILE *popen(char const *__command , char const *__modes ) ; +# 876 "/usr/include/stdio.h" +extern int pclose(FILE *__stream ) ; +# 882 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) char *( __attribute__((__leaf__)) ctermid)(char *__s ) ; +# 910 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) flockfile)(FILE *__stream ) ; +# 914 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) int ( __attribute__((__leaf__)) ftrylockfile)(FILE *__stream ) ; +# 917 "/usr/include/stdio.h" +extern __attribute__((__nothrow__)) void ( __attribute__((__leaf__)) funlockfile)(FILE *__stream ) ; +# 4 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern struct ProtocolDesc *ocCurrentProto(void) ; +# 7 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern void setupOblivBool(OblivInputs *spec , __obliv_c__bool *dest , _Bool v ) ; +# 8 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern void setupOblivChar(OblivInputs *spec , __obliv_c__char *dest , char v ) ; +# 9 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern void setupOblivInt(OblivInputs *spec , __obliv_c__int *dest , int v ) ; +# 10 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern void setupOblivShort(OblivInputs *spec , __obliv_c__short *dest , short v ) ; +# 11 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern void setupOblivLong(OblivInputs *spec , __obliv_c__long *dest , long v ) ; +# 12 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern void setupOblivLLong(OblivInputs *spec , __obliv_c__lLong *dest , long long v ) ; +# 14 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern void feedOblivInputs(OblivInputs *spec , size_t count , int party ) ; +# 17 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern __obliv_c__bool feedOblivBool(_Bool v , int party ) ; +# 18 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern __obliv_c__char feedOblivChar(char v , int party ) ; +# 19 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern __obliv_c__short feedOblivShort(short v , int party ) ; +# 20 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern __obliv_c__int feedOblivInt(int v , int party ) ; +# 21 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern __obliv_c__long feedOblivLong(long v , int party ) ; +# 22 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern __obliv_c__lLong feedOblivLLong(long long v , int party ) ; +# 27 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern _Bool revealOblivBool(_Bool *dest , __obliv_c__bool src , int party ) ; +# 28 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern _Bool revealOblivChar(char *dest , __obliv_c__char src , int party ) ; +# 29 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern _Bool revealOblivInt(int *dest , __obliv_c__int src , int party ) ; +# 30 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern _Bool revealOblivShort(short *dest , __obliv_c__short src , int party ) ; +# 31 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern _Bool revealOblivLong(long *dest , __obliv_c__long src , int party ) ; +# 32 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern _Bool revealOblivLLong(long long *dest , __obliv_c__lLong src , int party ) ; +# 34 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern _Bool ocBroadcastBool(int source , _Bool v ) ; +# 35 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern char ocBroadcastChar(int source , char v ) ; +# 36 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern int ocBroadcastInt(int source , int v ) ; +# 37 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern short ocBroadcastShort(int source , short v ) ; +# 38 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern long ocBroadcastLong(int source , long v ) ; +# 39 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" +extern long long ocBroadcastLLong(int source , long long v ) ; +# 15 "./mutual.h" +extern char const *mySide() ; +# 17 "./mutual.h" +void mutualFriends(void *args ) ; +# 9 "mutual.oc" +obool oblivStrCmp(__obliv_c__bool const *__obliv_c__en , __obliv_c__char *s1 , __obliv_c__char *s2 ) +{ + __obliv_c__bool afternull ; + int i ; + obool ob ; + __obliv_c__char c ; + int __cil_tmp7 ; + int __cil_tmp8 ; + __obliv_c__char *__cil_tmp9 ; + __obliv_c__char __cil_tmp10 ; + __obliv_c__char *__cil_tmp11 ; + __obliv_c__char __cil_tmp12 ; + __obliv_c__int __cil_tmp13 ; + __obliv_c__int __cil_tmp14 ; + __obliv_c__int __cil_tmp15 ; + __obliv_c__int __cil_tmp16 ; + int __cil_tmp17 ; + int __cil_tmp18 ; + int __cil_tmp19 ; + __obliv_c__bool __obliv_c__cond21 ; + __obliv_c__bool __obliv_c__cond22 ; + __obliv_c__bool __obliv_c__cond23 ; + __obliv_c__bool __obliv_c__cond24 ; + __obliv_c__bool __obliv_c__cond25 ; + __obliv_c__bool __obliv_c__cond26 ; + __obliv_c__bool __obliv_c__cond27 ; + __obliv_c__bool __obliv_c__cond28 ; + __obliv_c__bool __obliv_c__cond29 ; + + { +# 49 "mutual.oc" + memset((void *)(& afternull), 0, sizeof(__obliv_c__bool )); +# 49 "mutual.oc" + memset((void *)(& i), 0, sizeof(int )); +# 49 "mutual.oc" + memset((void *)(& ob), 0, sizeof(obool )); +# 49 "mutual.oc" + memset((void *)(& c), 0, sizeof(__obliv_c__char )); +# 11 "mutual.oc" + __obliv_c__setSignedKnown(& afternull, 1UL, (widest_t )((_Bool )0)); +# 13 "mutual.oc" + __obliv_c__setSignedKnown(& ob, 1UL, (widest_t )((_Bool )1)); +# 15 "mutual.oc" + i = 0; +# 15 "mutual.oc" + while (1) { + { +# 15 "mutual.oc" + __cil_tmp7 = (int )10; +# 15 "mutual.oc" + __cil_tmp8 = (int )i; +# 15 "mutual.oc" + if (! (__cil_tmp8 < __cil_tmp7)) { +# 15 "mutual.oc" + break; + } + } + { +# 17 "mutual.oc" + __obliv_c__cond21 = afternull; +# 17 "mutual.oc" + __obliv_c__setBitAnd((struct OblivBit *)(& __obliv_c__cond22), (struct OblivBit const *)(& __obliv_c__cond21), + (struct OblivBit const *)(& *__obliv_c__en)); +# 17 "mutual.oc" + __obliv_c__setNotEqual(& __obliv_c__cond23, & __obliv_c__cond22, & *__obliv_c__en, + 1UL); + { + + } + { +# 20 "mutual.oc" + __cil_tmp9 = s1 + i; +# 20 "mutual.oc" + __cil_tmp10 = *((__obliv_c__char *)__cil_tmp9); +# 20 "mutual.oc" + __obliv_c__setSignExtend(& c, 8UL, & __cil_tmp10, 8UL); + { +# 21 "mutual.oc" + __cil_tmp11 = s2 + i; +# 21 "mutual.oc" + __cil_tmp12 = *((__obliv_c__char *)__cil_tmp11); +# 21 "mutual.oc" + __obliv_c__setSignExtend(& __cil_tmp13, 32UL, & __cil_tmp12, 8UL); +# 21 "mutual.oc" + __obliv_c__setSignExtend(& __cil_tmp14, 32UL, & c, 8UL); + { +# 21 "mutual.oc" + __obliv_c__setNotEqual(& __obliv_c__cond24, & __cil_tmp14, & __cil_tmp13, 32UL); +# 21 "mutual.oc" + __obliv_c__setBitAnd((struct OblivBit *)(& __obliv_c__cond25), (struct OblivBit const *)(& __obliv_c__cond24), + (struct OblivBit const *)(& __obliv_c__cond23)); +# 21 "mutual.oc" + __obliv_c__setNotEqual(& __obliv_c__cond26, & __obliv_c__cond25, & __obliv_c__cond23, + 1UL); + { +# 22 "mutual.oc" + __obliv_c__condAssignKnown(& __obliv_c__cond25, & ob, 1UL, (widest_t )((_Bool )0)); + } + { + { +# 24 "mutual.oc" + __obliv_c__setSignedKnown(& __cil_tmp15, 32UL, (widest_t )((int )0)); +# 24 "mutual.oc" + __obliv_c__setSignExtend(& __cil_tmp16, 32UL, & c, 8UL); + { +# 24 "mutual.oc" + __obliv_c__setEqualTo(& __obliv_c__cond27, & __cil_tmp16, & __cil_tmp15, 32UL); +# 24 "mutual.oc" + __obliv_c__setBitAnd((struct OblivBit *)(& __obliv_c__cond28), (struct OblivBit const *)(& __obliv_c__cond27), + (struct OblivBit const *)(& __obliv_c__cond26)); +# 24 "mutual.oc" + __obliv_c__setNotEqual(& __obliv_c__cond29, & __obliv_c__cond28, & __obliv_c__cond26, + 1UL); + { +# 25 "mutual.oc" + __obliv_c__condAssignKnown(& __obliv_c__cond28, & afternull, 1UL, (widest_t )((_Bool )1)); + } + { + + } + } + } + } + } + } + } + } +# 15 "mutual.oc" + __cil_tmp17 = (int )1; +# 15 "mutual.oc" + __cil_tmp18 = (int )i; +# 15 "mutual.oc" + __cil_tmp19 = __cil_tmp18 + __cil_tmp17; +# 15 "mutual.oc" + i = (int )__cil_tmp19; + } +# 33 "mutual.oc" + return (ob); +} +} +# 36 "mutual.oc" +void addString(__obliv_c__bool const *__obliv_c__en , __obliv_c__char *src , __obliv_c__char *dest ) +{ + int i ; + int __cil_tmp4 ; + int __cil_tmp5 ; + __obliv_c__char *__cil_tmp6 ; + __obliv_c__char *__cil_tmp7 ; + int __cil_tmp8 ; + int __cil_tmp9 ; + int __cil_tmp10 ; + + { +# 49 "mutual.oc" + memset((void *)(& i), 0, sizeof(int )); +# 38 "mutual.oc" + i = 0; +# 38 "mutual.oc" + while (1) { + { +# 38 "mutual.oc" + __cil_tmp4 = (int )10; +# 38 "mutual.oc" + __cil_tmp5 = (int )i; +# 38 "mutual.oc" + if (! (__cil_tmp5 < __cil_tmp4)) { +# 38 "mutual.oc" + break; + } + } +# 39 "mutual.oc" + __cil_tmp6 = dest + i; +# 39 "mutual.oc" + __cil_tmp7 = src + i; +# 39 "mutual.oc" + __obliv_c__condAssign(__obliv_c__en, (__obliv_c__char *)__cil_tmp6, (__obliv_c__char *)__cil_tmp7, + 8UL); +# 38 "mutual.oc" + __cil_tmp8 = (int )1; +# 38 "mutual.oc" + __cil_tmp9 = (int )i; +# 38 "mutual.oc" + __cil_tmp10 = __cil_tmp9 + __cil_tmp8; +# 38 "mutual.oc" + i = (int )__cil_tmp10; + } +# 40 "mutual.oc" + return; +} +} +# 42 "mutual.oc" +void readString(__obliv_c__char *dest , int n , char const *src , int party ) +{ + OblivInputs specs[45] ; + int i ; + unsigned long __cil_tmp7 ; + unsigned long __cil_tmp8 ; + OblivInputs *__cil_tmp9 ; + size_t __cil_tmp10 ; + + { +# 49 "mutual.oc" + memset((void *)(& specs), 0, sizeof(OblivInputs [45])); +# 49 "mutual.oc" + memset((void *)(& i), 0, sizeof(int )); +# 47 "mutual.oc" + __cil_tmp7 = 0 * 24UL; +# 47 "mutual.oc" + __cil_tmp8 = (unsigned long )(specs) + __cil_tmp7; +# 47 "mutual.oc" + __cil_tmp9 = (OblivInputs *)__cil_tmp8; +# 47 "mutual.oc" + __cil_tmp10 = (size_t )n; +# 47 "mutual.oc" + feedOblivInputs(__cil_tmp9, __cil_tmp10, party); +# 48 "mutual.oc" + return; +} +} +# 49 "mutual.oc" +void mutualFriends(void *args ) +{ + protocolIO *io ; + int size1 ; + int size2 ; + int i ; + int j ; + obool match[45] ; + __obliv_c__char friends1[45][10] ; + __obliv_c__char friends2[45][10] ; + __obliv_c__char commonFriends[45][10] ; + __obliv_c__int commonSize ; + obool tmp ; + _Bool pubMatch[45] ; + unsigned long __cil_tmp14 ; + unsigned long __cil_tmp15 ; + int __cil_tmp16 ; + unsigned long __cil_tmp17 ; + unsigned long __cil_tmp18 ; + int __cil_tmp19 ; + int __cil_tmp20 ; + int __cil_tmp21 ; + int __cil_tmp22 ; + int __cil_tmp23 ; + unsigned long __cil_tmp24 ; + unsigned long __cil_tmp25 ; + unsigned long __cil_tmp26 ; + unsigned long __cil_tmp27 ; + unsigned long __cil_tmp28 ; + unsigned long __cil_tmp29 ; + unsigned long __cil_tmp30 ; + unsigned long __cil_tmp31 ; + unsigned long __cil_tmp32 ; + unsigned long __cil_tmp33 ; + char __cil_tmp34 ; + int __cil_tmp35 ; + int __cil_tmp36 ; + int __cil_tmp37 ; + int __cil_tmp38 ; + int __cil_tmp39 ; + int __cil_tmp40 ; + int __cil_tmp41 ; + int __cil_tmp42 ; + unsigned long __cil_tmp43 ; + unsigned long __cil_tmp44 ; + int __cil_tmp45 ; + int __cil_tmp46 ; + int __cil_tmp47 ; + int __cil_tmp48 ; + int __cil_tmp49 ; + int __cil_tmp50 ; + int __cil_tmp51 ; + unsigned long __cil_tmp52 ; + unsigned long __cil_tmp53 ; + unsigned long __cil_tmp54 ; + unsigned long __cil_tmp55 ; + unsigned long __cil_tmp56 ; + unsigned long __cil_tmp57 ; + unsigned long __cil_tmp58 ; + unsigned long __cil_tmp59 ; + unsigned long __cil_tmp60 ; + unsigned long __cil_tmp61 ; + char __cil_tmp62 ; + int __cil_tmp63 ; + int __cil_tmp64 ; + int __cil_tmp65 ; + int __cil_tmp66 ; + int __cil_tmp67 ; + int __cil_tmp68 ; + int __cil_tmp69 ; + int __cil_tmp70 ; + int __cil_tmp71 ; + int __cil_tmp72 ; + __obliv_c__int __cil_tmp73 ; + unsigned long __cil_tmp74 ; + unsigned long __cil_tmp75 ; + obool __cil_tmp76 ; + __obliv_c__int __cil_tmp77 ; + unsigned long __cil_tmp78 ; + unsigned long __cil_tmp79 ; + unsigned long __cil_tmp80 ; + unsigned long __cil_tmp81 ; + __obliv_c__char *__cil_tmp82 ; + unsigned long __cil_tmp83 ; + unsigned long __cil_tmp84 ; + unsigned long __cil_tmp85 ; + unsigned long __cil_tmp86 ; + __obliv_c__char *__cil_tmp87 ; + __obliv_c__int __cil_tmp88 ; + __obliv_c__int __cil_tmp89 ; + __obliv_c__int __cil_tmp90 ; + unsigned long __cil_tmp91 ; + unsigned long __cil_tmp92 ; + unsigned long __cil_tmp93 ; + unsigned long __cil_tmp94 ; + __obliv_c__char *__cil_tmp95 ; + unsigned long __cil_tmp96 ; + unsigned long __cil_tmp97 ; + unsigned long __cil_tmp98 ; + unsigned long __cil_tmp99 ; + __obliv_c__char *__cil_tmp100 ; + int __cil_tmp101 ; + int __cil_tmp102 ; + int __cil_tmp103 ; + int __cil_tmp104 ; + int __cil_tmp105 ; + int __cil_tmp106 ; + int __cil_tmp107 ; + int __cil_tmp108 ; + int __cil_tmp109 ; + int __cil_tmp110 ; + int __cil_tmp111 ; + unsigned long __cil_tmp112 ; + unsigned long __cil_tmp113 ; + _Bool __cil_tmp114 ; + int __cil_tmp115 ; + int __cil_tmp116 ; + int __cil_tmp117 ; + int __cil_tmp118 ; + int __cil_tmp119 ; + int __cil_tmp120 ; + int __cil_tmp121 ; + int __cil_tmp122 ; + int __cil_tmp123 ; + int __cil_tmp124 ; + unsigned long __cil_tmp125 ; + unsigned long __cil_tmp126 ; + int *__cil_tmp127 ; + int __cil_tmp128 ; + int __cil_tmp129 ; + int __cil_tmp130 ; + int __cil_tmp131 ; + unsigned long __cil_tmp132 ; + unsigned long __cil_tmp133 ; + unsigned long __cil_tmp134 ; + unsigned long __cil_tmp135 ; + unsigned long __cil_tmp136 ; + unsigned long __cil_tmp137 ; + char *__cil_tmp138 ; + unsigned long __cil_tmp139 ; + unsigned long __cil_tmp140 ; + unsigned long __cil_tmp141 ; + unsigned long __cil_tmp142 ; + __obliv_c__char __cil_tmp143 ; + int __cil_tmp144 ; + int __cil_tmp145 ; + int __cil_tmp146 ; + int __cil_tmp147 ; + int __cil_tmp148 ; + int __cil_tmp149 ; + __obliv_c__bool __obliv_c__cond150 ; + __obliv_c__bool __obliv_c__cond151 ; + __obliv_c__bool __obliv_c__cond152 ; + obool __cil_tmp153 ; + __obliv_c__bool __obliv_c__cond154 ; + __obliv_c__bool __obliv_c__cond155 ; + __obliv_c__bool __obliv_c__cond156 ; + __obliv_c__int __cil_tmp157 ; + + { +# 49 "mutual.oc" + memset((void *)(& io), 0, sizeof(protocolIO *)); +# 49 "mutual.oc" + memset((void *)(& size1), 0, sizeof(int )); +# 49 "mutual.oc" + memset((void *)(& size2), 0, sizeof(int )); +# 49 "mutual.oc" + memset((void *)(& i), 0, sizeof(int )); +# 49 "mutual.oc" + memset((void *)(& j), 0, sizeof(int )); +# 49 "mutual.oc" + memset((void *)(& match), 0, sizeof(obool [45])); +# 49 "mutual.oc" + memset((void *)(& friends1), 0, sizeof(__obliv_c__char [45][10])); +# 49 "mutual.oc" + memset((void *)(& friends2), 0, sizeof(__obliv_c__char [45][10])); +# 49 "mutual.oc" + memset((void *)(& commonFriends), 0, sizeof(__obliv_c__char [45][10])); +# 49 "mutual.oc" + memset((void *)(& commonSize), 0, sizeof(__obliv_c__int )); +# 49 "mutual.oc" + memset((void *)(& tmp), 0, sizeof(obool )); +# 49 "mutual.oc" + memset((void *)(& pubMatch), 0, sizeof(_Bool [45])); +# 50 "mutual.oc" + io = (protocolIO *)args; +# 58 "mutual.oc" + __cil_tmp14 = (unsigned long )io; +# 58 "mutual.oc" + __cil_tmp15 = __cil_tmp14 + 452; +# 58 "mutual.oc" + __cil_tmp16 = *((int *)__cil_tmp15); +# 58 "mutual.oc" + size1 = ocBroadcastInt(1, __cil_tmp16); +# 59 "mutual.oc" + __cil_tmp17 = (unsigned long )io; +# 59 "mutual.oc" + __cil_tmp18 = __cil_tmp17 + 452; +# 59 "mutual.oc" + __cil_tmp19 = *((int *)__cil_tmp18); +# 59 "mutual.oc" + size2 = ocBroadcastInt(2, __cil_tmp19); +# 60 "mutual.oc" + i = 0; +# 60 "mutual.oc" + while (1) { + { +# 60 "mutual.oc" + __cil_tmp20 = (int )size1; +# 60 "mutual.oc" + __cil_tmp21 = (int )i; +# 60 "mutual.oc" + if (! (__cil_tmp21 < __cil_tmp20)) { +# 60 "mutual.oc" + break; + } + } +# 61 "mutual.oc" + j = 0; +# 61 "mutual.oc" + while (1) { + { +# 61 "mutual.oc" + __cil_tmp22 = (int )10; +# 61 "mutual.oc" + __cil_tmp23 = (int )j; +# 61 "mutual.oc" + if (! (__cil_tmp23 < __cil_tmp22)) { +# 61 "mutual.oc" + break; + } + } +# 62 "mutual.oc" + __cil_tmp24 = j * 104UL; +# 62 "mutual.oc" + __cil_tmp25 = i * 1040UL; +# 62 "mutual.oc" + __cil_tmp26 = __cil_tmp25 + __cil_tmp24; +# 62 "mutual.oc" + __cil_tmp27 = (unsigned long )(friends1) + __cil_tmp26; +# 62 "mutual.oc" + __cil_tmp28 = j * 1UL; +# 62 "mutual.oc" + __cil_tmp29 = i * 10UL; +# 62 "mutual.oc" + __cil_tmp30 = __cil_tmp29 + __cil_tmp28; +# 62 "mutual.oc" + __cil_tmp31 = 0 + __cil_tmp30; +# 62 "mutual.oc" + __cil_tmp32 = (unsigned long )io; +# 62 "mutual.oc" + __cil_tmp33 = __cil_tmp32 + __cil_tmp31; +# 62 "mutual.oc" + __cil_tmp34 = *((char *)__cil_tmp33); +# 62 "mutual.oc" + *((__obliv_c__char *)__cil_tmp27) = feedOblivChar(__cil_tmp34, 1); +# 61 "mutual.oc" + __cil_tmp35 = (int )1; +# 61 "mutual.oc" + __cil_tmp36 = (int )j; +# 61 "mutual.oc" + __cil_tmp37 = __cil_tmp36 + __cil_tmp35; +# 61 "mutual.oc" + j = (int )__cil_tmp37; + } +# 60 "mutual.oc" + __cil_tmp38 = (int )1; +# 60 "mutual.oc" + __cil_tmp39 = (int )i; +# 60 "mutual.oc" + __cil_tmp40 = __cil_tmp39 + __cil_tmp38; +# 60 "mutual.oc" + i = (int )__cil_tmp40; + } +# 65 "mutual.oc" + i = 0; +# 65 "mutual.oc" + while (1) { + { +# 65 "mutual.oc" + __cil_tmp41 = (int )45; +# 65 "mutual.oc" + __cil_tmp42 = (int )i; +# 65 "mutual.oc" + if (! (__cil_tmp42 < __cil_tmp41)) { +# 65 "mutual.oc" + break; + } + } +# 66 "mutual.oc" + __cil_tmp43 = i * 13UL; +# 66 "mutual.oc" + __cil_tmp44 = (unsigned long )(match) + __cil_tmp43; +# 66 "mutual.oc" + __obliv_c__setSignedKnown(& *((obool *)__cil_tmp44), 1UL, (widest_t )((_Bool )0)); +# 65 "mutual.oc" + __cil_tmp45 = (int )1; +# 65 "mutual.oc" + __cil_tmp46 = (int )i; +# 65 "mutual.oc" + __cil_tmp47 = __cil_tmp46 + __cil_tmp45; +# 65 "mutual.oc" + i = (int )__cil_tmp47; + } +# 67 "mutual.oc" + i = 0; +# 67 "mutual.oc" + while (1) { + { +# 67 "mutual.oc" + __cil_tmp48 = (int )size2; +# 67 "mutual.oc" + __cil_tmp49 = (int )i; +# 67 "mutual.oc" + if (! (__cil_tmp49 < __cil_tmp48)) { +# 67 "mutual.oc" + break; + } + } +# 68 "mutual.oc" + j = 0; +# 68 "mutual.oc" + while (1) { + { +# 68 "mutual.oc" + __cil_tmp50 = (int )10; +# 68 "mutual.oc" + __cil_tmp51 = (int )j; +# 68 "mutual.oc" + if (! (__cil_tmp51 < __cil_tmp50)) { +# 68 "mutual.oc" + break; + } + } +# 69 "mutual.oc" + __cil_tmp52 = j * 104UL; +# 69 "mutual.oc" + __cil_tmp53 = i * 1040UL; +# 69 "mutual.oc" + __cil_tmp54 = __cil_tmp53 + __cil_tmp52; +# 69 "mutual.oc" + __cil_tmp55 = (unsigned long )(friends2) + __cil_tmp54; +# 69 "mutual.oc" + __cil_tmp56 = j * 1UL; +# 69 "mutual.oc" + __cil_tmp57 = i * 10UL; +# 69 "mutual.oc" + __cil_tmp58 = __cil_tmp57 + __cil_tmp56; +# 69 "mutual.oc" + __cil_tmp59 = 0 + __cil_tmp58; +# 69 "mutual.oc" + __cil_tmp60 = (unsigned long )io; +# 69 "mutual.oc" + __cil_tmp61 = __cil_tmp60 + __cil_tmp59; +# 69 "mutual.oc" + __cil_tmp62 = *((char *)__cil_tmp61); +# 69 "mutual.oc" + *((__obliv_c__char *)__cil_tmp55) = feedOblivChar(__cil_tmp62, 2); +# 68 "mutual.oc" + __cil_tmp63 = (int )1; +# 68 "mutual.oc" + __cil_tmp64 = (int )j; +# 68 "mutual.oc" + __cil_tmp65 = __cil_tmp64 + __cil_tmp63; +# 68 "mutual.oc" + j = (int )__cil_tmp65; + } +# 67 "mutual.oc" + __cil_tmp66 = (int )1; +# 67 "mutual.oc" + __cil_tmp67 = (int )i; +# 67 "mutual.oc" + __cil_tmp68 = __cil_tmp67 + __cil_tmp66; +# 67 "mutual.oc" + i = (int )__cil_tmp68; + } +# 71 "mutual.oc" + i = 0; +# 71 "mutual.oc" + while (1) { + { +# 71 "mutual.oc" + __cil_tmp69 = (int )size1; +# 71 "mutual.oc" + __cil_tmp70 = (int )i; +# 71 "mutual.oc" + if (! (__cil_tmp70 < __cil_tmp69)) { +# 71 "mutual.oc" + break; + } + } +# 72 "mutual.oc" + j = 0; +# 72 "mutual.oc" + while (1) { + { +# 72 "mutual.oc" + __cil_tmp71 = (int )size2; +# 72 "mutual.oc" + __cil_tmp72 = (int )j; +# 72 "mutual.oc" + if (! (__cil_tmp72 < __cil_tmp71)) { +# 72 "mutual.oc" + break; + } + } + { +# 73 "mutual.oc" + __obliv_c__setSignedKnown(& __cil_tmp73, 32UL, (widest_t )((int )0)); +# 73 "mutual.oc" + __cil_tmp74 = j * 13UL; +# 73 "mutual.oc" + __cil_tmp75 = (unsigned long )(match) + __cil_tmp74; +# 73 "mutual.oc" + __cil_tmp76 = *((obool *)__cil_tmp75); +# 73 "mutual.oc" + __obliv_c__setZeroExtend(& __cil_tmp77, 32UL, & __cil_tmp76, 1UL); + { +# 73 "mutual.oc" + __obliv_c__setEqualTo(& __obliv_c__cond150, & __cil_tmp77, & __cil_tmp73, 32UL); +# 73 "mutual.oc" + __obliv_c__setBitAnd((struct OblivBit *)(& __obliv_c__cond151), (struct OblivBit const *)(& __obliv_c__cond150), + (struct OblivBit const *)(& __obliv_c__trueCond)); +# 73 "mutual.oc" + __obliv_c__setNotEqual(& __obliv_c__cond152, & __obliv_c__cond151, & __obliv_c__trueCond, + 1UL); + { +# 74 "mutual.oc" + __cil_tmp78 = 0 * 104UL; +# 74 "mutual.oc" + __cil_tmp79 = i * 1040UL; +# 74 "mutual.oc" + __cil_tmp80 = __cil_tmp79 + __cil_tmp78; +# 74 "mutual.oc" + __cil_tmp81 = (unsigned long )(friends1) + __cil_tmp80; +# 74 "mutual.oc" + __cil_tmp82 = (__obliv_c__char *)__cil_tmp81; +# 74 "mutual.oc" + __cil_tmp83 = 0 * 104UL; +# 74 "mutual.oc" + __cil_tmp84 = j * 1040UL; +# 74 "mutual.oc" + __cil_tmp85 = __cil_tmp84 + __cil_tmp83; +# 74 "mutual.oc" + __cil_tmp86 = (unsigned long )(friends2) + __cil_tmp85; +# 74 "mutual.oc" + __cil_tmp87 = (__obliv_c__char *)__cil_tmp86; +# 74 "mutual.oc" + __cil_tmp153 = oblivStrCmp(& __obliv_c__cond151, __cil_tmp82, __cil_tmp87); +# 74 "mutual.oc" + tmp = __cil_tmp153; + { +# 74 "mutual.oc" + __obliv_c__cond154 = tmp; +# 74 "mutual.oc" + __obliv_c__setBitAnd((struct OblivBit *)(& __obliv_c__cond155), (struct OblivBit const *)(& __obliv_c__cond154), + (struct OblivBit const *)(& __obliv_c__cond151)); +# 74 "mutual.oc" + __obliv_c__setNotEqual(& __obliv_c__cond156, & __obliv_c__cond155, & __obliv_c__cond151, + 1UL); + { +# 75 "mutual.oc" + __obliv_c__setSignedKnown(& __cil_tmp88, 32UL, (widest_t )((int )1)); +# 75 "mutual.oc" + __obliv_c__setSignExtend(& __cil_tmp89, 32UL, & commonSize, 32UL); +# 75 "mutual.oc" + __obliv_c__setPlainAdd(& __cil_tmp90, & __cil_tmp89, & __cil_tmp88, 32UL); +# 75 "mutual.oc" + __obliv_c__setSignExtend(& __cil_tmp157, 32UL, & __cil_tmp90, 32UL); +# 75 "mutual.oc" + __obliv_c__condAssign(& __obliv_c__cond155, & commonSize, & __cil_tmp157, 32UL); +# 77 "mutual.oc" + __cil_tmp91 = 0 * 104UL; +# 77 "mutual.oc" + __cil_tmp92 = i * 1040UL; +# 77 "mutual.oc" + __cil_tmp93 = __cil_tmp92 + __cil_tmp91; +# 77 "mutual.oc" + __cil_tmp94 = (unsigned long )(friends1) + __cil_tmp93; +# 77 "mutual.oc" + __cil_tmp95 = (__obliv_c__char *)__cil_tmp94; +# 77 "mutual.oc" + __cil_tmp96 = 0 * 104UL; +# 77 "mutual.oc" + __cil_tmp97 = i * 1040UL; +# 77 "mutual.oc" + __cil_tmp98 = __cil_tmp97 + __cil_tmp96; +# 77 "mutual.oc" + __cil_tmp99 = (unsigned long )(commonFriends) + __cil_tmp98; +# 77 "mutual.oc" + __cil_tmp100 = (__obliv_c__char *)__cil_tmp99; +# 77 "mutual.oc" + addString(& __obliv_c__cond155, __cil_tmp95, __cil_tmp100); + } + { + + } + } + } + { + + } + } + } +# 72 "mutual.oc" + __cil_tmp101 = (int )1; +# 72 "mutual.oc" + __cil_tmp102 = (int )j; +# 72 "mutual.oc" + __cil_tmp103 = __cil_tmp102 + __cil_tmp101; +# 72 "mutual.oc" + j = (int )__cil_tmp103; + } +# 71 "mutual.oc" + __cil_tmp104 = (int )1; +# 71 "mutual.oc" + __cil_tmp105 = (int )i; +# 71 "mutual.oc" + __cil_tmp106 = __cil_tmp105 + __cil_tmp104; +# 71 "mutual.oc" + i = (int )__cil_tmp106; + } +# 80 "mutual.oc" + j = 0; +# 83 "mutual.oc" + i = 0; +# 83 "mutual.oc" + while (1) { + { +# 83 "mutual.oc" + __cil_tmp107 = (int )45; +# 83 "mutual.oc" + __cil_tmp108 = (int )i; +# 83 "mutual.oc" + if (! (__cil_tmp108 < __cil_tmp107)) { +# 83 "mutual.oc" + break; + } + } +# 86 "mutual.oc" + i = 0; +# 86 "mutual.oc" + while (1) { + { +# 86 "mutual.oc" + __cil_tmp109 = (int )45; +# 86 "mutual.oc" + __cil_tmp110 = (int )i; +# 86 "mutual.oc" + if (! (__cil_tmp110 < __cil_tmp109)) { +# 86 "mutual.oc" + break; + } + } + { +# 87 "mutual.oc" + __cil_tmp111 = (int )1; +# 87 "mutual.oc" + __cil_tmp112 = i * 1UL; +# 87 "mutual.oc" + __cil_tmp113 = (unsigned long )(pubMatch) + __cil_tmp112; +# 87 "mutual.oc" + __cil_tmp114 = *((_Bool *)__cil_tmp113); +# 87 "mutual.oc" + __cil_tmp115 = (int )__cil_tmp114; +# 87 "mutual.oc" + if (__cil_tmp115 == __cil_tmp111) { +# 89 "mutual.oc" + __cil_tmp116 = (int )1; +# 89 "mutual.oc" + __cil_tmp117 = (int )j; +# 89 "mutual.oc" + __cil_tmp118 = __cil_tmp117 + __cil_tmp116; +# 89 "mutual.oc" + j = (int )__cil_tmp118; + } + } +# 86 "mutual.oc" + __cil_tmp119 = (int )1; +# 86 "mutual.oc" + __cil_tmp120 = (int )i; +# 86 "mutual.oc" + __cil_tmp121 = __cil_tmp120 + __cil_tmp119; +# 86 "mutual.oc" + i = (int )__cil_tmp121; + } +# 83 "mutual.oc" + __cil_tmp122 = (int )1; +# 83 "mutual.oc" + __cil_tmp123 = (int )i; +# 83 "mutual.oc" + __cil_tmp124 = __cil_tmp123 + __cil_tmp122; +# 83 "mutual.oc" + i = (int )__cil_tmp124; + } +# 91 "mutual.oc" + __cil_tmp125 = (unsigned long )io; +# 91 "mutual.oc" + __cil_tmp126 = __cil_tmp125 + 908; +# 91 "mutual.oc" + __cil_tmp127 = (int *)__cil_tmp126; +# 91 "mutual.oc" + revealOblivInt(__cil_tmp127, commonSize, 0); +# 92 "mutual.oc" + i = 0; +# 92 "mutual.oc" + while (1) { + { +# 92 "mutual.oc" + __cil_tmp128 = (int )45; +# 92 "mutual.oc" + __cil_tmp129 = (int )i; +# 92 "mutual.oc" + if (! (__cil_tmp129 < __cil_tmp128)) { +# 92 "mutual.oc" + break; + } + } +# 93 "mutual.oc" + j = 0; +# 93 "mutual.oc" + while (1) { + { +# 93 "mutual.oc" + __cil_tmp130 = (int )10; +# 93 "mutual.oc" + __cil_tmp131 = (int )j; +# 93 "mutual.oc" + if (! (__cil_tmp131 < __cil_tmp130)) { +# 93 "mutual.oc" + break; + } + } +# 94 "mutual.oc" + __cil_tmp132 = j * 1UL; +# 94 "mutual.oc" + __cil_tmp133 = i * 10UL; +# 94 "mutual.oc" + __cil_tmp134 = __cil_tmp133 + __cil_tmp132; +# 94 "mutual.oc" + __cil_tmp135 = 456 + __cil_tmp134; +# 94 "mutual.oc" + __cil_tmp136 = (unsigned long )io; +# 94 "mutual.oc" + __cil_tmp137 = __cil_tmp136 + __cil_tmp135; +# 94 "mutual.oc" + __cil_tmp138 = (char *)__cil_tmp137; +# 94 "mutual.oc" + __cil_tmp139 = j * 104UL; +# 94 "mutual.oc" + __cil_tmp140 = i * 1040UL; +# 94 "mutual.oc" + __cil_tmp141 = __cil_tmp140 + __cil_tmp139; +# 94 "mutual.oc" + __cil_tmp142 = (unsigned long )(commonFriends) + __cil_tmp141; +# 94 "mutual.oc" + __cil_tmp143 = *((__obliv_c__char *)__cil_tmp142); +# 94 "mutual.oc" + revealOblivChar(__cil_tmp138, __cil_tmp143, 0); +# 93 "mutual.oc" + __cil_tmp144 = (int )1; +# 93 "mutual.oc" + __cil_tmp145 = (int )j; +# 93 "mutual.oc" + __cil_tmp146 = __cil_tmp145 + __cil_tmp144; +# 93 "mutual.oc" + j = (int )__cil_tmp146; + } +# 92 "mutual.oc" + __cil_tmp147 = (int )1; +# 92 "mutual.oc" + __cil_tmp148 = (int )i; +# 92 "mutual.oc" + __cil_tmp149 = __cil_tmp148 + __cil_tmp147; +# 92 "mutual.oc" + i = (int )__cil_tmp149; + } +# 96 "mutual.oc" + return; +} +} diff --git a/test/oblivc/mutual/mutual.oc.i b/test/oblivc/mutual/mutual.oc.i new file mode 100644 index 000000000..61d6e3704 --- /dev/null +++ b/test/oblivc/mutual/mutual.oc.i @@ -0,0 +1,5220 @@ +# 1 "/tmp/tmp.KtcPgJYzOx.c" +# 1 "" +# 1 "" +# 1 "/tmp/tmp.KtcPgJYzOx.c" +# 1 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" 1 + + +void* memset(void* s, int c, unsigned long n); +# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" 1 3 4 +# 150 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" 3 4 +typedef long int ptrdiff_t; +# 212 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 324 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" 3 4 +typedef int wchar_t; +# 5 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" 2 + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stdbool.h" 1 3 4 +# 7 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" 2 + + + +# 1 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" 1 + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" 1 3 4 +# 5 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" 2 + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stdint.h" 1 3 4 + + +# 1 "/usr/include/stdint.h" 1 3 4 +# 26 "/usr/include/stdint.h" 3 4 +# 1 "/usr/include/features.h" 1 3 4 +# 324 "/usr/include/features.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/predefs.h" 1 3 4 +# 325 "/usr/include/features.h" 2 3 4 +# 357 "/usr/include/features.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4 +# 378 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 379 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4 +# 358 "/usr/include/features.h" 2 3 4 +# 389 "/usr/include/features.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 5 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4 + + + + +# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4 +# 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4 +# 390 "/usr/include/features.h" 2 3 4 +# 27 "/usr/include/stdint.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wchar.h" 1 3 4 +# 28 "/usr/include/stdint.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 29 "/usr/include/stdint.h" 2 3 4 +# 37 "/usr/include/stdint.h" 3 4 +typedef signed char int8_t; +typedef short int int16_t; +typedef int int32_t; + +typedef long int int64_t; + + + + + + + +typedef unsigned char uint8_t; +typedef unsigned short int uint16_t; + +typedef unsigned int uint32_t; + + + +typedef unsigned long int uint64_t; +# 66 "/usr/include/stdint.h" 3 4 +typedef signed char int_least8_t; +typedef short int int_least16_t; +typedef int int_least32_t; + +typedef long int int_least64_t; + + + + + + +typedef unsigned char uint_least8_t; +typedef unsigned short int uint_least16_t; +typedef unsigned int uint_least32_t; + +typedef unsigned long int uint_least64_t; +# 91 "/usr/include/stdint.h" 3 4 +typedef signed char int_fast8_t; + +typedef long int int_fast16_t; +typedef long int int_fast32_t; +typedef long int int_fast64_t; +# 104 "/usr/include/stdint.h" 3 4 +typedef unsigned char uint_fast8_t; + +typedef unsigned long int uint_fast16_t; +typedef unsigned long int uint_fast32_t; +typedef unsigned long int uint_fast64_t; +# 120 "/usr/include/stdint.h" 3 4 +typedef long int intptr_t; + + +typedef unsigned long int uintptr_t; +# 135 "/usr/include/stdint.h" 3 4 +typedef long int intmax_t; +typedef unsigned long int uintmax_t; +# 4 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stdint.h" 2 3 4 +# 7 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" 2 +# 1 "/usr/include/gcrypt.h" 1 3 4 +# 25 "/usr/include/gcrypt.h" 3 4 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 33 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" 1 3 4 +# 34 "/usr/include/stdlib.h" 2 3 4 + + + + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 1 3 4 +# 43 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4 +# 65 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 3 4 +# 1 "/usr/include/endian.h" 1 3 4 +# 37 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/endian.h" 1 3 4 +# 38 "/usr/include/endian.h" 2 3 4 +# 61 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4 +# 28 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 29 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 2 3 4 +# 62 "/usr/include/endian.h" 2 3 4 +# 66 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 2 3 4 + +union wait + { + int w_status; + struct + { + + unsigned int __w_termsig:7; + unsigned int __w_coredump:1; + unsigned int __w_retcode:8; + unsigned int:16; + + + + + + + + } __wait_terminated; + struct + { + + unsigned int __w_stopval:8; + unsigned int __w_stopsig:8; + unsigned int:16; + + + + + + + } __wait_stopped; + }; +# 44 "/usr/include/stdlib.h" 2 3 4 +# 68 "/usr/include/stdlib.h" 3 4 +typedef union + { + union wait *__uptr; + int *__iptr; + } __WAIT_STATUS __attribute__ ((__transparent_union__)); +# 96 "/usr/include/stdlib.h" 3 4 + + +typedef struct + { + int quot; + int rem; + } div_t; + + + +typedef struct + { + long int quot; + long int rem; + } ldiv_t; + + + + + + + +__extension__ typedef struct + { + long long int quot; + long long int rem; + } lldiv_t; + + +# 140 "/usr/include/stdlib.h" 3 4 +extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__ , __leaf__)) ; + + + + +extern double atof (__const char *__nptr) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern int atoi (__const char *__nptr) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern long int atol (__const char *__nptr) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + + +__extension__ extern long long int atoll (__const char *__nptr) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + + +extern double strtod (__const char *__restrict __nptr, + char **__restrict __endptr) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ; + + + + + +extern float strtof (__const char *__restrict __nptr, + char **__restrict __endptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ; + +extern long double strtold (__const char *__restrict __nptr, + char **__restrict __endptr) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ; + + + + + +extern long int strtol (__const char *__restrict __nptr, + char **__restrict __endptr, int __base) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ; + +extern unsigned long int strtoul (__const char *__restrict __nptr, + char **__restrict __endptr, int __base) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ; + + + + +__extension__ +extern long long int strtoq (__const char *__restrict __nptr, + char **__restrict __endptr, int __base) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ; + +__extension__ +extern unsigned long long int strtouq (__const char *__restrict __nptr, + char **__restrict __endptr, int __base) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ; + + + + + +__extension__ +extern long long int strtoll (__const char *__restrict __nptr, + char **__restrict __endptr, int __base) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ; + +__extension__ +extern unsigned long long int strtoull (__const char *__restrict __nptr, + char **__restrict __endptr, int __base) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ; + +# 311 "/usr/include/stdlib.h" 3 4 +extern char *l64a (long int __n) __attribute__ ((__nothrow__ , __leaf__)) ; + + +extern long int a64l (__const char *__s) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + +# 1 "/usr/include/x86_64-linux-gnu/sys/types.h" 1 3 4 +# 28 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types.h" 1 3 4 +# 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 29 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 + + +typedef unsigned char __u_char; +typedef unsigned short int __u_short; +typedef unsigned int __u_int; +typedef unsigned long int __u_long; + + +typedef signed char __int8_t; +typedef unsigned char __uint8_t; +typedef signed short int __int16_t; +typedef unsigned short int __uint16_t; +typedef signed int __int32_t; +typedef unsigned int __uint32_t; + +typedef signed long int __int64_t; +typedef unsigned long int __uint64_t; + + + + + + + +typedef long int __quad_t; +typedef unsigned long int __u_quad_t; +# 131 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4 +# 132 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 + + +typedef unsigned long int __dev_t; +typedef unsigned int __uid_t; +typedef unsigned int __gid_t; +typedef unsigned long int __ino_t; +typedef unsigned long int __ino64_t; +typedef unsigned int __mode_t; +typedef unsigned long int __nlink_t; +typedef long int __off_t; +typedef long int __off64_t; +typedef int __pid_t; +typedef struct { int __val[2]; } __fsid_t; +typedef long int __clock_t; +typedef unsigned long int __rlim_t; +typedef unsigned long int __rlim64_t; +typedef unsigned int __id_t; +typedef long int __time_t; +typedef unsigned int __useconds_t; +typedef long int __suseconds_t; + +typedef int __daddr_t; +typedef long int __swblk_t; +typedef int __key_t; + + +typedef int __clockid_t; + + +typedef void * __timer_t; + + +typedef long int __blksize_t; + + + + +typedef long int __blkcnt_t; +typedef long int __blkcnt64_t; + + +typedef unsigned long int __fsblkcnt_t; +typedef unsigned long int __fsblkcnt64_t; + + +typedef unsigned long int __fsfilcnt_t; +typedef unsigned long int __fsfilcnt64_t; + +typedef long int __ssize_t; + + + +typedef __off64_t __loff_t; +typedef __quad_t *__qaddr_t; +typedef char *__caddr_t; + + +typedef long int __intptr_t; + + +typedef unsigned int __socklen_t; +# 31 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + + +typedef __u_char u_char; +typedef __u_short u_short; +typedef __u_int u_int; +typedef __u_long u_long; +typedef __quad_t quad_t; +typedef __u_quad_t u_quad_t; +typedef __fsid_t fsid_t; + + + + +typedef __loff_t loff_t; + + + +typedef __ino_t ino_t; +# 61 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +typedef __dev_t dev_t; + + + + +typedef __gid_t gid_t; + + + + +typedef __mode_t mode_t; + + + + +typedef __nlink_t nlink_t; + + + + +typedef __uid_t uid_t; + + + + + +typedef __off_t off_t; +# 99 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +typedef __pid_t pid_t; + + + + + +typedef __id_t id_t; + + + + +typedef __ssize_t ssize_t; + + + + + +typedef __daddr_t daddr_t; +typedef __caddr_t caddr_t; + + + + + +typedef __key_t key_t; +# 133 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +# 1 "/usr/include/time.h" 1 3 4 +# 58 "/usr/include/time.h" 3 4 + + +typedef __clock_t clock_t; + + + +# 74 "/usr/include/time.h" 3 4 + + +typedef __time_t time_t; + + + +# 92 "/usr/include/time.h" 3 4 +typedef __clockid_t clockid_t; +# 104 "/usr/include/time.h" 3 4 +typedef __timer_t timer_t; +# 134 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 +# 147 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" 1 3 4 +# 148 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + + +typedef unsigned long int ulong; +typedef unsigned short int ushort; +typedef unsigned int uint; +# 201 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__))); +typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__))); +typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__))); +typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__))); + +typedef int register_t __attribute__ ((__mode__ (__word__))); +# 220 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4 +# 31 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4 +# 23 "/usr/include/x86_64-linux-gnu/bits/select.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/select.h" 2 3 4 +# 32 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 + + +# 1 "/usr/include/x86_64-linux-gnu/bits/sigset.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/sigset.h" 3 4 +typedef int __sig_atomic_t; + + + + +typedef struct + { + unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; + } __sigset_t; +# 35 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 + + + +typedef __sigset_t sigset_t; + + + + + +# 1 "/usr/include/time.h" 1 3 4 +# 120 "/usr/include/time.h" 3 4 +struct timespec + { + __time_t tv_sec; + long int tv_nsec; + }; +# 45 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 + +# 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4 +# 31 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4 +struct timeval + { + __time_t tv_sec; + __suseconds_t tv_usec; + }; +# 47 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 + + +typedef __suseconds_t suseconds_t; + + + + + +typedef long int __fd_mask; +# 65 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +typedef struct + { + + + + + + + __fd_mask __fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; + + + } fd_set; + + + + + + +typedef __fd_mask fd_mask; +# 97 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 + +# 107 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +extern int select (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + struct timeval *__restrict __timeout); +# 119 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +extern int pselect (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + const struct timespec *__restrict __timeout, + const __sigset_t *__restrict __sigmask); +# 132 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 + +# 221 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + +# 1 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 1 3 4 +# 30 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 3 4 + + +__extension__ +extern unsigned int gnu_dev_major (unsigned long long int __dev) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); +__extension__ +extern unsigned int gnu_dev_minor (unsigned long long int __dev) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); +__extension__ +extern unsigned long long int gnu_dev_makedev (unsigned int __major, + unsigned int __minor) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); +# 64 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 3 4 + +# 224 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + + + + +typedef __blksize_t blksize_t; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 271 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 1 3 4 +# 23 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 2 3 4 +# 50 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4 +typedef unsigned long int pthread_t; + + +typedef union +{ + char __size[56]; + long int __align; +} pthread_attr_t; + + + +typedef struct __pthread_internal_list +{ + struct __pthread_internal_list *__prev; + struct __pthread_internal_list *__next; +} __pthread_list_t; +# 76 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4 +typedef union +{ + struct __pthread_mutex_s + { + int __lock; + unsigned int __count; + int __owner; + + unsigned int __nusers; + + + + int __kind; + + int __spins; + __pthread_list_t __list; +# 101 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4 + } __data; + char __size[40]; + long int __align; +} pthread_mutex_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_mutexattr_t; + + + + +typedef union +{ + struct + { + int __lock; + unsigned int __futex; + __extension__ unsigned long long int __total_seq; + __extension__ unsigned long long int __wakeup_seq; + __extension__ unsigned long long int __woken_seq; + void *__mutex; + unsigned int __nwaiters; + unsigned int __broadcast_seq; + } __data; + char __size[48]; + __extension__ long long int __align; +} pthread_cond_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_condattr_t; + + + +typedef unsigned int pthread_key_t; + + + +typedef int pthread_once_t; + + + + + +typedef union +{ + + struct + { + int __lock; + unsigned int __nr_readers; + unsigned int __readers_wakeup; + unsigned int __writer_wakeup; + unsigned int __nr_readers_queued; + unsigned int __nr_writers_queued; + int __writer; + int __shared; + unsigned long int __pad1; + unsigned long int __pad2; + + + unsigned int __flags; + } __data; +# 187 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4 + char __size[56]; + long int __align; +} pthread_rwlock_t; + +typedef union +{ + char __size[8]; + long int __align; +} pthread_rwlockattr_t; + + + + + +typedef volatile int pthread_spinlock_t; + + + + +typedef union +{ + char __size[32]; + long int __align; +} pthread_barrier_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_barrierattr_t; +# 272 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + + +# 321 "/usr/include/stdlib.h" 2 3 4 + + + + + + +extern long int random (void) __attribute__ ((__nothrow__ , __leaf__)); + + +extern void srandom (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__)); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); + + + + + + + +struct random_data + { + int32_t *fptr; + int32_t *rptr; + int32_t *state; + int rand_type; + int rand_deg; + int rand_sep; + int32_t *end_ptr; + }; + +extern int random_r (struct random_data *__restrict __buf, + int32_t *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int srandom_r (unsigned int __seed, struct random_data *__buf) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))); + +extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, + size_t __statelen, + struct random_data *__restrict __buf) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4))); + +extern int setstate_r (char *__restrict __statebuf, + struct random_data *__restrict __buf) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern int rand (void) __attribute__ ((__nothrow__ , __leaf__)); + +extern void srand (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__)); + + + + +extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__ , __leaf__)); + + + + + + + +extern double drand48 (void) __attribute__ ((__nothrow__ , __leaf__)); +extern double erand48 (unsigned short int __xsubi[3]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); + + +extern long int lrand48 (void) __attribute__ ((__nothrow__ , __leaf__)); +extern long int nrand48 (unsigned short int __xsubi[3]) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); + + +extern long int mrand48 (void) __attribute__ ((__nothrow__ , __leaf__)); +extern long int jrand48 (unsigned short int __xsubi[3]) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); + + +extern void srand48 (long int __seedval) __attribute__ ((__nothrow__ , __leaf__)); +extern unsigned short int *seed48 (unsigned short int __seed16v[3]) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); +extern void lcong48 (unsigned short int __param[7]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); + + + + + +struct drand48_data + { + unsigned short int __x[3]; + unsigned short int __old_x[3]; + unsigned short int __c; + unsigned short int __init; + unsigned long long int __a; + }; + + +extern int drand48_r (struct drand48_data *__restrict __buffer, + double *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); +extern int erand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + double *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int lrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); +extern int nrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int mrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); +extern int jrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int srand48_r (long int __seedval, struct drand48_data *__buffer) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))); + +extern int seed48_r (unsigned short int __seed16v[3], + struct drand48_data *__buffer) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int lcong48_r (unsigned short int __param[7], + struct drand48_data *__buffer) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + + + + + +extern void *malloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) ; + +extern void *calloc (size_t __nmemb, size_t __size) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) ; + + + + + + + + + + +extern void *realloc (void *__ptr, size_t __size) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)); + +extern void free (void *__ptr) __attribute__ ((__nothrow__ , __leaf__)); + + + + +extern void cfree (void *__ptr) __attribute__ ((__nothrow__ , __leaf__)); + + + +# 1 "/usr/include/alloca.h" 1 3 4 +# 25 "/usr/include/alloca.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" 1 3 4 +# 26 "/usr/include/alloca.h" 2 3 4 + + + + + + + +extern void *alloca (size_t __size) __attribute__ ((__nothrow__ , __leaf__)); + + + + + + +# 498 "/usr/include/stdlib.h" 2 3 4 + + + + + +extern void *valloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) ; + + + + +extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ; + + + + +extern void abort (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__)); + + + +extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); +# 531 "/usr/include/stdlib.h" 3 4 + + + + + +extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern void exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__)); +# 554 "/usr/include/stdlib.h" 3 4 + + + + + + +extern void _Exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__)); + + + + + + +extern char *getenv (__const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ; + + + + +extern char *__secure_getenv (__const char *__name) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ; + + + + + +extern int putenv (char *__string) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); + + + + + +extern int setenv (__const char *__name, __const char *__value, int __replace) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))); + + +extern int unsetenv (__const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int clearenv (void) __attribute__ ((__nothrow__ , __leaf__)); +# 606 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ; +# 620 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 642 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; +# 663 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ; +# 712 "/usr/include/stdlib.h" 3 4 + + + + + +extern int system (__const char *__command) ; + +# 734 "/usr/include/stdlib.h" 3 4 +extern char *realpath (__const char *__restrict __name, + char *__restrict __resolved) __attribute__ ((__nothrow__ , __leaf__)) ; + + + + + + +typedef int (*__compar_fn_t) (__const void *, __const void *); +# 752 "/usr/include/stdlib.h" 3 4 + + + +extern void *bsearch (__const void *__key, __const void *__base, + size_t __nmemb, size_t __size, __compar_fn_t __compar) + __attribute__ ((__nonnull__ (1, 2, 5))) ; + + + +extern void qsort (void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); +# 771 "/usr/include/stdlib.h" 3 4 +extern int abs (int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ; +extern long int labs (long int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ; + + + +__extension__ extern long long int llabs (long long int __x) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ; + + + + + + + +extern div_t div (int __numer, int __denom) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ; +extern ldiv_t ldiv (long int __numer, long int __denom) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ; + + + + +__extension__ extern lldiv_t lldiv (long long int __numer, + long long int __denom) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ; + +# 808 "/usr/include/stdlib.h" 3 4 +extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *gcvt (double __value, int __ndigit, char *__buf) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) ; + + + + +extern char *qecvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qfcvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qgcvt (long double __value, int __ndigit, char *__buf) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) ; + + + + +extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5))); + +extern int qecvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int qfcvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5))); + + + + + + + +extern int mblen (__const char *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) ; + + +extern int mbtowc (wchar_t *__restrict __pwc, + __const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) ; + + +extern int wctomb (char *__s, wchar_t __wchar) __attribute__ ((__nothrow__ , __leaf__)) ; + + + +extern size_t mbstowcs (wchar_t *__restrict __pwcs, + __const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)); + +extern size_t wcstombs (char *__restrict __s, + __const wchar_t *__restrict __pwcs, size_t __n) + __attribute__ ((__nothrow__ , __leaf__)); + + + + + + + + +extern int rpmatch (__const char *__response) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ; +# 896 "/usr/include/stdlib.h" 3 4 +extern int getsubopt (char **__restrict __optionp, + char *__const *__restrict __tokens, + char **__restrict __valuep) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3))) ; +# 948 "/usr/include/stdlib.h" 3 4 +extern int getloadavg (double __loadavg[], int __nelem) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); +# 964 "/usr/include/stdlib.h" 3 4 + +# 26 "/usr/include/gcrypt.h" 2 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stdarg.h" 1 3 4 +# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stdarg.h" 3 4 +typedef __builtin_va_list __gnuc_va_list; +# 102 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stdarg.h" 3 4 +typedef __gnuc_va_list va_list; +# 27 "/usr/include/gcrypt.h" 2 3 4 +# 1 "/usr/include/string.h" 1 3 4 +# 29 "/usr/include/string.h" 3 4 + + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" 1 3 4 +# 35 "/usr/include/string.h" 2 3 4 + + + + + + + + + +extern void *memcpy (void *__restrict __dest, + __const void *__restrict __src, size_t __n) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern void *memmove (void *__dest, __const void *__src, size_t __n) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern void *memccpy (void *__restrict __dest, __const void *__restrict __src, + int __c, size_t __n) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern void *memset (void *__s, int __c, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); + + +extern int memcmp (__const void *__s1, __const void *__s2, size_t __n) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 95 "/usr/include/string.h" 3 4 +extern void *memchr (__const void *__s, int __c, size_t __n) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + +# 126 "/usr/include/string.h" 3 4 + + +extern char *strcpy (char *__restrict __dest, __const char *__restrict __src) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncpy (char *__restrict __dest, + __const char *__restrict __src, size_t __n) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strcat (char *__restrict __dest, __const char *__restrict __src) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncat (char *__restrict __dest, __const char *__restrict __src, + size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcmp (__const char *__s1, __const char *__s2) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int strncmp (__const char *__s1, __const char *__s2, size_t __n) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcoll (__const char *__s1, __const char *__s2) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern size_t strxfrm (char *__restrict __dest, + __const char *__restrict __src, size_t __n) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))); + + + + + + +# 1 "/usr/include/xlocale.h" 1 3 4 +# 28 "/usr/include/xlocale.h" 3 4 +typedef struct __locale_struct +{ + + struct __locale_data *__locales[13]; + + + const unsigned short int *__ctype_b; + const int *__ctype_tolower; + const int *__ctype_toupper; + + + const char *__names[13]; +} *__locale_t; + + +typedef __locale_t locale_t; +# 163 "/usr/include/string.h" 2 3 4 + + +extern int strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + +extern size_t strxfrm_l (char *__dest, __const char *__src, size_t __n, + __locale_t __l) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4))); + + + + + +extern char *strdup (__const char *__s) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern char *strndup (__const char *__string, size_t __n) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); +# 210 "/usr/include/string.h" 3 4 + +# 235 "/usr/include/string.h" 3 4 +extern char *strchr (__const char *__s, int __c) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 262 "/usr/include/string.h" 3 4 +extern char *strrchr (__const char *__s, int __c) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + +# 281 "/usr/include/string.h" 3 4 + + + +extern size_t strcspn (__const char *__s, __const char *__reject) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern size_t strspn (__const char *__s, __const char *__accept) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 314 "/usr/include/string.h" 3 4 +extern char *strpbrk (__const char *__s, __const char *__accept) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 342 "/usr/include/string.h" 3 4 +extern char *strstr (__const char *__haystack, __const char *__needle) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern char *strtok (char *__restrict __s, __const char *__restrict __delim) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))); + + + + +extern char *__strtok_r (char *__restrict __s, + __const char *__restrict __delim, + char **__restrict __save_ptr) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3))); + +extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim, + char **__restrict __save_ptr) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3))); +# 397 "/usr/include/string.h" 3 4 + + +extern size_t strlen (__const char *__s) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + +extern size_t strnlen (__const char *__string, size_t __maxlen) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + +extern char *strerror (int __errnum) __attribute__ ((__nothrow__ , __leaf__)); + +# 427 "/usr/include/string.h" 3 4 +extern int strerror_r (int __errnum, char *__buf, size_t __buflen) __asm__ ("" "__xpg_strerror_r") __attribute__ ((__nothrow__ , __leaf__)) + + __attribute__ ((__nonnull__ (2))); +# 445 "/usr/include/string.h" 3 4 +extern char *strerror_l (int __errnum, __locale_t __l) __attribute__ ((__nothrow__ , __leaf__)); + + + + + +extern void __bzero (void *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); + + + +extern void bcopy (__const void *__src, void *__dest, size_t __n) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bzero (void *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); + + +extern int bcmp (__const void *__s1, __const void *__s2, size_t __n) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 489 "/usr/include/string.h" 3 4 +extern char *index (__const char *__s, int __c) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 517 "/usr/include/string.h" 3 4 +extern char *rindex (__const char *__s, int __c) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern int ffs (int __i) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); +# 536 "/usr/include/string.h" 3 4 +extern int strcasecmp (__const char *__s1, __const char *__s2) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 559 "/usr/include/string.h" 3 4 +extern char *strsep (char **__restrict __stringp, + __const char *__restrict __delim) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern char *strsignal (int __sig) __attribute__ ((__nothrow__ , __leaf__)); + + +extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern char *__stpncpy (char *__restrict __dest, + __const char *__restrict __src, size_t __n) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpncpy (char *__restrict __dest, + __const char *__restrict __src, size_t __n) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); +# 646 "/usr/include/string.h" 3 4 + +# 28 "/usr/include/gcrypt.h" 2 3 4 + +# 1 "/usr/include/gpg-error.h" 1 3 4 +# 26 "/usr/include/gpg-error.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" 1 3 4 +# 27 "/usr/include/gpg-error.h" 2 3 4 +# 78 "/usr/include/gpg-error.h" 3 4 +typedef enum + { + GPG_ERR_SOURCE_UNKNOWN = 0, + GPG_ERR_SOURCE_GCRYPT = 1, + GPG_ERR_SOURCE_GPG = 2, + GPG_ERR_SOURCE_GPGSM = 3, + GPG_ERR_SOURCE_GPGAGENT = 4, + GPG_ERR_SOURCE_PINENTRY = 5, + GPG_ERR_SOURCE_SCD = 6, + GPG_ERR_SOURCE_GPGME = 7, + GPG_ERR_SOURCE_KEYBOX = 8, + GPG_ERR_SOURCE_KSBA = 9, + GPG_ERR_SOURCE_DIRMNGR = 10, + GPG_ERR_SOURCE_GSTI = 11, + GPG_ERR_SOURCE_GPA = 12, + GPG_ERR_SOURCE_KLEO = 13, + GPG_ERR_SOURCE_G13 = 14, + GPG_ERR_SOURCE_ANY = 31, + GPG_ERR_SOURCE_USER_1 = 32, + GPG_ERR_SOURCE_USER_2 = 33, + GPG_ERR_SOURCE_USER_3 = 34, + GPG_ERR_SOURCE_USER_4 = 35, + + + GPG_ERR_SOURCE_DIM = 128 + } gpg_err_source_t; + + + + + + +typedef enum + { + GPG_ERR_NO_ERROR = 0, + GPG_ERR_GENERAL = 1, + GPG_ERR_UNKNOWN_PACKET = 2, + GPG_ERR_UNKNOWN_VERSION = 3, + GPG_ERR_PUBKEY_ALGO = 4, + GPG_ERR_DIGEST_ALGO = 5, + GPG_ERR_BAD_PUBKEY = 6, + GPG_ERR_BAD_SECKEY = 7, + GPG_ERR_BAD_SIGNATURE = 8, + GPG_ERR_NO_PUBKEY = 9, + GPG_ERR_CHECKSUM = 10, + GPG_ERR_BAD_PASSPHRASE = 11, + GPG_ERR_CIPHER_ALGO = 12, + GPG_ERR_KEYRING_OPEN = 13, + GPG_ERR_INV_PACKET = 14, + GPG_ERR_INV_ARMOR = 15, + GPG_ERR_NO_USER_ID = 16, + GPG_ERR_NO_SECKEY = 17, + GPG_ERR_WRONG_SECKEY = 18, + GPG_ERR_BAD_KEY = 19, + GPG_ERR_COMPR_ALGO = 20, + GPG_ERR_NO_PRIME = 21, + GPG_ERR_NO_ENCODING_METHOD = 22, + GPG_ERR_NO_ENCRYPTION_SCHEME = 23, + GPG_ERR_NO_SIGNATURE_SCHEME = 24, + GPG_ERR_INV_ATTR = 25, + GPG_ERR_NO_VALUE = 26, + GPG_ERR_NOT_FOUND = 27, + GPG_ERR_VALUE_NOT_FOUND = 28, + GPG_ERR_SYNTAX = 29, + GPG_ERR_BAD_MPI = 30, + GPG_ERR_INV_PASSPHRASE = 31, + GPG_ERR_SIG_CLASS = 32, + GPG_ERR_RESOURCE_LIMIT = 33, + GPG_ERR_INV_KEYRING = 34, + GPG_ERR_TRUSTDB = 35, + GPG_ERR_BAD_CERT = 36, + GPG_ERR_INV_USER_ID = 37, + GPG_ERR_UNEXPECTED = 38, + GPG_ERR_TIME_CONFLICT = 39, + GPG_ERR_KEYSERVER = 40, + GPG_ERR_WRONG_PUBKEY_ALGO = 41, + GPG_ERR_TRIBUTE_TO_D_A = 42, + GPG_ERR_WEAK_KEY = 43, + GPG_ERR_INV_KEYLEN = 44, + GPG_ERR_INV_ARG = 45, + GPG_ERR_BAD_URI = 46, + GPG_ERR_INV_URI = 47, + GPG_ERR_NETWORK = 48, + GPG_ERR_UNKNOWN_HOST = 49, + GPG_ERR_SELFTEST_FAILED = 50, + GPG_ERR_NOT_ENCRYPTED = 51, + GPG_ERR_NOT_PROCESSED = 52, + GPG_ERR_UNUSABLE_PUBKEY = 53, + GPG_ERR_UNUSABLE_SECKEY = 54, + GPG_ERR_INV_VALUE = 55, + GPG_ERR_BAD_CERT_CHAIN = 56, + GPG_ERR_MISSING_CERT = 57, + GPG_ERR_NO_DATA = 58, + GPG_ERR_BUG = 59, + GPG_ERR_NOT_SUPPORTED = 60, + GPG_ERR_INV_OP = 61, + GPG_ERR_TIMEOUT = 62, + GPG_ERR_INTERNAL = 63, + GPG_ERR_EOF_GCRYPT = 64, + GPG_ERR_INV_OBJ = 65, + GPG_ERR_TOO_SHORT = 66, + GPG_ERR_TOO_LARGE = 67, + GPG_ERR_NO_OBJ = 68, + GPG_ERR_NOT_IMPLEMENTED = 69, + GPG_ERR_CONFLICT = 70, + GPG_ERR_INV_CIPHER_MODE = 71, + GPG_ERR_INV_FLAG = 72, + GPG_ERR_INV_HANDLE = 73, + GPG_ERR_TRUNCATED = 74, + GPG_ERR_INCOMPLETE_LINE = 75, + GPG_ERR_INV_RESPONSE = 76, + GPG_ERR_NO_AGENT = 77, + GPG_ERR_AGENT = 78, + GPG_ERR_INV_DATA = 79, + GPG_ERR_ASSUAN_SERVER_FAULT = 80, + GPG_ERR_ASSUAN = 81, + GPG_ERR_INV_SESSION_KEY = 82, + GPG_ERR_INV_SEXP = 83, + GPG_ERR_UNSUPPORTED_ALGORITHM = 84, + GPG_ERR_NO_PIN_ENTRY = 85, + GPG_ERR_PIN_ENTRY = 86, + GPG_ERR_BAD_PIN = 87, + GPG_ERR_INV_NAME = 88, + GPG_ERR_BAD_DATA = 89, + GPG_ERR_INV_PARAMETER = 90, + GPG_ERR_WRONG_CARD = 91, + GPG_ERR_NO_DIRMNGR = 92, + GPG_ERR_DIRMNGR = 93, + GPG_ERR_CERT_REVOKED = 94, + GPG_ERR_NO_CRL_KNOWN = 95, + GPG_ERR_CRL_TOO_OLD = 96, + GPG_ERR_LINE_TOO_LONG = 97, + GPG_ERR_NOT_TRUSTED = 98, + GPG_ERR_CANCELED = 99, + GPG_ERR_BAD_CA_CERT = 100, + GPG_ERR_CERT_EXPIRED = 101, + GPG_ERR_CERT_TOO_YOUNG = 102, + GPG_ERR_UNSUPPORTED_CERT = 103, + GPG_ERR_UNKNOWN_SEXP = 104, + GPG_ERR_UNSUPPORTED_PROTECTION = 105, + GPG_ERR_CORRUPTED_PROTECTION = 106, + GPG_ERR_AMBIGUOUS_NAME = 107, + GPG_ERR_CARD = 108, + GPG_ERR_CARD_RESET = 109, + GPG_ERR_CARD_REMOVED = 110, + GPG_ERR_INV_CARD = 111, + GPG_ERR_CARD_NOT_PRESENT = 112, + GPG_ERR_NO_PKCS15_APP = 113, + GPG_ERR_NOT_CONFIRMED = 114, + GPG_ERR_CONFIGURATION = 115, + GPG_ERR_NO_POLICY_MATCH = 116, + GPG_ERR_INV_INDEX = 117, + GPG_ERR_INV_ID = 118, + GPG_ERR_NO_SCDAEMON = 119, + GPG_ERR_SCDAEMON = 120, + GPG_ERR_UNSUPPORTED_PROTOCOL = 121, + GPG_ERR_BAD_PIN_METHOD = 122, + GPG_ERR_CARD_NOT_INITIALIZED = 123, + GPG_ERR_UNSUPPORTED_OPERATION = 124, + GPG_ERR_WRONG_KEY_USAGE = 125, + GPG_ERR_NOTHING_FOUND = 126, + GPG_ERR_WRONG_BLOB_TYPE = 127, + GPG_ERR_MISSING_VALUE = 128, + GPG_ERR_HARDWARE = 129, + GPG_ERR_PIN_BLOCKED = 130, + GPG_ERR_USE_CONDITIONS = 131, + GPG_ERR_PIN_NOT_SYNCED = 132, + GPG_ERR_INV_CRL = 133, + GPG_ERR_BAD_BER = 134, + GPG_ERR_INV_BER = 135, + GPG_ERR_ELEMENT_NOT_FOUND = 136, + GPG_ERR_IDENTIFIER_NOT_FOUND = 137, + GPG_ERR_INV_TAG = 138, + GPG_ERR_INV_LENGTH = 139, + GPG_ERR_INV_KEYINFO = 140, + GPG_ERR_UNEXPECTED_TAG = 141, + GPG_ERR_NOT_DER_ENCODED = 142, + GPG_ERR_NO_CMS_OBJ = 143, + GPG_ERR_INV_CMS_OBJ = 144, + GPG_ERR_UNKNOWN_CMS_OBJ = 145, + GPG_ERR_UNSUPPORTED_CMS_OBJ = 146, + GPG_ERR_UNSUPPORTED_ENCODING = 147, + GPG_ERR_UNSUPPORTED_CMS_VERSION = 148, + GPG_ERR_UNKNOWN_ALGORITHM = 149, + GPG_ERR_INV_ENGINE = 150, + GPG_ERR_PUBKEY_NOT_TRUSTED = 151, + GPG_ERR_DECRYPT_FAILED = 152, + GPG_ERR_KEY_EXPIRED = 153, + GPG_ERR_SIG_EXPIRED = 154, + GPG_ERR_ENCODING_PROBLEM = 155, + GPG_ERR_INV_STATE = 156, + GPG_ERR_DUP_VALUE = 157, + GPG_ERR_MISSING_ACTION = 158, + GPG_ERR_MODULE_NOT_FOUND = 159, + GPG_ERR_INV_OID_STRING = 160, + GPG_ERR_INV_TIME = 161, + GPG_ERR_INV_CRL_OBJ = 162, + GPG_ERR_UNSUPPORTED_CRL_VERSION = 163, + GPG_ERR_INV_CERT_OBJ = 164, + GPG_ERR_UNKNOWN_NAME = 165, + GPG_ERR_LOCALE_PROBLEM = 166, + GPG_ERR_NOT_LOCKED = 167, + GPG_ERR_PROTOCOL_VIOLATION = 168, + GPG_ERR_INV_MAC = 169, + GPG_ERR_INV_REQUEST = 170, + GPG_ERR_UNKNOWN_EXTN = 171, + GPG_ERR_UNKNOWN_CRIT_EXTN = 172, + GPG_ERR_LOCKED = 173, + GPG_ERR_UNKNOWN_OPTION = 174, + GPG_ERR_UNKNOWN_COMMAND = 175, + GPG_ERR_NOT_OPERATIONAL = 176, + GPG_ERR_NO_PASSPHRASE = 177, + GPG_ERR_NO_PIN = 178, + GPG_ERR_NOT_ENABLED = 179, + GPG_ERR_NO_ENGINE = 180, + GPG_ERR_MISSING_KEY = 181, + GPG_ERR_TOO_MANY = 182, + GPG_ERR_LIMIT_REACHED = 183, + GPG_ERR_NOT_INITIALIZED = 184, + GPG_ERR_MISSING_ISSUER_CERT = 185, + GPG_ERR_FULLY_CANCELED = 198, + GPG_ERR_UNFINISHED = 199, + GPG_ERR_BUFFER_TOO_SHORT = 200, + GPG_ERR_SEXP_INV_LEN_SPEC = 201, + GPG_ERR_SEXP_STRING_TOO_LONG = 202, + GPG_ERR_SEXP_UNMATCHED_PAREN = 203, + GPG_ERR_SEXP_NOT_CANONICAL = 204, + GPG_ERR_SEXP_BAD_CHARACTER = 205, + GPG_ERR_SEXP_BAD_QUOTATION = 206, + GPG_ERR_SEXP_ZERO_PREFIX = 207, + GPG_ERR_SEXP_NESTED_DH = 208, + GPG_ERR_SEXP_UNMATCHED_DH = 209, + GPG_ERR_SEXP_UNEXPECTED_PUNC = 210, + GPG_ERR_SEXP_BAD_HEX_CHAR = 211, + GPG_ERR_SEXP_ODD_HEX_NUMBERS = 212, + GPG_ERR_SEXP_BAD_OCT_CHAR = 213, + GPG_ERR_ASS_GENERAL = 257, + GPG_ERR_ASS_ACCEPT_FAILED = 258, + GPG_ERR_ASS_CONNECT_FAILED = 259, + GPG_ERR_ASS_INV_RESPONSE = 260, + GPG_ERR_ASS_INV_VALUE = 261, + GPG_ERR_ASS_INCOMPLETE_LINE = 262, + GPG_ERR_ASS_LINE_TOO_LONG = 263, + GPG_ERR_ASS_NESTED_COMMANDS = 264, + GPG_ERR_ASS_NO_DATA_CB = 265, + GPG_ERR_ASS_NO_INQUIRE_CB = 266, + GPG_ERR_ASS_NOT_A_SERVER = 267, + GPG_ERR_ASS_NOT_A_CLIENT = 268, + GPG_ERR_ASS_SERVER_START = 269, + GPG_ERR_ASS_READ_ERROR = 270, + GPG_ERR_ASS_WRITE_ERROR = 271, + GPG_ERR_ASS_TOO_MUCH_DATA = 273, + GPG_ERR_ASS_UNEXPECTED_CMD = 274, + GPG_ERR_ASS_UNKNOWN_CMD = 275, + GPG_ERR_ASS_SYNTAX = 276, + GPG_ERR_ASS_CANCELED = 277, + GPG_ERR_ASS_NO_INPUT = 278, + GPG_ERR_ASS_NO_OUTPUT = 279, + GPG_ERR_ASS_PARAMETER = 280, + GPG_ERR_ASS_UNKNOWN_INQUIRE = 281, + GPG_ERR_USER_1 = 1024, + GPG_ERR_USER_2 = 1025, + GPG_ERR_USER_3 = 1026, + GPG_ERR_USER_4 = 1027, + GPG_ERR_USER_5 = 1028, + GPG_ERR_USER_6 = 1029, + GPG_ERR_USER_7 = 1030, + GPG_ERR_USER_8 = 1031, + GPG_ERR_USER_9 = 1032, + GPG_ERR_USER_10 = 1033, + GPG_ERR_USER_11 = 1034, + GPG_ERR_USER_12 = 1035, + GPG_ERR_USER_13 = 1036, + GPG_ERR_USER_14 = 1037, + GPG_ERR_USER_15 = 1038, + GPG_ERR_USER_16 = 1039, + GPG_ERR_MISSING_ERRNO = 16381, + GPG_ERR_UNKNOWN_ERRNO = 16382, + GPG_ERR_EOF = 16383, + + + + GPG_ERR_E2BIG = (1 << 15) | 0, + GPG_ERR_EACCES = (1 << 15) | 1, + GPG_ERR_EADDRINUSE = (1 << 15) | 2, + GPG_ERR_EADDRNOTAVAIL = (1 << 15) | 3, + GPG_ERR_EADV = (1 << 15) | 4, + GPG_ERR_EAFNOSUPPORT = (1 << 15) | 5, + GPG_ERR_EAGAIN = (1 << 15) | 6, + GPG_ERR_EALREADY = (1 << 15) | 7, + GPG_ERR_EAUTH = (1 << 15) | 8, + GPG_ERR_EBACKGROUND = (1 << 15) | 9, + GPG_ERR_EBADE = (1 << 15) | 10, + GPG_ERR_EBADF = (1 << 15) | 11, + GPG_ERR_EBADFD = (1 << 15) | 12, + GPG_ERR_EBADMSG = (1 << 15) | 13, + GPG_ERR_EBADR = (1 << 15) | 14, + GPG_ERR_EBADRPC = (1 << 15) | 15, + GPG_ERR_EBADRQC = (1 << 15) | 16, + GPG_ERR_EBADSLT = (1 << 15) | 17, + GPG_ERR_EBFONT = (1 << 15) | 18, + GPG_ERR_EBUSY = (1 << 15) | 19, + GPG_ERR_ECANCELED = (1 << 15) | 20, + GPG_ERR_ECHILD = (1 << 15) | 21, + GPG_ERR_ECHRNG = (1 << 15) | 22, + GPG_ERR_ECOMM = (1 << 15) | 23, + GPG_ERR_ECONNABORTED = (1 << 15) | 24, + GPG_ERR_ECONNREFUSED = (1 << 15) | 25, + GPG_ERR_ECONNRESET = (1 << 15) | 26, + GPG_ERR_ED = (1 << 15) | 27, + GPG_ERR_EDEADLK = (1 << 15) | 28, + GPG_ERR_EDEADLOCK = (1 << 15) | 29, + GPG_ERR_EDESTADDRREQ = (1 << 15) | 30, + GPG_ERR_EDIED = (1 << 15) | 31, + GPG_ERR_EDOM = (1 << 15) | 32, + GPG_ERR_EDOTDOT = (1 << 15) | 33, + GPG_ERR_EDQUOT = (1 << 15) | 34, + GPG_ERR_EEXIST = (1 << 15) | 35, + GPG_ERR_EFAULT = (1 << 15) | 36, + GPG_ERR_EFBIG = (1 << 15) | 37, + GPG_ERR_EFTYPE = (1 << 15) | 38, + GPG_ERR_EGRATUITOUS = (1 << 15) | 39, + GPG_ERR_EGREGIOUS = (1 << 15) | 40, + GPG_ERR_EHOSTDOWN = (1 << 15) | 41, + GPG_ERR_EHOSTUNREACH = (1 << 15) | 42, + GPG_ERR_EIDRM = (1 << 15) | 43, + GPG_ERR_EIEIO = (1 << 15) | 44, + GPG_ERR_EILSEQ = (1 << 15) | 45, + GPG_ERR_EINPROGRESS = (1 << 15) | 46, + GPG_ERR_EINTR = (1 << 15) | 47, + GPG_ERR_EINVAL = (1 << 15) | 48, + GPG_ERR_EIO = (1 << 15) | 49, + GPG_ERR_EISCONN = (1 << 15) | 50, + GPG_ERR_EISDIR = (1 << 15) | 51, + GPG_ERR_EISNAM = (1 << 15) | 52, + GPG_ERR_EL2HLT = (1 << 15) | 53, + GPG_ERR_EL2NSYNC = (1 << 15) | 54, + GPG_ERR_EL3HLT = (1 << 15) | 55, + GPG_ERR_EL3RST = (1 << 15) | 56, + GPG_ERR_ELIBACC = (1 << 15) | 57, + GPG_ERR_ELIBBAD = (1 << 15) | 58, + GPG_ERR_ELIBEXEC = (1 << 15) | 59, + GPG_ERR_ELIBMAX = (1 << 15) | 60, + GPG_ERR_ELIBSCN = (1 << 15) | 61, + GPG_ERR_ELNRNG = (1 << 15) | 62, + GPG_ERR_ELOOP = (1 << 15) | 63, + GPG_ERR_EMEDIUMTYPE = (1 << 15) | 64, + GPG_ERR_EMFILE = (1 << 15) | 65, + GPG_ERR_EMLINK = (1 << 15) | 66, + GPG_ERR_EMSGSIZE = (1 << 15) | 67, + GPG_ERR_EMULTIHOP = (1 << 15) | 68, + GPG_ERR_ENAMETOOLONG = (1 << 15) | 69, + GPG_ERR_ENAVAIL = (1 << 15) | 70, + GPG_ERR_ENEEDAUTH = (1 << 15) | 71, + GPG_ERR_ENETDOWN = (1 << 15) | 72, + GPG_ERR_ENETRESET = (1 << 15) | 73, + GPG_ERR_ENETUNREACH = (1 << 15) | 74, + GPG_ERR_ENFILE = (1 << 15) | 75, + GPG_ERR_ENOANO = (1 << 15) | 76, + GPG_ERR_ENOBUFS = (1 << 15) | 77, + GPG_ERR_ENOCSI = (1 << 15) | 78, + GPG_ERR_ENODATA = (1 << 15) | 79, + GPG_ERR_ENODEV = (1 << 15) | 80, + GPG_ERR_ENOENT = (1 << 15) | 81, + GPG_ERR_ENOEXEC = (1 << 15) | 82, + GPG_ERR_ENOLCK = (1 << 15) | 83, + GPG_ERR_ENOLINK = (1 << 15) | 84, + GPG_ERR_ENOMEDIUM = (1 << 15) | 85, + GPG_ERR_ENOMEM = (1 << 15) | 86, + GPG_ERR_ENOMSG = (1 << 15) | 87, + GPG_ERR_ENONET = (1 << 15) | 88, + GPG_ERR_ENOPKG = (1 << 15) | 89, + GPG_ERR_ENOPROTOOPT = (1 << 15) | 90, + GPG_ERR_ENOSPC = (1 << 15) | 91, + GPG_ERR_ENOSR = (1 << 15) | 92, + GPG_ERR_ENOSTR = (1 << 15) | 93, + GPG_ERR_ENOSYS = (1 << 15) | 94, + GPG_ERR_ENOTBLK = (1 << 15) | 95, + GPG_ERR_ENOTCONN = (1 << 15) | 96, + GPG_ERR_ENOTDIR = (1 << 15) | 97, + GPG_ERR_ENOTEMPTY = (1 << 15) | 98, + GPG_ERR_ENOTNAM = (1 << 15) | 99, + GPG_ERR_ENOTSOCK = (1 << 15) | 100, + GPG_ERR_ENOTSUP = (1 << 15) | 101, + GPG_ERR_ENOTTY = (1 << 15) | 102, + GPG_ERR_ENOTUNIQ = (1 << 15) | 103, + GPG_ERR_ENXIO = (1 << 15) | 104, + GPG_ERR_EOPNOTSUPP = (1 << 15) | 105, + GPG_ERR_EOVERFLOW = (1 << 15) | 106, + GPG_ERR_EPERM = (1 << 15) | 107, + GPG_ERR_EPFNOSUPPORT = (1 << 15) | 108, + GPG_ERR_EPIPE = (1 << 15) | 109, + GPG_ERR_EPROCLIM = (1 << 15) | 110, + GPG_ERR_EPROCUNAVAIL = (1 << 15) | 111, + GPG_ERR_EPROGMISMATCH = (1 << 15) | 112, + GPG_ERR_EPROGUNAVAIL = (1 << 15) | 113, + GPG_ERR_EPROTO = (1 << 15) | 114, + GPG_ERR_EPROTONOSUPPORT = (1 << 15) | 115, + GPG_ERR_EPROTOTYPE = (1 << 15) | 116, + GPG_ERR_ERANGE = (1 << 15) | 117, + GPG_ERR_EREMCHG = (1 << 15) | 118, + GPG_ERR_EREMOTE = (1 << 15) | 119, + GPG_ERR_EREMOTEIO = (1 << 15) | 120, + GPG_ERR_ERESTART = (1 << 15) | 121, + GPG_ERR_EROFS = (1 << 15) | 122, + GPG_ERR_ERPCMISMATCH = (1 << 15) | 123, + GPG_ERR_ESHUTDOWN = (1 << 15) | 124, + GPG_ERR_ESOCKTNOSUPPORT = (1 << 15) | 125, + GPG_ERR_ESPIPE = (1 << 15) | 126, + GPG_ERR_ESRCH = (1 << 15) | 127, + GPG_ERR_ESRMNT = (1 << 15) | 128, + GPG_ERR_ESTALE = (1 << 15) | 129, + GPG_ERR_ESTRPIPE = (1 << 15) | 130, + GPG_ERR_ETIME = (1 << 15) | 131, + GPG_ERR_ETIMEDOUT = (1 << 15) | 132, + GPG_ERR_ETOOMANYREFS = (1 << 15) | 133, + GPG_ERR_ETXTBSY = (1 << 15) | 134, + GPG_ERR_EUCLEAN = (1 << 15) | 135, + GPG_ERR_EUNATCH = (1 << 15) | 136, + GPG_ERR_EUSERS = (1 << 15) | 137, + GPG_ERR_EWOULDBLOCK = (1 << 15) | 138, + GPG_ERR_EXDEV = (1 << 15) | 139, + GPG_ERR_EXFULL = (1 << 15) | 140, + + + GPG_ERR_CODE_DIM = 65536 + } gpg_err_code_t; +# 513 "/usr/include/gpg-error.h" 3 4 +typedef unsigned int gpg_error_t; +# 551 "/usr/include/gpg-error.h" 3 4 +gpg_error_t gpg_err_init (void) __attribute__ ((__constructor__)); +# 562 "/usr/include/gpg-error.h" 3 4 +void gpg_err_deinit (int mode); + + + + + + +static __inline__ gpg_error_t +gpg_err_make (gpg_err_source_t source, gpg_err_code_t code) +{ + return code == GPG_ERR_NO_ERROR ? GPG_ERR_NO_ERROR + : (((source & (GPG_ERR_SOURCE_DIM - 1)) << 24) + | (code & (GPG_ERR_CODE_DIM - 1))); +} +# 584 "/usr/include/gpg-error.h" 3 4 +static __inline__ gpg_error_t +gpg_error (gpg_err_code_t code) +{ + return gpg_err_make (GPG_ERR_SOURCE_UNKNOWN, code); +} + + + +static __inline__ gpg_err_code_t +gpg_err_code (gpg_error_t err) +{ + return (gpg_err_code_t) (err & (GPG_ERR_CODE_DIM - 1)); +} + + + +static __inline__ gpg_err_source_t +gpg_err_source (gpg_error_t err) +{ + return (gpg_err_source_t) ((err >> 24) + & (GPG_ERR_SOURCE_DIM - 1)); +} + + + + + + +const char *gpg_strerror (gpg_error_t err); +# 621 "/usr/include/gpg-error.h" 3 4 +int gpg_strerror_r (gpg_error_t err, char *buf, size_t buflen); + + + +const char *gpg_strsource (gpg_error_t err); + + + + + + + +gpg_err_code_t gpg_err_code_from_errno (int err); + + + + +int gpg_err_code_to_errno (gpg_err_code_t code); + + + + + +gpg_err_code_t gpg_err_code_from_syserror (void); + + + + +void gpg_err_set_errno (int err); + + + + +static __inline__ gpg_error_t +gpg_err_make_from_errno (gpg_err_source_t source, int err) +{ + return gpg_err_make (source, gpg_err_code_from_errno (err)); +} + + +static __inline__ gpg_error_t +gpg_error_from_errno (int err) +{ + return gpg_error (gpg_err_code_from_errno (err)); +} + +static __inline__ gpg_error_t +gpg_error_from_syserror (void) +{ + return gpg_error (gpg_err_code_from_syserror ()); +} +# 30 "/usr/include/gcrypt.h" 2 3 4 +# 42 "/usr/include/gcrypt.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/sys/socket.h" 1 3 4 +# 26 "/usr/include/x86_64-linux-gnu/sys/socket.h" 3 4 + + +# 1 "/usr/include/x86_64-linux-gnu/sys/uio.h" 1 3 4 +# 26 "/usr/include/x86_64-linux-gnu/sys/uio.h" 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/uio.h" 1 3 4 +# 44 "/usr/include/x86_64-linux-gnu/bits/uio.h" 3 4 +struct iovec + { + void *iov_base; + size_t iov_len; + }; + + + + + + + + + +extern ssize_t process_vm_readv (pid_t __pid, __const struct iovec *__lvec, + unsigned long int __liovcnt, + __const struct iovec *__rvec, + unsigned long int __riovcnt, + unsigned long int __flags) + __attribute__ ((__nothrow__ , __leaf__)); + + +extern ssize_t process_vm_writev (pid_t __pid, __const struct iovec *__lvec, + unsigned long int __liovcnt, + __const struct iovec *__rvec, + unsigned long int __riovcnt, + unsigned long int __flags) + __attribute__ ((__nothrow__ , __leaf__)); + + +# 30 "/usr/include/x86_64-linux-gnu/sys/uio.h" 2 3 4 +# 40 "/usr/include/x86_64-linux-gnu/sys/uio.h" 3 4 +extern ssize_t readv (int __fd, __const struct iovec *__iovec, int __count) + ; +# 51 "/usr/include/x86_64-linux-gnu/sys/uio.h" 3 4 +extern ssize_t writev (int __fd, __const struct iovec *__iovec, int __count) + ; +# 66 "/usr/include/x86_64-linux-gnu/sys/uio.h" 3 4 +extern ssize_t preadv (int __fd, __const struct iovec *__iovec, int __count, + __off_t __offset) ; +# 78 "/usr/include/x86_64-linux-gnu/sys/uio.h" 3 4 +extern ssize_t pwritev (int __fd, __const struct iovec *__iovec, int __count, + __off_t __offset) ; +# 121 "/usr/include/x86_64-linux-gnu/sys/uio.h" 3 4 + +# 29 "/usr/include/x86_64-linux-gnu/sys/socket.h" 2 3 4 + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" 1 3 4 +# 31 "/usr/include/x86_64-linux-gnu/sys/socket.h" 2 3 4 +# 40 "/usr/include/x86_64-linux-gnu/sys/socket.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/socket.h" 1 3 4 +# 29 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" 1 3 4 +# 30 "/usr/include/x86_64-linux-gnu/bits/socket.h" 2 3 4 + + + + + +typedef __socklen_t socklen_t; + + + + +enum __socket_type +{ + SOCK_STREAM = 1, + + + SOCK_DGRAM = 2, + + + SOCK_RAW = 3, + + SOCK_RDM = 4, + + SOCK_SEQPACKET = 5, + + + SOCK_DCCP = 6, + + SOCK_PACKET = 10, + + + + + + + + SOCK_CLOEXEC = 02000000, + + + SOCK_NONBLOCK = 04000 + + +}; +# 177 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/sockaddr.h" 1 3 4 +# 29 "/usr/include/x86_64-linux-gnu/bits/sockaddr.h" 3 4 +typedef unsigned short int sa_family_t; +# 178 "/usr/include/x86_64-linux-gnu/bits/socket.h" 2 3 4 + + +struct sockaddr + { + sa_family_t sa_family; + char sa_data[14]; + }; +# 193 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4 +struct sockaddr_storage + { + sa_family_t ss_family; + unsigned long int __ss_align; + char __ss_padding[(128 - (2 * sizeof (unsigned long int)))]; + }; + + + +enum + { + MSG_OOB = 0x01, + + MSG_PEEK = 0x02, + + MSG_DONTROUTE = 0x04, + + + + + + + MSG_CTRUNC = 0x08, + + MSG_PROXY = 0x10, + + MSG_TRUNC = 0x20, + + MSG_DONTWAIT = 0x40, + + MSG_EOR = 0x80, + + MSG_WAITALL = 0x100, + + MSG_FIN = 0x200, + + MSG_SYN = 0x400, + + MSG_CONFIRM = 0x800, + + MSG_RST = 0x1000, + + MSG_ERRQUEUE = 0x2000, + + MSG_NOSIGNAL = 0x4000, + + MSG_MORE = 0x8000, + + MSG_WAITFORONE = 0x10000, + + + MSG_CMSG_CLOEXEC = 0x40000000 + + + + }; + + + + +struct msghdr + { + void *msg_name; + socklen_t msg_namelen; + + struct iovec *msg_iov; + size_t msg_iovlen; + + void *msg_control; + size_t msg_controllen; + + + + + int msg_flags; + }; +# 280 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4 +struct cmsghdr + { + size_t cmsg_len; + + + + + int cmsg_level; + int cmsg_type; + + __extension__ unsigned char __cmsg_data []; + + }; +# 310 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4 +extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr, + struct cmsghdr *__cmsg) __attribute__ ((__nothrow__ , __leaf__)); +# 337 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4 +enum + { + SCM_RIGHTS = 0x01 + + + + + + }; +# 383 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/asm/socket.h" 1 3 4 +# 1 "/usr/include/asm-generic/socket.h" 1 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/asm/sockios.h" 1 3 4 +# 1 "/usr/include/asm-generic/sockios.h" 1 3 4 +# 1 "/usr/include/x86_64-linux-gnu/asm/sockios.h" 2 3 4 +# 5 "/usr/include/asm-generic/socket.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/asm/socket.h" 2 3 4 +# 384 "/usr/include/x86_64-linux-gnu/bits/socket.h" 2 3 4 +# 417 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4 +struct linger + { + int l_onoff; + int l_linger; + }; + + + + + + + + + +extern int recvmmsg (int __fd, struct mmsghdr *__vmessages, + unsigned int __vlen, int __flags, + __const struct timespec *__tmo); + + + + + +extern int sendmmsg (int __fd, struct mmsghdr *__vmessages, + unsigned int __vlen, int __flags); + + +# 41 "/usr/include/x86_64-linux-gnu/sys/socket.h" 2 3 4 + + + + +struct osockaddr + { + unsigned short int sa_family; + unsigned char sa_data[14]; + }; + + + + +enum +{ + SHUT_RD = 0, + + SHUT_WR, + + SHUT_RDWR + +}; +# 105 "/usr/include/x86_64-linux-gnu/sys/socket.h" 3 4 +extern int socket (int __domain, int __type, int __protocol) __attribute__ ((__nothrow__ , __leaf__)); + + + + + +extern int socketpair (int __domain, int __type, int __protocol, + int __fds[2]) __attribute__ ((__nothrow__ , __leaf__)); + + +extern int bind (int __fd, __const struct sockaddr * __addr, socklen_t __len) + __attribute__ ((__nothrow__ , __leaf__)); + + +extern int getsockname (int __fd, struct sockaddr *__restrict __addr, + socklen_t *__restrict __len) __attribute__ ((__nothrow__ , __leaf__)); +# 129 "/usr/include/x86_64-linux-gnu/sys/socket.h" 3 4 +extern int connect (int __fd, __const struct sockaddr * __addr, socklen_t __len); + + + +extern int getpeername (int __fd, struct sockaddr *__restrict __addr, + socklen_t *__restrict __len) __attribute__ ((__nothrow__ , __leaf__)); + + + + + + +extern ssize_t send (int __fd, __const void *__buf, size_t __n, int __flags); + + + + + + +extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags); + + + + + + +extern ssize_t sendto (int __fd, __const void *__buf, size_t __n, + int __flags, __const struct sockaddr * __addr, + socklen_t __addr_len); +# 166 "/usr/include/x86_64-linux-gnu/sys/socket.h" 3 4 +extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n, + int __flags, struct sockaddr *__restrict __addr, + socklen_t *__restrict __addr_len); + + + + + + + +extern ssize_t sendmsg (int __fd, __const struct msghdr *__message, + int __flags); + + + + + + +extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags); + + + + + +extern int getsockopt (int __fd, int __level, int __optname, + void *__restrict __optval, + socklen_t *__restrict __optlen) __attribute__ ((__nothrow__ , __leaf__)); + + + + +extern int setsockopt (int __fd, int __level, int __optname, + __const void *__optval, socklen_t __optlen) __attribute__ ((__nothrow__ , __leaf__)); + + + + + +extern int listen (int __fd, int __n) __attribute__ ((__nothrow__ , __leaf__)); +# 214 "/usr/include/x86_64-linux-gnu/sys/socket.h" 3 4 +extern int accept (int __fd, struct sockaddr *__restrict __addr, + socklen_t *__restrict __addr_len); +# 232 "/usr/include/x86_64-linux-gnu/sys/socket.h" 3 4 +extern int shutdown (int __fd, int __how) __attribute__ ((__nothrow__ , __leaf__)); + + + + +extern int sockatmark (int __fd) __attribute__ ((__nothrow__ , __leaf__)); + + + + + + + +extern int isfdtype (int __fd, int __fdtype) __attribute__ ((__nothrow__ , __leaf__)); +# 254 "/usr/include/x86_64-linux-gnu/sys/socket.h" 3 4 + +# 43 "/usr/include/gcrypt.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/sys/time.h" 1 3 4 +# 27 "/usr/include/x86_64-linux-gnu/sys/time.h" 3 4 +# 1 "/usr/include/time.h" 1 3 4 +# 28 "/usr/include/x86_64-linux-gnu/sys/time.h" 2 3 4 + +# 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4 +# 30 "/usr/include/x86_64-linux-gnu/sys/time.h" 2 3 4 +# 39 "/usr/include/x86_64-linux-gnu/sys/time.h" 3 4 + +# 57 "/usr/include/x86_64-linux-gnu/sys/time.h" 3 4 +struct timezone + { + int tz_minuteswest; + int tz_dsttime; + }; + +typedef struct timezone *__restrict __timezone_ptr_t; +# 73 "/usr/include/x86_64-linux-gnu/sys/time.h" 3 4 +extern int gettimeofday (struct timeval *__restrict __tv, + __timezone_ptr_t __tz) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); + + + + +extern int settimeofday (__const struct timeval *__tv, + __const struct timezone *__tz) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); + + + + + +extern int adjtime (__const struct timeval *__delta, + struct timeval *__olddelta) __attribute__ ((__nothrow__ , __leaf__)); + + + + +enum __itimer_which + { + + ITIMER_REAL = 0, + + + ITIMER_VIRTUAL = 1, + + + + ITIMER_PROF = 2 + + }; + + + +struct itimerval + { + + struct timeval it_interval; + + struct timeval it_value; + }; + + + + + + +typedef int __itimer_which_t; + + + + +extern int getitimer (__itimer_which_t __which, + struct itimerval *__value) __attribute__ ((__nothrow__ , __leaf__)); + + + + +extern int setitimer (__itimer_which_t __which, + __const struct itimerval *__restrict __new, + struct itimerval *__restrict __old) __attribute__ ((__nothrow__ , __leaf__)); + + + + +extern int utimes (__const char *__file, __const struct timeval __tvp[2]) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); + + + +extern int lutimes (__const char *__file, __const struct timeval __tvp[2]) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); + + +extern int futimes (int __fd, __const struct timeval __tvp[2]) __attribute__ ((__nothrow__ , __leaf__)); +# 191 "/usr/include/x86_64-linux-gnu/sys/time.h" 3 4 + +# 44 "/usr/include/gcrypt.h" 2 3 4 + + + +typedef socklen_t gcry_socklen_t; +# 117 "/usr/include/gcrypt.h" 3 4 +typedef gpg_error_t gcry_error_t; +typedef gpg_err_code_t gcry_err_code_t; +typedef gpg_err_source_t gcry_err_source_t; + +static __inline__ gcry_error_t +gcry_err_make (gcry_err_source_t source, gcry_err_code_t code) +{ + return gpg_err_make (source, code); +} + + + + + + + +static __inline__ gcry_error_t +gcry_error (gcry_err_code_t code) +{ + return gcry_err_make (GPG_ERR_SOURCE_USER_1, code); +} + +static __inline__ gcry_err_code_t +gcry_err_code (gcry_error_t err) +{ + return gpg_err_code (err); +} + + +static __inline__ gcry_err_source_t +gcry_err_source (gcry_error_t err) +{ + return gpg_err_source (err); +} + + + +const char *gcry_strerror (gcry_error_t err); + + + +const char *gcry_strsource (gcry_error_t err); + + + + +gcry_err_code_t gcry_err_code_from_errno (int err); + + + +int gcry_err_code_to_errno (gcry_err_code_t code); + + + +gcry_error_t gcry_err_make_from_errno (gcry_err_source_t source, int err); + + +gcry_err_code_t gcry_error_from_errno (int err); + + + + +enum gcry_thread_option + { + _GCRY_THREAD_OPTION_DUMMY + } __attribute__ ((__deprecated__)); +# 197 "/usr/include/gcrypt.h" 3 4 +struct gcry_thread_cbs +{ + + + + + + unsigned int option; + + int (*init) (void); + int (*mutex_init) (void **priv); + int (*mutex_destroy) (void **priv); + int (*mutex_lock) (void **priv); + int (*mutex_unlock) (void **priv); + ssize_t (*read) (int fd, void *buf, size_t nbytes); + ssize_t (*write) (int fd, const void *buf, size_t nbytes); +# 222 "/usr/include/gcrypt.h" 3 4 + ssize_t (*select) (int nfd, fd_set *rset, fd_set *wset, fd_set *eset, + struct timeval *timeout); + ssize_t (*waitpid) (pid_t pid, int *status, int options); + int (*accept) (int s, struct sockaddr *addr, gcry_socklen_t *length_ptr); + int (*connect) (int s, struct sockaddr *addr, gcry_socklen_t length); + int (*sendmsg) (int s, const struct msghdr *msg, int flags); + int (*recvmsg) (int s, struct msghdr *msg, int flags); + +}; +# 343 "/usr/include/gcrypt.h" 3 4 +struct gcry_mpi; +typedef struct gcry_mpi *gcry_mpi_t; + + +typedef struct gcry_mpi *GCRY_MPI __attribute__ ((__deprecated__)); +typedef struct gcry_mpi *GcryMPI __attribute__ ((__deprecated__)); + + + + + +const char *gcry_check_version (const char *req_version); + + + + +enum gcry_ctl_cmds + { + GCRYCTL_SET_KEY = 1, + GCRYCTL_SET_IV = 2, + GCRYCTL_CFB_SYNC = 3, + GCRYCTL_RESET = 4, + GCRYCTL_FINALIZE = 5, + GCRYCTL_GET_KEYLEN = 6, + GCRYCTL_GET_BLKLEN = 7, + GCRYCTL_TEST_ALGO = 8, + GCRYCTL_IS_SECURE = 9, + GCRYCTL_GET_ASNOID = 10, + GCRYCTL_ENABLE_ALGO = 11, + GCRYCTL_DISABLE_ALGO = 12, + GCRYCTL_DUMP_RANDOM_STATS = 13, + GCRYCTL_DUMP_SECMEM_STATS = 14, + GCRYCTL_GET_ALGO_NPKEY = 15, + GCRYCTL_GET_ALGO_NSKEY = 16, + GCRYCTL_GET_ALGO_NSIGN = 17, + GCRYCTL_GET_ALGO_NENCR = 18, + GCRYCTL_SET_VERBOSITY = 19, + GCRYCTL_SET_DEBUG_FLAGS = 20, + GCRYCTL_CLEAR_DEBUG_FLAGS = 21, + GCRYCTL_USE_SECURE_RNDPOOL= 22, + GCRYCTL_DUMP_MEMORY_STATS = 23, + GCRYCTL_INIT_SECMEM = 24, + GCRYCTL_TERM_SECMEM = 25, + GCRYCTL_DISABLE_SECMEM_WARN = 27, + GCRYCTL_SUSPEND_SECMEM_WARN = 28, + GCRYCTL_RESUME_SECMEM_WARN = 29, + GCRYCTL_DROP_PRIVS = 30, + GCRYCTL_ENABLE_M_GUARD = 31, + GCRYCTL_START_DUMP = 32, + GCRYCTL_STOP_DUMP = 33, + GCRYCTL_GET_ALGO_USAGE = 34, + GCRYCTL_IS_ALGO_ENABLED = 35, + GCRYCTL_DISABLE_INTERNAL_LOCKING = 36, + GCRYCTL_DISABLE_SECMEM = 37, + GCRYCTL_INITIALIZATION_FINISHED = 38, + GCRYCTL_INITIALIZATION_FINISHED_P = 39, + GCRYCTL_ANY_INITIALIZATION_P = 40, + GCRYCTL_SET_CBC_CTS = 41, + GCRYCTL_SET_CBC_MAC = 42, + GCRYCTL_SET_CTR = 43, + GCRYCTL_ENABLE_QUICK_RANDOM = 44, + GCRYCTL_SET_RANDOM_SEED_FILE = 45, + GCRYCTL_UPDATE_RANDOM_SEED_FILE = 46, + GCRYCTL_SET_THREAD_CBS = 47, + GCRYCTL_FAST_POLL = 48, + GCRYCTL_SET_RANDOM_DAEMON_SOCKET = 49, + GCRYCTL_USE_RANDOM_DAEMON = 50, + GCRYCTL_FAKED_RANDOM_P = 51, + GCRYCTL_SET_RNDEGD_SOCKET = 52, + GCRYCTL_PRINT_CONFIG = 53, + GCRYCTL_OPERATIONAL_P = 54, + GCRYCTL_FIPS_MODE_P = 55, + GCRYCTL_FORCE_FIPS_MODE = 56, + GCRYCTL_SELFTEST = 57, + + GCRYCTL_DISABLE_HWF = 63 + }; + + +gcry_error_t gcry_control (enum gcry_ctl_cmds CMD, ...); + + + + + + +struct gcry_sexp; +typedef struct gcry_sexp *gcry_sexp_t; + + +typedef struct gcry_sexp *GCRY_SEXP __attribute__ ((__deprecated__)); +typedef struct gcry_sexp *GcrySexp __attribute__ ((__deprecated__)); + + + +enum gcry_sexp_format + { + GCRYSEXP_FMT_DEFAULT = 0, + GCRYSEXP_FMT_CANON = 1, + GCRYSEXP_FMT_BASE64 = 2, + GCRYSEXP_FMT_ADVANCED = 3 + }; + + + + +gcry_error_t gcry_sexp_new (gcry_sexp_t *retsexp, + const void *buffer, size_t length, + int autodetect); + + + +gcry_error_t gcry_sexp_create (gcry_sexp_t *retsexp, + void *buffer, size_t length, + int autodetect, void (*freefnc) (void *)); + + + +gcry_error_t gcry_sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff, + const char *buffer, size_t length); + + + +gcry_error_t gcry_sexp_build (gcry_sexp_t *retsexp, size_t *erroff, + const char *format, ...); + + + +gcry_error_t gcry_sexp_build_array (gcry_sexp_t *retsexp, size_t *erroff, + const char *format, void **arg_list); + + +void gcry_sexp_release (gcry_sexp_t sexp); + + + +size_t gcry_sexp_canon_len (const unsigned char *buffer, size_t length, + size_t *erroff, gcry_error_t *errcode); + + + +size_t gcry_sexp_sprint (gcry_sexp_t sexp, int mode, void *buffer, + size_t maxlength); + + + +void gcry_sexp_dump (const gcry_sexp_t a); + +gcry_sexp_t gcry_sexp_cons (const gcry_sexp_t a, const gcry_sexp_t b); +gcry_sexp_t gcry_sexp_alist (const gcry_sexp_t *array); +gcry_sexp_t gcry_sexp_vlist (const gcry_sexp_t a, ...); +gcry_sexp_t gcry_sexp_append (const gcry_sexp_t a, const gcry_sexp_t n); +gcry_sexp_t gcry_sexp_prepend (const gcry_sexp_t a, const gcry_sexp_t n); + + + + + + +gcry_sexp_t gcry_sexp_find_token (gcry_sexp_t list, + const char *tok, size_t toklen); + + +int gcry_sexp_length (const gcry_sexp_t list); + + + + +gcry_sexp_t gcry_sexp_nth (const gcry_sexp_t list, int number); + + + + +gcry_sexp_t gcry_sexp_car (const gcry_sexp_t list); + + + + + + +gcry_sexp_t gcry_sexp_cdr (const gcry_sexp_t list); + +gcry_sexp_t gcry_sexp_cadr (const gcry_sexp_t list); +# 534 "/usr/include/gcrypt.h" 3 4 +const char *gcry_sexp_nth_data (const gcry_sexp_t list, int number, + size_t *datalen); + + + + + + +char *gcry_sexp_nth_string (gcry_sexp_t list, int number); + + + + + + + +gcry_mpi_t gcry_sexp_nth_mpi (gcry_sexp_t list, int number, int mpifmt); +# 561 "/usr/include/gcrypt.h" 3 4 +enum gcry_mpi_format + { + GCRYMPI_FMT_NONE= 0, + GCRYMPI_FMT_STD = 1, + GCRYMPI_FMT_PGP = 2, + GCRYMPI_FMT_SSH = 3, + GCRYMPI_FMT_HEX = 4, + GCRYMPI_FMT_USG = 5 + }; + + +enum gcry_mpi_flag + { + GCRYMPI_FLAG_SECURE = 1, + GCRYMPI_FLAG_OPAQUE = 2 + + + }; + + + + +gcry_mpi_t gcry_mpi_new (unsigned int nbits); + + +gcry_mpi_t gcry_mpi_snew (unsigned int nbits); + + +void gcry_mpi_release (gcry_mpi_t a); + + +gcry_mpi_t gcry_mpi_copy (const gcry_mpi_t a); + + +gcry_mpi_t gcry_mpi_set (gcry_mpi_t w, const gcry_mpi_t u); + + +gcry_mpi_t gcry_mpi_set_ui (gcry_mpi_t w, unsigned long u); + + +void gcry_mpi_swap (gcry_mpi_t a, gcry_mpi_t b); + + + +int gcry_mpi_cmp (const gcry_mpi_t u, const gcry_mpi_t v); + + + + +int gcry_mpi_cmp_ui (const gcry_mpi_t u, unsigned long v); + + + + + +gcry_error_t gcry_mpi_scan (gcry_mpi_t *ret_mpi, enum gcry_mpi_format format, + const void *buffer, size_t buflen, + size_t *nscanned); + + + + + + +gcry_error_t gcry_mpi_print (enum gcry_mpi_format format, + unsigned char *buffer, size_t buflen, + size_t *nwritten, + const gcry_mpi_t a); + + + + + +gcry_error_t gcry_mpi_aprint (enum gcry_mpi_format format, + unsigned char **buffer, size_t *nwritten, + const gcry_mpi_t a); + + + + + +void gcry_mpi_dump (const gcry_mpi_t a); + + + +void gcry_mpi_add (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v); + + +void gcry_mpi_add_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v); + + +void gcry_mpi_addm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m); + + +void gcry_mpi_sub (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v); + + +void gcry_mpi_sub_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v ); + + +void gcry_mpi_subm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m); + + +void gcry_mpi_mul (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v); + + +void gcry_mpi_mul_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v ); + + +void gcry_mpi_mulm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m); + + +void gcry_mpi_mul_2exp (gcry_mpi_t w, gcry_mpi_t u, unsigned long cnt); + + + +void gcry_mpi_div (gcry_mpi_t q, gcry_mpi_t r, + gcry_mpi_t dividend, gcry_mpi_t divisor, int round); + + +void gcry_mpi_mod (gcry_mpi_t r, gcry_mpi_t dividend, gcry_mpi_t divisor); + + +void gcry_mpi_powm (gcry_mpi_t w, + const gcry_mpi_t b, const gcry_mpi_t e, + const gcry_mpi_t m); + + + +int gcry_mpi_gcd (gcry_mpi_t g, gcry_mpi_t a, gcry_mpi_t b); + + + +int gcry_mpi_invm (gcry_mpi_t x, gcry_mpi_t a, gcry_mpi_t m); + + + +unsigned int gcry_mpi_get_nbits (gcry_mpi_t a); + + +int gcry_mpi_test_bit (gcry_mpi_t a, unsigned int n); + + +void gcry_mpi_set_bit (gcry_mpi_t a, unsigned int n); + + +void gcry_mpi_clear_bit (gcry_mpi_t a, unsigned int n); + + +void gcry_mpi_set_highbit (gcry_mpi_t a, unsigned int n); + + +void gcry_mpi_clear_highbit (gcry_mpi_t a, unsigned int n); + + +void gcry_mpi_rshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n); + + +void gcry_mpi_lshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n); + + + + +gcry_mpi_t gcry_mpi_set_opaque (gcry_mpi_t a, void *p, unsigned int nbits); + + + + +void *gcry_mpi_get_opaque (gcry_mpi_t a, unsigned int *nbits); + + + + +void gcry_mpi_set_flag (gcry_mpi_t a, enum gcry_mpi_flag flag); + + + +void gcry_mpi_clear_flag (gcry_mpi_t a, enum gcry_mpi_flag flag); + + +int gcry_mpi_get_flag (gcry_mpi_t a, enum gcry_mpi_flag flag); +# 801 "/usr/include/gcrypt.h" 3 4 +struct gcry_cipher_handle; +typedef struct gcry_cipher_handle *gcry_cipher_hd_t; + + +typedef struct gcry_cipher_handle *GCRY_CIPHER_HD __attribute__ ((__deprecated__)); +typedef struct gcry_cipher_handle *GcryCipherHd __attribute__ ((__deprecated__)); + + + + +enum gcry_cipher_algos + { + GCRY_CIPHER_NONE = 0, + GCRY_CIPHER_IDEA = 1, + GCRY_CIPHER_3DES = 2, + GCRY_CIPHER_CAST5 = 3, + GCRY_CIPHER_BLOWFISH = 4, + GCRY_CIPHER_SAFER_SK128 = 5, + GCRY_CIPHER_DES_SK = 6, + GCRY_CIPHER_AES = 7, + GCRY_CIPHER_AES192 = 8, + GCRY_CIPHER_AES256 = 9, + GCRY_CIPHER_TWOFISH = 10, + + + GCRY_CIPHER_ARCFOUR = 301, + GCRY_CIPHER_DES = 302, + GCRY_CIPHER_TWOFISH128 = 303, + GCRY_CIPHER_SERPENT128 = 304, + GCRY_CIPHER_SERPENT192 = 305, + GCRY_CIPHER_SERPENT256 = 306, + GCRY_CIPHER_RFC2268_40 = 307, + GCRY_CIPHER_RFC2268_128 = 308, + GCRY_CIPHER_SEED = 309, + GCRY_CIPHER_CAMELLIA128 = 310, + GCRY_CIPHER_CAMELLIA192 = 311, + GCRY_CIPHER_CAMELLIA256 = 312 + }; +# 849 "/usr/include/gcrypt.h" 3 4 +enum gcry_cipher_modes + { + GCRY_CIPHER_MODE_NONE = 0, + GCRY_CIPHER_MODE_ECB = 1, + GCRY_CIPHER_MODE_CFB = 2, + GCRY_CIPHER_MODE_CBC = 3, + GCRY_CIPHER_MODE_STREAM = 4, + GCRY_CIPHER_MODE_OFB = 5, + GCRY_CIPHER_MODE_CTR = 6, + GCRY_CIPHER_MODE_AESWRAP= 7 + }; + + +enum gcry_cipher_flags + { + GCRY_CIPHER_SECURE = 1, + GCRY_CIPHER_ENABLE_SYNC = 2, + GCRY_CIPHER_CBC_CTS = 4, + GCRY_CIPHER_CBC_MAC = 8 + }; + + + + +gcry_error_t gcry_cipher_open (gcry_cipher_hd_t *handle, + int algo, int mode, unsigned int flags); + + +void gcry_cipher_close (gcry_cipher_hd_t h); + + +gcry_error_t gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, + size_t buflen); + + +gcry_error_t gcry_cipher_info (gcry_cipher_hd_t h, int what, void *buffer, + size_t *nbytes); + + +gcry_error_t gcry_cipher_algo_info (int algo, int what, void *buffer, + size_t *nbytes); + + + + +const char *gcry_cipher_algo_name (int algorithm) __attribute__ ((__pure__)); + + + +int gcry_cipher_map_name (const char *name) __attribute__ ((__pure__)); + + + + +int gcry_cipher_mode_from_oid (const char *string) __attribute__ ((__pure__)); + + + + + +gcry_error_t gcry_cipher_encrypt (gcry_cipher_hd_t h, + void *out, size_t outsize, + const void *in, size_t inlen); + + +gcry_error_t gcry_cipher_decrypt (gcry_cipher_hd_t h, + void *out, size_t outsize, + const void *in, size_t inlen); + + +gcry_error_t gcry_cipher_setkey (gcry_cipher_hd_t hd, + const void *key, size_t keylen); + + + +gcry_error_t gcry_cipher_setiv (gcry_cipher_hd_t hd, + const void *iv, size_t ivlen); +# 941 "/usr/include/gcrypt.h" 3 4 +gpg_error_t gcry_cipher_setctr (gcry_cipher_hd_t hd, + const void *ctr, size_t ctrlen); + + +size_t gcry_cipher_get_algo_keylen (int algo); + + +size_t gcry_cipher_get_algo_blklen (int algo); +# 960 "/usr/include/gcrypt.h" 3 4 +gcry_error_t gcry_cipher_list (int *list, int *list_length); +# 970 "/usr/include/gcrypt.h" 3 4 +enum gcry_pk_algos + { + GCRY_PK_RSA = 1, + GCRY_PK_RSA_E = 2, + GCRY_PK_RSA_S = 3, + GCRY_PK_ELG_E = 16, + GCRY_PK_DSA = 17, + GCRY_PK_ELG = 20, + GCRY_PK_ECDSA = 301, + GCRY_PK_ECDH = 302 + }; +# 991 "/usr/include/gcrypt.h" 3 4 +gcry_error_t gcry_pk_encrypt (gcry_sexp_t *result, + gcry_sexp_t data, gcry_sexp_t pkey); + + + +gcry_error_t gcry_pk_decrypt (gcry_sexp_t *result, + gcry_sexp_t data, gcry_sexp_t skey); + + + +gcry_error_t gcry_pk_sign (gcry_sexp_t *result, + gcry_sexp_t data, gcry_sexp_t skey); + + +gcry_error_t gcry_pk_verify (gcry_sexp_t sigval, + gcry_sexp_t data, gcry_sexp_t pkey); + + +gcry_error_t gcry_pk_testkey (gcry_sexp_t key); + + + + +gcry_error_t gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms); + + +gcry_error_t gcry_pk_ctl (int cmd, void *buffer, size_t buflen); + + +gcry_error_t gcry_pk_algo_info (int algo, int what, + void *buffer, size_t *nbytes); + + + + +const char *gcry_pk_algo_name (int algorithm) __attribute__ ((__pure__)); + + + +int gcry_pk_map_name (const char* name) __attribute__ ((__pure__)); + + + +unsigned int gcry_pk_get_nbits (gcry_sexp_t key) __attribute__ ((__pure__)); + + + +unsigned char *gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array); + + +const char *gcry_pk_get_curve (gcry_sexp_t key, int iterator, + unsigned int *r_nbits); + + + +gcry_sexp_t gcry_pk_get_param (int algo, const char *name); +# 1058 "/usr/include/gcrypt.h" 3 4 +gcry_error_t gcry_pk_list (int *list, int *list_length); +# 1070 "/usr/include/gcrypt.h" 3 4 +enum gcry_md_algos + { + GCRY_MD_NONE = 0, + GCRY_MD_MD5 = 1, + GCRY_MD_SHA1 = 2, + GCRY_MD_RMD160 = 3, + GCRY_MD_MD2 = 5, + GCRY_MD_TIGER = 6, + GCRY_MD_HAVAL = 7, + GCRY_MD_SHA256 = 8, + GCRY_MD_SHA384 = 9, + GCRY_MD_SHA512 = 10, + GCRY_MD_SHA224 = 11, + GCRY_MD_MD4 = 301, + GCRY_MD_CRC32 = 302, + GCRY_MD_CRC32_RFC1510 = 303, + GCRY_MD_CRC24_RFC2440 = 304, + GCRY_MD_WHIRLPOOL = 305, + GCRY_MD_TIGER1 = 306, + GCRY_MD_TIGER2 = 307 + }; + + +enum gcry_md_flags + { + GCRY_MD_FLAG_SECURE = 1, + GCRY_MD_FLAG_HMAC = 2 + }; + + +struct gcry_md_context; + + + + +typedef struct gcry_md_handle +{ + + struct gcry_md_context *ctx; + + + int bufpos; + int bufsize; + unsigned char buf[1]; +} *gcry_md_hd_t; + + + +typedef struct gcry_md_handle *GCRY_MD_HD __attribute__ ((__deprecated__)); +typedef struct gcry_md_handle *GcryMDHd __attribute__ ((__deprecated__)); + + + + + + +gcry_error_t gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags); + + +void gcry_md_close (gcry_md_hd_t hd); + + +gcry_error_t gcry_md_enable (gcry_md_hd_t hd, int algo); + + +gcry_error_t gcry_md_copy (gcry_md_hd_t *bhd, gcry_md_hd_t ahd); + + +void gcry_md_reset (gcry_md_hd_t hd); + + +gcry_error_t gcry_md_ctl (gcry_md_hd_t hd, int cmd, + void *buffer, size_t buflen); + + + + +void gcry_md_write (gcry_md_hd_t hd, const void *buffer, size_t length); + + + +unsigned char *gcry_md_read (gcry_md_hd_t hd, int algo); + + + + + + +void gcry_md_hash_buffer (int algo, void *digest, + const void *buffer, size_t length); + + + +int gcry_md_get_algo (gcry_md_hd_t hd); + + + +unsigned int gcry_md_get_algo_dlen (int algo); + + + +int gcry_md_is_enabled (gcry_md_hd_t a, int algo); + + +int gcry_md_is_secure (gcry_md_hd_t a); + + +gcry_error_t gcry_md_info (gcry_md_hd_t h, int what, void *buffer, + size_t *nbytes); + + +gcry_error_t gcry_md_algo_info (int algo, int what, void *buffer, + size_t *nbytes); + + + + +const char *gcry_md_algo_name (int algo) __attribute__ ((__pure__)); + + + +int gcry_md_map_name (const char* name) __attribute__ ((__pure__)); + + + +gcry_error_t gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen); + + + + +void gcry_md_debug (gcry_md_hd_t hd, const char *suffix); +# 1249 "/usr/include/gcrypt.h" 3 4 +gcry_error_t gcry_md_list (int *list, int *list_length); + + + + + + +typedef enum gcry_ac_id + { + GCRY_AC_RSA = 1, + GCRY_AC_DSA = 17, + GCRY_AC_ELG = 20, + GCRY_AC_ELG_E = 16 + } +gcry_ac_id_t __attribute__ ((__deprecated__)); + + +typedef enum gcry_ac_key_type + { + GCRY_AC_KEY_SECRET, + GCRY_AC_KEY_PUBLIC + } +gcry_ac_key_type_t __attribute__ ((__deprecated__)); + + +typedef enum gcry_ac_em + { + GCRY_AC_EME_PKCS_V1_5, + GCRY_AC_EMSA_PKCS_V1_5 + } +gcry_ac_em_t __attribute__ ((__deprecated__)); + + +typedef enum gcry_ac_scheme + { + GCRY_AC_ES_PKCS_V1_5, + GCRY_AC_SSA_PKCS_V1_5 + } +gcry_ac_scheme_t __attribute__ ((__deprecated__)); + + + + + + + +typedef struct gcry_ac_data *gcry_ac_data_t __attribute__ ((__deprecated__)); + + + +typedef struct gcry_ac_key *gcry_ac_key_t __attribute__ ((__deprecated__)); + + + +typedef struct gcry_ac_key_pair *gcry_ac_key_pair_t __attribute__ ((__deprecated__)); + + + +typedef struct gcry_ac_handle *gcry_ac_handle_t __attribute__ ((__deprecated__)); + +typedef gpg_error_t (*gcry_ac_data_read_cb_t) (void *opaque, + unsigned char *buffer, + size_t *buffer_n) + __attribute__ ((__deprecated__)); + +typedef gpg_error_t (*gcry_ac_data_write_cb_t) (void *opaque, + unsigned char *buffer, + size_t buffer_n) + __attribute__ ((__deprecated__)); + +typedef enum + { + GCRY_AC_IO_READABLE, + GCRY_AC_IO_WRITABLE + } +gcry_ac_io_mode_t __attribute__ ((__deprecated__)); + +typedef enum + { + GCRY_AC_IO_STRING, + GCRY_AC_IO_CALLBACK + } +gcry_ac_io_type_t __attribute__ ((__deprecated__)); + +typedef struct gcry_ac_io +{ + + gcry_ac_io_mode_t mode __attribute__ ((__deprecated__)); + gcry_ac_io_type_t type __attribute__ ((__deprecated__)); + union + { + union + { + struct + { + gcry_ac_data_read_cb_t cb; + void *opaque; + } callback; + struct + { + unsigned char *data; + size_t data_n; + } string; + void *opaque; + } readable; + union + { + struct + { + gcry_ac_data_write_cb_t cb; + void *opaque; + } callback; + struct + { + unsigned char **data; + size_t *data_n; + } string; + void *opaque; + } writable; + } io __attribute__ ((__deprecated__)); +} +gcry_ac_io_t __attribute__ ((__deprecated__)); + + + + +typedef struct gcry_ac_key_spec_rsa +{ + gcry_mpi_t e; +} gcry_ac_key_spec_rsa_t __attribute__ ((__deprecated__)); + + + +typedef struct gcry_ac_eme_pkcs_v1_5 +{ + size_t key_size; +} gcry_ac_eme_pkcs_v1_5_t __attribute__ ((__deprecated__)); + +typedef enum gcry_md_algos gcry_md_algo_t __attribute__ ((__deprecated__)); + + + +typedef struct gcry_ac_emsa_pkcs_v1_5 +{ + gcry_md_algo_t md; + size_t em_n; +} gcry_ac_emsa_pkcs_v1_5_t __attribute__ ((__deprecated__)); + + + +typedef struct gcry_ac_ssa_pkcs_v1_5 +{ + gcry_md_algo_t md; +} gcry_ac_ssa_pkcs_v1_5_t __attribute__ ((__deprecated__)); + + + + +gcry_error_t gcry_ac_data_new (gcry_ac_data_t *data) + __attribute__ ((__deprecated__)); + + +void gcry_ac_data_destroy (gcry_ac_data_t data) + __attribute__ ((__deprecated__)); + + +gcry_error_t gcry_ac_data_copy (gcry_ac_data_t *data_cp, + gcry_ac_data_t data) + __attribute__ ((__deprecated__)); + + + +unsigned int gcry_ac_data_length (gcry_ac_data_t data) + __attribute__ ((__deprecated__)); + + +void gcry_ac_data_clear (gcry_ac_data_t data) + __attribute__ ((__deprecated__)); + + + + + + +gcry_error_t gcry_ac_data_set (gcry_ac_data_t data, unsigned int flags, + const char *name, gcry_mpi_t mpi) + __attribute__ ((__deprecated__)); + + + + +gcry_error_t gcry_ac_data_get_name (gcry_ac_data_t data, unsigned int flags, + const char *name, gcry_mpi_t *mpi) + __attribute__ ((__deprecated__)); + + + + + +gcry_error_t gcry_ac_data_get_index (gcry_ac_data_t data, unsigned int flags, + unsigned int idx, + const char **name, gcry_mpi_t *mpi) + __attribute__ ((__deprecated__)); + + + + +gcry_error_t gcry_ac_data_to_sexp (gcry_ac_data_t data, gcry_sexp_t *sexp, + const char **identifiers) + __attribute__ ((__deprecated__)); + + + + +gcry_error_t gcry_ac_data_from_sexp (gcry_ac_data_t *data, gcry_sexp_t sexp, + const char **identifiers) + __attribute__ ((__deprecated__)); + + + + +void gcry_ac_io_init (gcry_ac_io_t *ac_io, gcry_ac_io_mode_t mode, + gcry_ac_io_type_t type, ...) + __attribute__ ((__deprecated__)); + + + + +void gcry_ac_io_init_va (gcry_ac_io_t *ac_io, gcry_ac_io_mode_t mode, + gcry_ac_io_type_t type, va_list ap) + __attribute__ ((__deprecated__)); + + +gcry_error_t gcry_ac_open (gcry_ac_handle_t *handle, + gcry_ac_id_t algorithm, unsigned int flags) + __attribute__ ((__deprecated__)); + + +void gcry_ac_close (gcry_ac_handle_t handle) + __attribute__ ((__deprecated__)); + + +gcry_error_t gcry_ac_key_init (gcry_ac_key_t *key, gcry_ac_handle_t handle, + gcry_ac_key_type_t type, gcry_ac_data_t data) + __attribute__ ((__deprecated__)); + + + + + + +gcry_error_t gcry_ac_key_pair_generate (gcry_ac_handle_t handle, + unsigned int nbits, void *spec, + gcry_ac_key_pair_t *key_pair, + gcry_mpi_t **misc_data) + __attribute__ ((__deprecated__)); + + +gcry_ac_key_t gcry_ac_key_pair_extract (gcry_ac_key_pair_t key_pair, + gcry_ac_key_type_t which) + __attribute__ ((__deprecated__)); + + +gcry_ac_data_t gcry_ac_key_data_get (gcry_ac_key_t key) + __attribute__ ((__deprecated__)); + + +gcry_error_t gcry_ac_key_test (gcry_ac_handle_t handle, gcry_ac_key_t key) + __attribute__ ((__deprecated__)); + + +gcry_error_t gcry_ac_key_get_nbits (gcry_ac_handle_t handle, + gcry_ac_key_t key, unsigned int *nbits) + __attribute__ ((__deprecated__)); + + + +gcry_error_t gcry_ac_key_get_grip (gcry_ac_handle_t handle, gcry_ac_key_t key, + unsigned char *key_grip) + __attribute__ ((__deprecated__)); + + +void gcry_ac_key_destroy (gcry_ac_key_t key) + __attribute__ ((__deprecated__)); + + +void gcry_ac_key_pair_destroy (gcry_ac_key_pair_t key_pair) + __attribute__ ((__deprecated__)); + + + + +gcry_error_t gcry_ac_data_encode (gcry_ac_em_t method, + unsigned int flags, void *options, + gcry_ac_io_t *io_read, + gcry_ac_io_t *io_write) + __attribute__ ((__deprecated__)); + + + + +gcry_error_t gcry_ac_data_decode (gcry_ac_em_t method, + unsigned int flags, void *options, + gcry_ac_io_t *io_read, + gcry_ac_io_t *io_write) + __attribute__ ((__deprecated__)); + + + + +gcry_error_t gcry_ac_data_encrypt (gcry_ac_handle_t handle, + unsigned int flags, + gcry_ac_key_t key, + gcry_mpi_t data_plain, + gcry_ac_data_t *data_encrypted) + __attribute__ ((__deprecated__)); + + + + +gcry_error_t gcry_ac_data_decrypt (gcry_ac_handle_t handle, + unsigned int flags, + gcry_ac_key_t key, + gcry_mpi_t *data_plain, + gcry_ac_data_t data_encrypted) + __attribute__ ((__deprecated__)); + + + +gcry_error_t gcry_ac_data_sign (gcry_ac_handle_t handle, + gcry_ac_key_t key, + gcry_mpi_t data, + gcry_ac_data_t *data_signature) + __attribute__ ((__deprecated__)); + + + + +gcry_error_t gcry_ac_data_verify (gcry_ac_handle_t handle, + gcry_ac_key_t key, + gcry_mpi_t data, + gcry_ac_data_t data_signature) + __attribute__ ((__deprecated__)); + + + + + + +gcry_error_t gcry_ac_data_encrypt_scheme (gcry_ac_handle_t handle, + gcry_ac_scheme_t scheme, + unsigned int flags, void *opts, + gcry_ac_key_t key, + gcry_ac_io_t *io_message, + gcry_ac_io_t *io_cipher) + __attribute__ ((__deprecated__)); + + + + + + +gcry_error_t gcry_ac_data_decrypt_scheme (gcry_ac_handle_t handle, + gcry_ac_scheme_t scheme, + unsigned int flags, void *opts, + gcry_ac_key_t key, + gcry_ac_io_t *io_cipher, + gcry_ac_io_t *io_message) + __attribute__ ((__deprecated__)); + + + + + + +gcry_error_t gcry_ac_data_sign_scheme (gcry_ac_handle_t handle, + gcry_ac_scheme_t scheme, + unsigned int flags, void *opts, + gcry_ac_key_t key, + gcry_ac_io_t *io_message, + gcry_ac_io_t *io_signature) + __attribute__ ((__deprecated__)); + + + + + + + +gcry_error_t gcry_ac_data_verify_scheme (gcry_ac_handle_t handle, + gcry_ac_scheme_t scheme, + unsigned int flags, void *opts, + gcry_ac_key_t key, + gcry_ac_io_t *io_message, + gcry_ac_io_t *io_signature) + __attribute__ ((__deprecated__)); + + + + +gcry_error_t gcry_ac_id_to_name (gcry_ac_id_t algorithm, + const char **name) + __attribute__ ((__deprecated__)); + + + +gcry_error_t gcry_ac_name_to_id (const char *name, + gcry_ac_id_t *algorithm) + __attribute__ ((__deprecated__)); +# 1668 "/usr/include/gcrypt.h" 3 4 +enum gcry_kdf_algos + { + GCRY_KDF_NONE = 0, + GCRY_KDF_SIMPLE_S2K = 16, + GCRY_KDF_SALTED_S2K = 17, + GCRY_KDF_ITERSALTED_S2K = 19, + GCRY_KDF_PBKDF1 = 33, + GCRY_KDF_PBKDF2 = 34 + }; + + +gpg_error_t gcry_kdf_derive (const void *passphrase, size_t passphraselen, + int algo, int subalgo, + const void *salt, size_t saltlen, + unsigned long iterations, + size_t keysize, void *keybuffer); +# 1698 "/usr/include/gcrypt.h" 3 4 +typedef enum gcry_random_level + { + GCRY_WEAK_RANDOM = 0, + GCRY_STRONG_RANDOM = 1, + GCRY_VERY_STRONG_RANDOM = 2 + } +gcry_random_level_t; + + + +void gcry_randomize (void *buffer, size_t length, + enum gcry_random_level level); + + + + +gcry_error_t gcry_random_add_bytes (const void *buffer, size_t length, + int quality); +# 1725 "/usr/include/gcrypt.h" 3 4 +void *gcry_random_bytes (size_t nbytes, enum gcry_random_level level) + __attribute__ ((__malloc__)); + + + + +void *gcry_random_bytes_secure (size_t nbytes, enum gcry_random_level level) + __attribute__ ((__malloc__)); + + + + + +void gcry_mpi_randomize (gcry_mpi_t w, + unsigned int nbits, enum gcry_random_level level); + + + +void gcry_create_nonce (void *buffer, size_t length); +# 1762 "/usr/include/gcrypt.h" 3 4 +typedef int (*gcry_prime_check_func_t) (void *arg, int mode, + gcry_mpi_t candidate); +# 1780 "/usr/include/gcrypt.h" 3 4 +gcry_error_t gcry_prime_generate (gcry_mpi_t *prime, + unsigned int prime_bits, + unsigned int factor_bits, + gcry_mpi_t **factors, + gcry_prime_check_func_t cb_func, + void *cb_arg, + gcry_random_level_t random_level, + unsigned int flags); + + + + + +gcry_error_t gcry_prime_group_generator (gcry_mpi_t *r_g, + gcry_mpi_t prime, + gcry_mpi_t *factors, + gcry_mpi_t start_g); + + + +void gcry_prime_release_factors (gcry_mpi_t *factors); + + + +gcry_error_t gcry_prime_check (gcry_mpi_t x, unsigned int flags); +# 1815 "/usr/include/gcrypt.h" 3 4 +enum gcry_log_levels + { + GCRY_LOG_CONT = 0, + GCRY_LOG_INFO = 10, + GCRY_LOG_WARN = 20, + GCRY_LOG_ERROR = 30, + GCRY_LOG_FATAL = 40, + GCRY_LOG_BUG = 50, + GCRY_LOG_DEBUG = 100 + }; + + +typedef void (*gcry_handler_progress_t) (void *, const char *, int, int, int); + + +typedef void *(*gcry_handler_alloc_t) (size_t n); + + +typedef int (*gcry_handler_secure_check_t) (const void *); + + +typedef void *(*gcry_handler_realloc_t) (void *p, size_t n); + + +typedef void (*gcry_handler_free_t) (void *); + + +typedef int (*gcry_handler_no_mem_t) (void *, size_t, unsigned int); + + +typedef void (*gcry_handler_error_t) (void *, int, const char *); + + +typedef void (*gcry_handler_log_t) (void *, int, const char *, va_list); + + + +void gcry_set_progress_handler (gcry_handler_progress_t cb, void *cb_data); + + + +void gcry_set_allocation_handler ( + gcry_handler_alloc_t func_alloc, + gcry_handler_alloc_t func_alloc_secure, + gcry_handler_secure_check_t func_secure_check, + gcry_handler_realloc_t func_realloc, + gcry_handler_free_t func_free); + + + +void gcry_set_outofcore_handler (gcry_handler_no_mem_t h, void *opaque); + + + +void gcry_set_fatalerror_handler (gcry_handler_error_t fnc, void *opaque); + + + +void gcry_set_log_handler (gcry_handler_log_t f, void *opaque); + + +void gcry_set_gettext_handler (const char *(*f)(const char*)); + + + +void *gcry_malloc (size_t n) __attribute__ ((__malloc__)); +void *gcry_calloc (size_t n, size_t m) __attribute__ ((__malloc__)); +void *gcry_malloc_secure (size_t n) __attribute__ ((__malloc__)); +void *gcry_calloc_secure (size_t n, size_t m) __attribute__ ((__malloc__)); +void *gcry_realloc (void *a, size_t n); +char *gcry_strdup (const char *string) __attribute__ ((__malloc__)); +void *gcry_xmalloc (size_t n) __attribute__ ((__malloc__)); +void *gcry_xcalloc (size_t n, size_t m) __attribute__ ((__malloc__)); +void *gcry_xmalloc_secure (size_t n) __attribute__ ((__malloc__)); +void *gcry_xcalloc_secure (size_t n, size_t m) __attribute__ ((__malloc__)); +void *gcry_xrealloc (void *a, size_t n); +char *gcry_xstrdup (const char * a) __attribute__ ((__malloc__)); +void gcry_free (void *a); + + +int gcry_is_secure (const void *a) __attribute__ ((__pure__)); + + + + + + +# 1 "/usr/include/gcrypt-module.h" 1 3 4 +# 43 "/usr/include/gcrypt-module.h" 3 4 +typedef struct gcry_module *gcry_module_t; + + + + +typedef gcry_err_code_t (*gcry_cipher_setkey_t) (void *c, + const unsigned char *key, + unsigned keylen); + + +typedef void (*gcry_cipher_encrypt_t) (void *c, + unsigned char *outbuf, + const unsigned char *inbuf); + + +typedef void (*gcry_cipher_decrypt_t) (void *c, + unsigned char *outbuf, + const unsigned char *inbuf); + + +typedef void (*gcry_cipher_stencrypt_t) (void *c, + unsigned char *outbuf, + const unsigned char *inbuf, + unsigned int n); + + +typedef void (*gcry_cipher_stdecrypt_t) (void *c, + unsigned char *outbuf, + const unsigned char *inbuf, + unsigned int n); + +typedef struct gcry_cipher_oid_spec +{ + const char *oid; + int mode; +} gcry_cipher_oid_spec_t; + + +typedef struct gcry_cipher_spec +{ + const char *name; + const char **aliases; + gcry_cipher_oid_spec_t *oids; + size_t blocksize; + size_t keylen; + size_t contextsize; + gcry_cipher_setkey_t setkey; + gcry_cipher_encrypt_t encrypt; + gcry_cipher_decrypt_t decrypt; + gcry_cipher_stencrypt_t stencrypt; + gcry_cipher_stdecrypt_t stdecrypt; +} gcry_cipher_spec_t; + + + + +gcry_error_t gcry_cipher_register (gcry_cipher_spec_t *cipher, + int *algorithm_id, + gcry_module_t *module) + __attribute__ ((__deprecated__)); + + + + +void gcry_cipher_unregister (gcry_module_t module) + __attribute__ ((__deprecated__)); + + + + +typedef gcry_err_code_t (*gcry_pk_generate_t) (int algo, + unsigned int nbits, + unsigned long use_e, + gcry_mpi_t *skey, + gcry_mpi_t **retfactors); + + +typedef gcry_err_code_t (*gcry_pk_check_secret_key_t) (int algo, + gcry_mpi_t *skey); + + +typedef gcry_err_code_t (*gcry_pk_encrypt_t) (int algo, + gcry_mpi_t *resarr, + gcry_mpi_t data, + gcry_mpi_t *pkey, + int flags); + + +typedef gcry_err_code_t (*gcry_pk_decrypt_t) (int algo, + gcry_mpi_t *result, + gcry_mpi_t *data, + gcry_mpi_t *skey, + int flags); + + +typedef gcry_err_code_t (*gcry_pk_sign_t) (int algo, + gcry_mpi_t *resarr, + gcry_mpi_t data, + gcry_mpi_t *skey); + + +typedef gcry_err_code_t (*gcry_pk_verify_t) (int algo, + gcry_mpi_t hash, + gcry_mpi_t *data, + gcry_mpi_t *pkey, + int (*cmp) (void *, gcry_mpi_t), + void *opaquev); + + +typedef unsigned (*gcry_pk_get_nbits_t) (int algo, gcry_mpi_t *pkey); + + +typedef struct gcry_pk_spec +{ + const char *name; + const char **aliases; + const char *elements_pkey; + const char *elements_skey; + const char *elements_enc; + const char *elements_sig; + const char *elements_grip; + int use; + gcry_pk_generate_t generate; + gcry_pk_check_secret_key_t check_secret_key; + gcry_pk_encrypt_t encrypt; + gcry_pk_decrypt_t decrypt; + gcry_pk_sign_t sign; + gcry_pk_verify_t verify; + gcry_pk_get_nbits_t get_nbits; +} gcry_pk_spec_t; + + + + +gcry_error_t gcry_pk_register (gcry_pk_spec_t *pubkey, + unsigned int *algorithm_id, + gcry_module_t *module) + __attribute__ ((__deprecated__)); + + + +void gcry_pk_unregister (gcry_module_t module) + __attribute__ ((__deprecated__)); + + + + +typedef void (*gcry_md_init_t) (void *c); + + +typedef void (*gcry_md_write_t) (void *c, const void *buf, size_t nbytes); + + +typedef void (*gcry_md_final_t) (void *c); + + +typedef unsigned char *(*gcry_md_read_t) (void *c); + +typedef struct gcry_md_oid_spec +{ + const char *oidstring; +} gcry_md_oid_spec_t; + + +typedef struct gcry_md_spec +{ + const char *name; + unsigned char *asnoid; + int asnlen; + gcry_md_oid_spec_t *oids; + int mdlen; + gcry_md_init_t init; + gcry_md_write_t write; + gcry_md_final_t final; + gcry_md_read_t read; + size_t contextsize; +} gcry_md_spec_t; + + + + +gcry_error_t gcry_md_register (gcry_md_spec_t *digest, + unsigned int *algorithm_id, + gcry_module_t *module) + __attribute__ ((__deprecated__)); + + + +void gcry_md_unregister (gcry_module_t module) + __attribute__ ((__deprecated__)); +# 1903 "/usr/include/gcrypt.h" 2 3 4 +# 8 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" 2 + +typedef long long widest_t; + + + + + + + +typedef struct ProtocolDesc ProtocolDesc; +typedef struct OblivInputs OblivInputs; +typedef struct OblivBit OblivBit; +# 28 "/home/student/obliv-c/src/ext/oblivc/obliv_types.h" +typedef char yao_key_t[((81 +7)/8)]; + +struct ProtocolDesc { + int partyCount, thisParty; + struct ProtocolTransport* trans; + union + { + struct { unsigned mulCount,xorCount; } debug; + }; + + void (*feedOblivInputs)(ProtocolDesc*,OblivInputs*,size_t,int); + + _Bool (*revealOblivBits)(ProtocolDesc*,widest_t*,const OblivBit*,size_t,int); + + void (*setBitAnd)(ProtocolDesc*,OblivBit*,const OblivBit*,const OblivBit*); + void (*setBitOr )(ProtocolDesc*,OblivBit*,const OblivBit*,const OblivBit*); + void (*setBitXor)(ProtocolDesc*,OblivBit*,const OblivBit*,const OblivBit*); + void (*setBitNot)(ProtocolDesc*,OblivBit*,const OblivBit*); + void (*flipBit )(ProtocolDesc*,OblivBit*); + + void* extra; +}; + + +typedef struct { + void* sender; + void (*send)(void*,const char*,const char*,int n,int len); + void (*release)(void*); +} OTsender; + +typedef struct { + void* recver; + void (*recv)(void*,char*,const _Bool*,int n,int len); + void (*release)(void*); +} OTrecver; + +typedef struct YaoProtocolDesc { + yao_key_t R,I; + uint64_t gcount; + unsigned icount, ocount; + void (*nonFreeGate)(struct ProtocolDesc*,OblivBit*,char, + const OblivBit*,const OblivBit*); + union { OTsender sender; OTrecver recver; }; +} YaoProtocolDesc; + +typedef struct ProtocolTransport ProtocolTransport; + + + +struct ProtocolTransport { + int maxParties, maxChannels, curChannel; + ProtocolTransport* (*subtransport)(ProtocolTransport*,int); + int (*send)(ProtocolTransport*,int,const void*,size_t); + int (*recv)(ProtocolTransport*,int, void*,size_t); + void (*cleanup)(ProtocolTransport*); +}; + +struct OblivInputs { + unsigned long long src; + struct OblivBit* dest; + size_t size; +}; + + +typedef void (*protocol_run)(void*); +# 11 "/home/student/obliv-c/src/ext/oblivc/obliv_bits.h" 2 + +typedef struct OblivBit { + _Bool unknown; + + + union { + + _Bool knownValue; + struct { + + + + yao_key_t w; + _Bool inverted; + } yao; + }; +} OblivBit; + + + + + +typedef struct { OblivBit bits[1]; } __obliv_c__bool; +typedef struct { OblivBit bits[(8*sizeof(char))]; } __obliv_c__char; +typedef struct { OblivBit bits[(8*sizeof(int))]; } __obliv_c__int; +typedef struct { OblivBit bits[(8*sizeof(short))]; } __obliv_c__short; +typedef struct { OblivBit bits[(8*sizeof(long))]; } __obliv_c__long; +typedef struct { OblivBit bits[(8*sizeof(long long))]; } __obliv_c__lLong; + +static const __obliv_c__bool __obliv_c__trueCond = {{{0,{1}}}}; + + + +void __obliv_c__assignBitKnown(OblivBit* dest, _Bool value); +void __obliv_c__copyBit(OblivBit* dest, const OblivBit* src); +_Bool __obliv_c__bitIsKnown(_Bool* val,const OblivBit* bit); + + +void __obliv_c__setBitAnd(OblivBit* dest,const OblivBit* a,const OblivBit* b); +void __obliv_c__setBitOr(OblivBit* dest,const OblivBit* a,const OblivBit* b); +void __obliv_c__setBitXor(OblivBit* dest,const OblivBit* a,const OblivBit* b); +void __obliv_c__setBitNot(OblivBit* dest,const OblivBit* a); +void __obliv_c__flipBit(OblivBit* dest); + + + + +int ocCurrentParty(); + + + + +void __obliv_c__setSignedKnown + (void * dest, size_t size,signed long long value); +void __obliv_c__setUnsignedKnown + (void * dest, size_t size,unsigned long long value); +void __obliv_c__setBitsKnown(OblivBit* dest, const _Bool* value, size_t size); +void __obliv_c__copyBits(OblivBit* dest, const OblivBit* src, size_t size); + +_Bool __obliv_c__allBitsKnown(const OblivBit* bits, _Bool* dest, size_t size); + +void __obliv_c__setBitwiseAnd (void* dest + ,const void* op1,const void* op2 + ,size_t size); +void __obliv_c__setBitwiseOr (void* dest + ,const void* op1,const void* op2 + ,size_t size); +void __obliv_c__setBitwiseXor (void* dest + ,const void* op1,const void* op2 + ,size_t size); +void __obliv_c__setBitwiseNot (void* dest,const void* op,size_t size); +void __obliv_c__setBitwiseNotInPlace (void* dest,size_t size); +void __obliv_c__setLShift (void* vdest, const void* vsrc, size_t size, + unsigned shiftAmt); +void __obliv_c__setRShiftSigned (void* vdest, const void* vsrc, size_t size, + unsigned shiftAmt); +void __obliv_c__setRShiftUnsigned (void* vdest, const void* vsrc, size_t size, + unsigned shiftAmt); +void __obliv_c__setRShift (void* vdest, const void* vsrc, size_t size, + unsigned shiftAmt,_Bool isSigned); + + + + + + +void __obliv_c__setPlainAdd (void* vdest + ,const void* vop1 ,const void* vop2 + ,size_t size); +void __obliv_c__setPlainSub (void* vdest + ,const void* vop1 ,const void* vop2 + ,size_t size); +void __obliv_c__setBitsAdd (void* dest,void* carryOut + ,const void* op1,const void* op2 + ,const void* carryIn + ,size_t size); +void __obliv_c__setNeg (void* vdest, const void* vsrc, size_t n); +void __obliv_c__condNeg (const void* vcond, void* vdest + ,const void* vsrc, size_t n); + + +void __obliv_c__setMul (void* vdest + ,const void* vop1 ,const void* vop2 + ,size_t size); +void __obliv_c__setDivModUnsigned (void* vquot, void* vrem + ,const void* vop1, const void* vop2 + ,size_t size); +void __obliv_c__setDivModSigned (void* vquot, void* vrem + ,const void* vop1, const void* vop2 + ,size_t size); +void __obliv_c__setDivUnsigned (void* vdest + ,const void* vop1 ,const void* vop2 + ,size_t size); +void __obliv_c__setModUnsigned (void* vdest + ,const void* vop1 ,const void* vop2 + ,size_t size); +void __obliv_c__setDivSigned (void* vdest + ,const void* vop1 ,const void* vop2 + ,size_t size); +void __obliv_c__setModSigned (void* vdest + ,const void* vop1 ,const void* vop2 + ,size_t size); + +void __obliv_c__setBitsSub (void* dest,void* borrowOut + ,const void* op1,const void* op2 + ,const void* borrowIn,size_t size); +void __obliv_c__setSignExtend (void* dest, size_t dsize + ,const void* src, size_t ssize); +void __obliv_c__setZeroExtend (void* dest, size_t dsize + ,const void* src, size_t ssize); +void __obliv_c__ifThenElse (void* dest, const void* tsrc + ,const void* fsrc, size_t size + ,const void* cond); +void __obliv_c__setLessThanUnit (OblivBit* ltOut + ,const OblivBit* op1, const OblivBit* op2 + ,size_t size, const OblivBit* ltIn); +void __obliv_c__setLessThanUnsigned (void* dest + ,const void* op1,const void* op2 + ,size_t size); +void __obliv_c__setLessOrEqualUnsigned (void* dest + ,const void* op1,const void* op2 + ,size_t size); +void __obliv_c__setLessThanSigned (void* dest + ,const void* op1,const void* op2 + ,size_t size); +void __obliv_c__setLessOrEqualSigned (void* dest + ,const void* op1,const void* op2 + ,size_t size); +void __obliv_c__setEqualTo (void* dest + ,const void* op1,const void* op2 + ,size_t size); +void __obliv_c__setNotEqual (void* dest + ,const void* op1,const void* op2 + ,size_t size); +void __obliv_c__setLogicalNot (void* dest,const void* op,size_t size); + +void __obliv_c__condAssign (const void* cond, void* dest, const void* src, + size_t size); + +static inline +void __obliv_c__condAssignKnown(const void* cond, void* dest, size_t size + ,widest_t val) +{ + OblivBit ov[(8*sizeof(widest_t))]; + __obliv_c__setSignedKnown(ov,size,val); + __obliv_c__ifThenElse(dest,ov,dest,size,cond); +} + +void __obliv_c__condAdd(const void* c,void* dest + ,const void* x,size_t size); + +void __obliv_c__condSub(const void* c,void* dest + ,const void* x,size_t size); +# 2 "/tmp/tmp.KtcPgJYzOx.c" 2 +# 1 "mutual.oc" +# 1 "/usr/include/stdio.h" 1 3 4 +# 30 "/usr/include/stdio.h" 3 4 + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" 1 3 4 +# 35 "/usr/include/stdio.h" 2 3 4 +# 45 "/usr/include/stdio.h" 3 4 +struct _IO_FILE; + + + +typedef struct _IO_FILE FILE; + + + + + +# 65 "/usr/include/stdio.h" 3 4 +typedef struct _IO_FILE __FILE; +# 75 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/libio.h" 1 3 4 +# 32 "/usr/include/libio.h" 3 4 +# 1 "/usr/include/_G_config.h" 1 3 4 +# 15 "/usr/include/_G_config.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.6/include/stddef.h" 1 3 4 +# 16 "/usr/include/_G_config.h" 2 3 4 + + + + +# 1 "/usr/include/wchar.h" 1 3 4 +# 83 "/usr/include/wchar.h" 3 4 +typedef struct +{ + int __count; + union + { + + unsigned int __wch; + + + + char __wchb[4]; + } __value; +} __mbstate_t; +# 21 "/usr/include/_G_config.h" 2 3 4 + +typedef struct +{ + __off_t __pos; + __mbstate_t __state; +} _G_fpos_t; +typedef struct +{ + __off64_t __pos; + __mbstate_t __state; +} _G_fpos64_t; +# 53 "/usr/include/_G_config.h" 3 4 +typedef int _G_int16_t __attribute__ ((__mode__ (__HI__))); +typedef int _G_int32_t __attribute__ ((__mode__ (__SI__))); +typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__))); +typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__))); +# 33 "/usr/include/libio.h" 2 3 4 +# 172 "/usr/include/libio.h" 3 4 +struct _IO_jump_t; struct _IO_FILE; +# 182 "/usr/include/libio.h" 3 4 +typedef void _IO_lock_t; + + + + + +struct _IO_marker { + struct _IO_marker *_next; + struct _IO_FILE *_sbuf; + + + + int _pos; +# 205 "/usr/include/libio.h" 3 4 +}; + + +enum __codecvt_result +{ + __codecvt_ok, + __codecvt_partial, + __codecvt_error, + __codecvt_noconv +}; +# 273 "/usr/include/libio.h" 3 4 +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; +# 321 "/usr/include/libio.h" 3 4 + __off64_t _offset; +# 330 "/usr/include/libio.h" 3 4 + void *__pad1; + void *__pad2; + void *__pad3; + void *__pad4; + size_t __pad5; + + int _mode; + + char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)]; + +}; + + +typedef struct _IO_FILE _IO_FILE; + + +struct _IO_FILE_plus; + +extern struct _IO_FILE_plus _IO_2_1_stdin_; +extern struct _IO_FILE_plus _IO_2_1_stdout_; +extern struct _IO_FILE_plus _IO_2_1_stderr_; +# 366 "/usr/include/libio.h" 3 4 +typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes); + + + + + + + +typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf, + size_t __n); + + + + + + + +typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w); + + +typedef int __io_close_fn (void *__cookie); +# 418 "/usr/include/libio.h" 3 4 +extern int __underflow (_IO_FILE *); +extern int __uflow (_IO_FILE *); +extern int __overflow (_IO_FILE *, int); +# 462 "/usr/include/libio.h" 3 4 +extern int _IO_getc (_IO_FILE *__fp); +extern int _IO_putc (int __c, _IO_FILE *__fp); +extern int _IO_feof (_IO_FILE *__fp) __attribute__ ((__nothrow__ , __leaf__)); +extern int _IO_ferror (_IO_FILE *__fp) __attribute__ ((__nothrow__ , __leaf__)); + +extern int _IO_peekc_locked (_IO_FILE *__fp); + + + + + +extern void _IO_flockfile (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__)); +extern void _IO_funlockfile (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__)); +extern int _IO_ftrylockfile (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__)); +# 492 "/usr/include/libio.h" 3 4 +extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict, + __gnuc_va_list, int *__restrict); +extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict, + __gnuc_va_list); +extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t); +extern size_t _IO_sgetn (_IO_FILE *, void *, size_t); + +extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int); +extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int); + +extern void _IO_free_backup_area (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__)); +# 76 "/usr/include/stdio.h" 2 3 4 +# 109 "/usr/include/stdio.h" 3 4 + + +typedef _G_fpos_t fpos_t; + + + + +# 165 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4 +# 166 "/usr/include/stdio.h" 2 3 4 + + + +extern struct _IO_FILE *stdin; +extern struct _IO_FILE *stdout; +extern struct _IO_FILE *stderr; + + + + + + + +extern int remove (__const char *__filename) __attribute__ ((__nothrow__ , __leaf__)); + +extern int rename (__const char *__old, __const char *__new) __attribute__ ((__nothrow__ , __leaf__)); + + + + +extern int renameat (int __oldfd, __const char *__old, int __newfd, + __const char *__new) __attribute__ ((__nothrow__ , __leaf__)); + + + + + + + + +extern FILE *tmpfile (void) ; +# 210 "/usr/include/stdio.h" 3 4 +extern char *tmpnam (char *__s) __attribute__ ((__nothrow__ , __leaf__)) ; + + + + + +extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__ , __leaf__)) ; +# 228 "/usr/include/stdio.h" 3 4 +extern char *tempnam (__const char *__dir, __const char *__pfx) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) ; + + + + + + + + +extern int fclose (FILE *__stream); + + + + +extern int fflush (FILE *__stream); + +# 253 "/usr/include/stdio.h" 3 4 +extern int fflush_unlocked (FILE *__stream); +# 267 "/usr/include/stdio.h" 3 4 + + + + + + +extern FILE *fopen (__const char *__restrict __filename, + __const char *__restrict __modes) ; + + + + +extern FILE *freopen (__const char *__restrict __filename, + __const char *__restrict __modes, + FILE *__restrict __stream) ; +# 296 "/usr/include/stdio.h" 3 4 + +# 307 "/usr/include/stdio.h" 3 4 +extern FILE *fdopen (int __fd, __const char *__modes) __attribute__ ((__nothrow__ , __leaf__)) ; +# 320 "/usr/include/stdio.h" 3 4 +extern FILE *fmemopen (void *__s, size_t __len, __const char *__modes) + __attribute__ ((__nothrow__ , __leaf__)) ; + + + + +extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__ , __leaf__)) ; + + + + + + +extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__)); + + + +extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, + int __modes, size_t __n) __attribute__ ((__nothrow__ , __leaf__)); + + + + + +extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, + size_t __size) __attribute__ ((__nothrow__ , __leaf__)); + + +extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)); + + + + + + + + +extern int fprintf (FILE *__restrict __stream, + __const char *__restrict __format, ...); + + + + +extern int printf (__const char *__restrict __format, ...); + +extern int sprintf (char *__restrict __s, + __const char *__restrict __format, ...) __attribute__ ((__nothrow__)); + + + + + +extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format, + __gnuc_va_list __arg); + + + + +extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg); + +extern int vsprintf (char *__restrict __s, __const char *__restrict __format, + __gnuc_va_list __arg) __attribute__ ((__nothrow__)); + + + + + +extern int snprintf (char *__restrict __s, size_t __maxlen, + __const char *__restrict __format, ...) + __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4))); + +extern int vsnprintf (char *__restrict __s, size_t __maxlen, + __const char *__restrict __format, __gnuc_va_list __arg) + __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0))); + +# 418 "/usr/include/stdio.h" 3 4 +extern int vdprintf (int __fd, __const char *__restrict __fmt, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__printf__, 2, 0))); +extern int dprintf (int __fd, __const char *__restrict __fmt, ...) + __attribute__ ((__format__ (__printf__, 2, 3))); + + + + + + + + +extern int fscanf (FILE *__restrict __stream, + __const char *__restrict __format, ...) ; + + + + +extern int scanf (__const char *__restrict __format, ...) ; + +extern int sscanf (__const char *__restrict __s, + __const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__)); +# 449 "/usr/include/stdio.h" 3 4 +extern int fscanf (FILE *__restrict __stream, __const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf") + + ; +extern int scanf (__const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf") + ; +extern int sscanf (__const char *__restrict __s, __const char *__restrict __format, ...) __asm__ ("" "__isoc99_sscanf") __attribute__ ((__nothrow__ , __leaf__)) + + ; +# 469 "/usr/include/stdio.h" 3 4 + + + + + + + + +extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 2, 0))) ; + + + + + +extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 1, 0))) ; + + +extern int vsscanf (__const char *__restrict __s, + __const char *__restrict __format, __gnuc_va_list __arg) + __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0))); +# 500 "/usr/include/stdio.h" 3 4 +extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))) ; +extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf") + + __attribute__ ((__format__ (__scanf__, 1, 0))) ; +extern int vsscanf (__const char *__restrict __s, __const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vsscanf") __attribute__ ((__nothrow__ , __leaf__)) + + + + __attribute__ ((__format__ (__scanf__, 2, 0))); +# 528 "/usr/include/stdio.h" 3 4 + + + + + + + + + +extern int fgetc (FILE *__stream); +extern int getc (FILE *__stream); + + + + + +extern int getchar (void); + +# 556 "/usr/include/stdio.h" 3 4 +extern int getc_unlocked (FILE *__stream); +extern int getchar_unlocked (void); +# 567 "/usr/include/stdio.h" 3 4 +extern int fgetc_unlocked (FILE *__stream); + + + + + + + + + + + +extern int fputc (int __c, FILE *__stream); +extern int putc (int __c, FILE *__stream); + + + + + +extern int putchar (int __c); + +# 600 "/usr/include/stdio.h" 3 4 +extern int fputc_unlocked (int __c, FILE *__stream); + + + + + + + +extern int putc_unlocked (int __c, FILE *__stream); +extern int putchar_unlocked (int __c); + + + + + + +extern int getw (FILE *__stream); + + +extern int putw (int __w, FILE *__stream); + + + + + + + + +extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream) + ; + + + + + + +extern char *gets (char *__s) ; + +# 662 "/usr/include/stdio.h" 3 4 +extern __ssize_t __getdelim (char **__restrict __lineptr, + size_t *__restrict __n, int __delimiter, + FILE *__restrict __stream) ; +extern __ssize_t getdelim (char **__restrict __lineptr, + size_t *__restrict __n, int __delimiter, + FILE *__restrict __stream) ; + + + + + + + +extern __ssize_t getline (char **__restrict __lineptr, + size_t *__restrict __n, + FILE *__restrict __stream) ; + + + + + + + + +extern int fputs (__const char *__restrict __s, FILE *__restrict __stream); + + + + + +extern int puts (__const char *__s); + + + + + + +extern int ungetc (int __c, FILE *__stream); + + + + + + +extern size_t fread (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream) ; + + + + +extern size_t fwrite (__const void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __s); + +# 734 "/usr/include/stdio.h" 3 4 +extern size_t fread_unlocked (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream) ; +extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream); + + + + + + + + +extern int fseek (FILE *__stream, long int __off, int __whence); + + + + +extern long int ftell (FILE *__stream) ; + + + + +extern void rewind (FILE *__stream); + +# 770 "/usr/include/stdio.h" 3 4 +extern int fseeko (FILE *__stream, __off_t __off, int __whence); + + + + +extern __off_t ftello (FILE *__stream) ; +# 789 "/usr/include/stdio.h" 3 4 + + + + + + +extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos); + + + + +extern int fsetpos (FILE *__stream, __const fpos_t *__pos); +# 812 "/usr/include/stdio.h" 3 4 + +# 821 "/usr/include/stdio.h" 3 4 + + +extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)); + +extern int feof (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ; + +extern int ferror (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ; + + + + +extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)); +extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ; +extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ; + + + + + + + + +extern void perror (__const char *__s); + + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 1 3 4 +# 27 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 3 4 +extern int sys_nerr; +extern __const char *__const sys_errlist[]; +# 851 "/usr/include/stdio.h" 2 3 4 + + + + +extern int fileno (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ; + + + + +extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ; +# 870 "/usr/include/stdio.h" 3 4 +extern FILE *popen (__const char *__command, __const char *__modes) ; + + + + + +extern int pclose (FILE *__stream); + + + + + +extern char *ctermid (char *__s) __attribute__ ((__nothrow__ , __leaf__)); +# 910 "/usr/include/stdio.h" 3 4 +extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)); + + + +extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ; + + +extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)); +# 940 "/usr/include/stdio.h" 3 4 + +# 2 "mutual.oc" 2 + +# 1 "/home/student/obliv-c/src/ext/oblivc/obliv.oh" 1 + + + +struct ProtocolDesc* ocCurrentProto(void); +int ocCurrentParty(void); + +void setupOblivBool(OblivInputs* spec, obliv _Bool* dest, _Bool v); +void setupOblivChar(OblivInputs* spec, obliv char* dest, char v); +void setupOblivInt(OblivInputs* spec, obliv int* dest, int v); +void setupOblivShort(OblivInputs* spec, obliv short* dest, short v); +void setupOblivLong(OblivInputs* spec, obliv long* dest, long v); +void setupOblivLLong(OblivInputs* spec, obliv long long * dest, long long v); + +void feedOblivInputs(OblivInputs* spec, size_t count, int party); + + +obliv _Bool feedOblivBool(_Bool v,int party); +obliv char feedOblivChar(char v,int party); +obliv short feedOblivShort(short v,int party); +obliv int feedOblivInt(int v,int party); +obliv long feedOblivLong(long v,int party); +obliv long long feedOblivLLong(long long v,int party); + + + + +_Bool revealOblivBool(_Bool* dest, obliv _Bool src,int party); +_Bool revealOblivChar(char* dest, obliv char src,int party); +_Bool revealOblivInt(int* dest, obliv int src,int party); +_Bool revealOblivShort(short* dest, obliv short src,int party); +_Bool revealOblivLong(long* dest, obliv long src,int party); +_Bool revealOblivLLong(long long* dest, obliv long long src,int party); + +_Bool ocBroadcastBool(int source,_Bool v); +char ocBroadcastChar(int source,char v); +int ocBroadcastInt(int source,int v); +short ocBroadcastShort(int source,short v); +long ocBroadcastLong(int source,long v); +long long ocBroadcastLLong(int source,long long v); +# 4 "mutual.oc" 2 + +# 1 "./mutual.h" 1 + + + + + + +typedef char* string; +typedef struct protocolIO{ + char mine[45][10]; + int size; + char common[45][10]; + int commonSize; +}protocolIO; + +const char* mySide(); + +void mutualFriends(void* args); +# 6 "mutual.oc" 2 + +typedef obliv _Bool obool; + +obool oblivStrCmp(obliv char* s1, obliv char* s2) obliv{ + + obliv _Bool afternull = 0; + int i; + obool ob = 1; + + for( i = 0; i < 10; i++) { + obliv + if (afternull) { + ; + } else { + obliv char c = s1[i]; + obliv if (c != s2[i]) { + ob = 0; + } else { + obliv if (c == '\0') { + afternull = 1; + } + } + } + } + + + + return ob; +} + +void addString(obliv char* src, obliv char* dest) obliv{ + int i; + for(i=0; i<10; i++) + dest[i]=src[i]; +} + +void readString(obliv char* dest, int n, const char* src,int party) +{ + OblivInputs specs[45]; + int i; + + feedOblivInputs(specs,n,party); +} +void mutualFriends(void* args){ + protocolIO *io = args; + int size1, size2; + int i, j; + obool match[45]; + obliv char friends1[45][10]; + obliv char friends2[45][10]; + obliv char commonFriends[45][10]; + obliv int commonSize; + size1 = ocBroadcastInt(1, io->size); + size2 = ocBroadcastInt(2, io->size); + for(i=0;imine[i][j], 1); + } + } + for(i=0; i<45; i++) + match[i] = 0; + for(i=0; imine[i][j], 2); + + for( i=0; icommonSize, commonSize, 0); + for(i=0; i<45; i++){ + for(j=0; j<10; j++){ + revealOblivChar(&io->common[i][j],commonFriends[i][j],0); + }} +} diff --git a/test/oblivc/mutual/mutualStringTest.c b/test/oblivc/mutual/mutualStringTest.c new file mode 100644 index 000000000..84d487d7a --- /dev/null +++ b/test/oblivc/mutual/mutualStringTest.c @@ -0,0 +1,62 @@ +#include +#include +#include +#include + +void cmp(char* s1, char* s2){ + +} +int main(int argc, char* argv[]){ + char* s1 = "Bob"; + char s2[6] = "Joe"; + char s3[10] = "Ricky"; + char* s4; + char s5[10]; + char ss1[20][20]; + s4 = s3;//valid for pointer = array + //s3 = s2; //illegal because s3 is an array and s2 is a pointer + //s2 = s3; //illegal views s3 as a pointer and s2 as an array + //can use strcpy for these!!! + s3[1] ='!'; + s4 = "Bobby!!!"; + //s4[2] = '!'; //SEG FAULT + s1 = s4; //valid for pointer to pointer + //s2 = s1; //illegal! views s1 as a pointer + //s2 = *s1;//illegal! views s1 as a char + //*s1 = *s2;//creates a segfault + //s5 = s2; //illegal! + strcpy(s5, s2);//valid for array to array IFFFFF Array has enough space + //s4 =s2; + strcpy(s2, s4);//Valid for array to pointer if array has enough space + int i; + for(i=0; s4[i]!='\0'; i++) + s2[i] = s4[i]; //Does the same thing as the cpy + strcpy(ss1[0], s1); + ss1[0][2]='1'; + printf("%s %s %s\n", s1, s2, ss1[0]); + i = 0; + strcpy(s3, "Boby"); + strcpy(ss1[1], s3); + bool b = true; + int c = 17; + char s6[20] = "Bo1by"; + strcpy(ss1[1], s6); + strcpy(ss1[0], s6); + cmp(ss1[0], s3); + int i1 = -1; + int i0 = -1; + for(i=0; i<20; i++){ + if(ss1[0][i]!=ss1[1][i] && i0 == -1 && i1 == -1){ + b = false; + } + if(ss1[0][i]=='\0' && i0 == -1) + i0 = i; + if(ss1[1][i]=='\0' && i1 == -1) + i1 = i; + } + if(i1!=i0) + b = false; + printf("%d %d %d\n", i,c, b); + printf("%s %s \n", ss1[0], ss1[1]); + return 0; +} From 3be25a4e1b405bd309698f06ef28163d27e20643 Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Thu, 12 Jun 2014 13:36:05 -0400 Subject: [PATCH 17/29] Works sort method works --- test/oblivc/mutual/mutual.oc | 204 +++++++++++++++++++++++------------ 1 file changed, 133 insertions(+), 71 deletions(-) diff --git a/test/oblivc/mutual/mutual.oc b/test/oblivc/mutual/mutual.oc index 49d42d9ab..e4ffcdb29 100644 --- a/test/oblivc/mutual/mutual.oc +++ b/test/oblivc/mutual/mutual.oc @@ -6,37 +6,63 @@ typedef obliv bool obool; -obool oblivStrCmp(obliv char* s1, obliv char* s2) obliv{ - //return true; - obliv bool afternull = false; - int i; - obool ob = true; - //return ob; - for( i = 0; i < MAXL; i++) { - obliv - if (afternull) { - ; - } else { - obliv char c = s1[i]; - obliv if (c != s2[i]) { - ob = false; - } else { - obliv if (c == '\0') { - afternull = true; - } - } - } +typedef obliv int oint; + +int greatestPowerOfTwoLessThan(int n){ + int k = 1; + while(k < n) + k=k*2; + return k / 2; +} + +void swap(obliv char* list, int a, int b){} + +oint oblivStrCmp(obliv char* s1, obliv char* s2) obliv{ + //return true; + obliv bool afternull = false; + int i; + oint ob = 0; + //return ob; + for( i = 0; i < MAXL; i++) { + obliv if (afternull) { + ; + } else { + obliv char c = s1[i]; + obliv if (c != s2[i]) { + obliv if(c < s2[i]) + ob = -1; + else + ob = 1; + } else { + obliv if (c == '\0') { + afternull = true; + } } + } + } - //return ob; - //ob = true; - return ob; + //return ob; + //ob = true; + return ob; } +/* oint oblivStrCmp2(obliv char * s1, obliv char * s2) obliv{ */ +/* int i; */ +/* for(i = 0; i < MAXL; i++){ */ +/* obliv if(*s1 == *s2){ */ +/* obliv if(*s1==0) */ +/* //return 0; */ +/* // s1++; */ +/* //s2++; */ +/* } */ +/* } */ +/* return *(unsigned char *) s1 - *(unsigned char *) s2; */ +/* } */ + void addString(obliv char* src, obliv char* dest) obliv{ - int i; - for(i=0; isize); - size2 = ocBroadcastInt(2, io->size); - for(i=0;imine[i][j], 1); - } - } - for(i=0; imine[i][j], 2); + protocolIO *io = args; + int size1, size2; + int i, j; + obliv char friends1[MAXN][MAXL]; + obliv char friends2[MAXN][MAXL]; + obliv char commonFriends[MAXN][MAXL]; + obliv int commonSize; + size1 = ocBroadcastInt(1, io->size); + size2 = ocBroadcastInt(2, io->size); + for(i=0;imine[i][j], 1); + + for(i=0; imine[i][j], 2); - for( i=0; icommonSize, commonSize, 0); + for(i=0; icommon[i][j],commonFriends[i][j],0); + } - for(i=0; icommonSize, commonSize, 0); - for(i=0; icommon[i][j],commonFriends[i][j],0); - }} -} +void sortMutual(void* args){ + protocolIO *io = args; + int size1, size2; + int i, j; + size1 = ocBroadcastInt(1, io->size); + size2 = ocBroadcastInt(2, io->size); + obliv char friends[2 * MAXN][MAXL]; + obliv char commonFriends[2 * MAXN][MAXL]; + obliv int commonSize; + for(i=0;imine[i][j], 1); + } + } + int k = size2 + size1 - 1; + for(i=0; i < size2; i++) + for(j=0; jmine[i][j], 2); + int totalSize = size1 + size2; + int k = greatestPowerOfTwoLessThan(totalSize); + //bitonicSort(friends, totalSize, k); + while(k>0){ + for(i=0; i= totalSize) + break; + obliv if(oblivStrCmp(friends[i], friends[i+k])==1){ + //obliv if(true){ + obliv char temp[MAXL]; + addString(friends[i], temp); + addString(friends[i+k], friends[i]); + addString(temp, friends[i+k]); + } + } + k = greatestPowerOfTwoLessThan(k); + } + /* for( i=0; icommonSize, commonSize, 0); + for(i=0; icommon[i][j],commonFriends[i][j],0); +} From e04b8699e6822cef794a2b4d2081f77a904ae477 Mon Sep 17 00:00:00 2001 From: Michael Mahoney Date: Thu, 12 Jun 2014 13:44:14 -0400 Subject: [PATCH 18/29] Merge sort method --- test/oblivc/MergeSort.c | 94 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+) create mode 100644 test/oblivc/MergeSort.c diff --git a/test/oblivc/MergeSort.c b/test/oblivc/MergeSort.c new file mode 100644 index 000000000..570327b4a --- /dev/null +++ b/test/oblivc/MergeSort.c @@ -0,0 +1,94 @@ +/* C program for merge sort */ +#include +#include +#include + +/* Function to merge the two haves arr[l..m] and arr[m+1..r] of array arr[] */ +void merge(char arr[45][100], int l, int m, int r) +{ + int i, j, k; + int n1 = m - l + 1; + int n2 = r - m; + + /* create temp arrays */ + char L[n1][100], R[n2][100]; + + /* Copy data to temp arrays L[] and R[] */ + for(i = 0; i < n1; i++) + strcpy(L[i], arr[l+i]); + for(j = 0; j < n2; j++) + strcpy(R[j], arr[m+1+j]); + + /* Merge the temp arrays back into arr[l..r]*/ + i = 0; + j = 0; + k = l; + while (i < n1 && j < n2) + { + if (strcmp(L[i],R[j]) == -1) + { + strcpy(arr[k], L[i]); + i++; + } + else + { + strcpy(arr[k], R[j]); + j++; + } + k++; + } + + /* Copy the remaining elements of L[], if there are any */ + while (i < n1) + { + strcpy(arr[k], L[i]); + i++; + k++; + } + + /* Copy the remaining elements of R[], if there are any */ + while (j < n2) + { + strcpy(arr[k], R[j]); + j++; + k++; + } +} + +/* l is for left index and r is right index of the sub-array + of arr to be sorted */ +void mergeSort(char arr[45][100], int l, int r) +{ + if (l < r) + { + int m = l+(r-l)/2; //Same as (l+r)/2, but avoids overflow for large l and h + mergeSort(arr, l, m); + mergeSort(arr, m+1, r); + merge(arr, l, m, r); //line 67 + } +} + +/* Driver program to test above functions */ +main() +{ + char arr[2][100]; + strcpy(arr[0], "bbb"); + strcpy(arr[1], "aaa"); +// printf("%s", arr[0]); +// printf("%s", arr[1]); + mergeSort(arr, 0, 1); + printf("%s", arr[0]); + printf("%s", arr[1]); + +// int arr[] = {12, 11, 13, 5, 6, 7}; +// int arr_size = sizeof(arr)/sizeof(arr[0]); + +// printf("Given array is \n"); +// printArray(arr, arr_size); + +// mergeSort(arr, 0, arr_size - 1); + +// printf("\nSorted array is \n"); +// printArray(arr, arr_size); + return 0; +} From 2f668f901ad5b72742e40e9bf0e5e70697cb35dd Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Fri, 13 Jun 2014 11:46:59 -0400 Subject: [PATCH 19/29] Changes to mutual --- test/oblivc/mutual/Makefile | 2 +- test/oblivc/mutual/alice1.txt | 42 ++--------------------------------- test/oblivc/mutual/bob1.txt | 40 ++------------------------------- test/oblivc/mutual/mutual.c | 4 ++-- test/oblivc/mutual/mutual.h | 2 ++ test/oblivc/mutual/mutual.oc | 8 +------ 6 files changed, 10 insertions(+), 88 deletions(-) diff --git a/test/oblivc/mutual/Makefile b/test/oblivc/mutual/Makefile index 62c09f532..4d014ed7c 100644 --- a/test/oblivc/mutual/Makefile +++ b/test/oblivc/mutual/Makefile @@ -2,4 +2,4 @@ all: ~/obliv-c/bin/oblivcc mutual.c mutual.oc -I ./ -lrt test: - ./cycle './a.out 1 alice1.txt | ./a.out 2 bob1.txt' + ~/cmd/cycle './a.out 1 alice1.txt | ./a.out 2 bob1.txt' diff --git a/test/oblivc/mutual/alice1.txt b/test/oblivc/mutual/alice1.txt index 6c3459e74..e3e1304f5 100644 --- a/test/oblivc/mutual/alice1.txt +++ b/test/oblivc/mutual/alice1.txt @@ -1,44 +1,6 @@ -Bob -Stu -Joe -Tom -Greg -Karl -Fred -Eric -Mark -Evan -Michael -L -M -N -O -P +A +G Q -R -S -T -U -V -W X Y Z -AA -BB -CC -DD -EE -FF -GG -HH -II -JJ -KK -LL -MM -NN -OO -PP -QQ -ZZ diff --git a/test/oblivc/mutual/bob1.txt b/test/oblivc/mutual/bob1.txt index e1060a154..1c9971e1c 100644 --- a/test/oblivc/mutual/bob1.txt +++ b/test/oblivc/mutual/bob1.txt @@ -1,41 +1,5 @@ -Alice -Stu -Joe -Jairus -Collis -Mark -Michael A B -C -D -E -F G -H -I -J -K -L -M -N -O -U -V -AA -BB -CC -DD -EE -FF -GG -HH -II -JJ -KK -LL -MM -NN -OO -PP -QQ +Q +Y diff --git a/test/oblivc/mutual/mutual.c b/test/oblivc/mutual/mutual.c index f32337883..3db8d732d 100644 --- a/test/oblivc/mutual/mutual.c +++ b/test/oblivc/mutual/mutual.c @@ -73,8 +73,8 @@ int main(int argc,char *argv[]) setCurrentParty(&pd,currentParty); setCurrentParty(&pd,currentParty); lap = wallClock(); - execYaoProtocol(&pd,mutualFriends,&io); - //execDebugProtocol(&pd,mutualFriends, &io); + //execYaoProtocol(&pd,mutualFriends,&io); + execDebugProtocol(&pd,sortMutual, &io); fprintf(stderr,"%s total time: %lf s\n",mySide(),wallClock()-lap); fprintf(stderr,"Gate Count: %u\n",yaoGateCount()); cleanupProtocol(&pd); diff --git a/test/oblivc/mutual/mutual.h b/test/oblivc/mutual/mutual.h index 2fa9be79e..eabaec948 100644 --- a/test/oblivc/mutual/mutual.h +++ b/test/oblivc/mutual/mutual.h @@ -16,3 +16,5 @@ const char* mySide(); void mutualFriends(void* args); +void sortMutual(void* args); + diff --git a/test/oblivc/mutual/mutual.oc b/test/oblivc/mutual/mutual.oc index e4ffcdb29..ef00b7ee3 100644 --- a/test/oblivc/mutual/mutual.oc +++ b/test/oblivc/mutual/mutual.oc @@ -138,13 +138,7 @@ void sortMutual(void* args){ } k = greatestPowerOfTwoLessThan(k); } - /* for( i=0; i Date: Fri, 13 Jun 2014 11:54:08 -0400 Subject: [PATCH 20/29] Update .gitignore --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index a56a1ab20..2afabf946 100644 --- a/.gitignore +++ b/.gitignore @@ -391,6 +391,9 @@ /test/small2/merge-ar /test/small2/libmerge.a +#mutual +/test/oblivc/mutual/*.oc.* + # /ocamlutil /ocamlutil/perfcount.c From 4ae72d3b217cd242c52e4e60c019cab6fbffc588 Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Mon, 16 Jun 2014 11:19:58 -0400 Subject: [PATCH 21/29] Update .gitignore --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index 2afabf946..fee96b6ea 100644 --- a/.gitignore +++ b/.gitignore @@ -393,6 +393,9 @@ #mutual /test/oblivc/mutual/*.oc.* +/test/oblivc/mutual/*.txt + +*.oc.* # /ocamlutil From 366c3d5257126956d54bfc1ea938ecad9c593bd5 Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Mon, 16 Jun 2014 15:45:51 -0400 Subject: [PATCH 22/29] Delete mutualStringTest.c --- test/oblivc/mutual/mutualStringTest.c | 62 --------------------------- 1 file changed, 62 deletions(-) delete mode 100644 test/oblivc/mutual/mutualStringTest.c diff --git a/test/oblivc/mutual/mutualStringTest.c b/test/oblivc/mutual/mutualStringTest.c deleted file mode 100644 index 84d487d7a..000000000 --- a/test/oblivc/mutual/mutualStringTest.c +++ /dev/null @@ -1,62 +0,0 @@ -#include -#include -#include -#include - -void cmp(char* s1, char* s2){ - -} -int main(int argc, char* argv[]){ - char* s1 = "Bob"; - char s2[6] = "Joe"; - char s3[10] = "Ricky"; - char* s4; - char s5[10]; - char ss1[20][20]; - s4 = s3;//valid for pointer = array - //s3 = s2; //illegal because s3 is an array and s2 is a pointer - //s2 = s3; //illegal views s3 as a pointer and s2 as an array - //can use strcpy for these!!! - s3[1] ='!'; - s4 = "Bobby!!!"; - //s4[2] = '!'; //SEG FAULT - s1 = s4; //valid for pointer to pointer - //s2 = s1; //illegal! views s1 as a pointer - //s2 = *s1;//illegal! views s1 as a char - //*s1 = *s2;//creates a segfault - //s5 = s2; //illegal! - strcpy(s5, s2);//valid for array to array IFFFFF Array has enough space - //s4 =s2; - strcpy(s2, s4);//Valid for array to pointer if array has enough space - int i; - for(i=0; s4[i]!='\0'; i++) - s2[i] = s4[i]; //Does the same thing as the cpy - strcpy(ss1[0], s1); - ss1[0][2]='1'; - printf("%s %s %s\n", s1, s2, ss1[0]); - i = 0; - strcpy(s3, "Boby"); - strcpy(ss1[1], s3); - bool b = true; - int c = 17; - char s6[20] = "Bo1by"; - strcpy(ss1[1], s6); - strcpy(ss1[0], s6); - cmp(ss1[0], s3); - int i1 = -1; - int i0 = -1; - for(i=0; i<20; i++){ - if(ss1[0][i]!=ss1[1][i] && i0 == -1 && i1 == -1){ - b = false; - } - if(ss1[0][i]=='\0' && i0 == -1) - i0 = i; - if(ss1[1][i]=='\0' && i1 == -1) - i1 = i; - } - if(i1!=i0) - b = false; - printf("%d %d %d\n", i,c, b); - printf("%s %s \n", ss1[0], ss1[1]); - return 0; -} From f82642496d7d9f81a66223bd213cec8552268255 Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Tue, 17 Jun 2014 13:14:37 -0400 Subject: [PATCH 23/29] Private Set Intersection example with working Sort-Compare-Shuffle method --- test/oblivc/mutual/mutual.c | 20 ++++++----- test/oblivc/mutual/mutual.oc | 68 +++++++++++++++--------------------- 2 files changed, 40 insertions(+), 48 deletions(-) diff --git a/test/oblivc/mutual/mutual.c b/test/oblivc/mutual/mutual.c index 224b02100..1a6d3e739 100644 --- a/test/oblivc/mutual/mutual.c +++ b/test/oblivc/mutual/mutual.c @@ -30,7 +30,7 @@ void merge(char arr[MAXN][MAXL], int l, int m, int r) k = l; while (i < n1 && j < n2) { - if (strcmp(L[i],R[j]) == -1) + if (strcmp(L[i],R[j]) < 0) { strcpy(arr[k], L[i]); i++; @@ -66,7 +66,7 @@ void mergeSort(char arr[MAXN][MAXL], int l, int r) { if (l < r) { - int m = l+(r-l)/2; //Same as (l+r)/2, but avoids overflow for large l and h + int m = (l+r) / 2; //Same as (l+r)/2, but avoids overflow for large l and h mergeSort(arr, l, m); mergeSort(arr, m+1, r); merge(arr, l, m, r); @@ -113,27 +113,31 @@ int main(int argc,char *argv[]) while(fgets(buf[i], MAXL, infile)!=NULL){ strcpy(io.mine[i], buf[i]); i++; - //buf[i] = malloc(20*sizeof(char)); } io.size = i; + mergeSort(io.mine, 0, io.size-1); + fprintf(stderr,"Result: %d\n", io.size); fclose(infile); + //standard setup protocolUseStdio(&pd); currentParty = (argv[1][0]=='1'?1:2); setCurrentParty(&pd,currentParty); setCurrentParty(&pd,currentParty); lap = wallClock(); - //execYaoProtocol(&pd,mutualFriends,&io); - execDebugProtocol(&pd,sortMutual, &io); - //fprintf(stderr,"%s total time: %lf s\n",mySide(),wallClock()-lap); - //fprintf(stderr,"Gate Count: %u\n",yaoGateCount()); + //execYaoProtocol(&pd,mutualFriends, &io); + //execDebugProtocol(&pd,mutualFriends, &io); + execYaoProtocol(&pd,sortMutual, &io); + //execDebugProtocol(&pd,sortMutual, &io); + fprintf(stderr,"%s total time: %lf s\n",mySide(),wallClock()-lap); + fprintf(stderr,"Gate Count: %u\n",yaoGateCount()); cleanupProtocol(&pd); fprintf(stderr, "Result: %d %c\n", io.commonSize, io.common[0][0]); for(i=0; icommon[i][j],commonFriends[i][j],0); } +//must be given two lists that are sorted void sortMutual(void* args){ protocolIO *io = args; int size1, size2; @@ -111,28 +105,26 @@ void sortMutual(void* args){ obliv char friends[2 * MAXN][MAXL]; obliv char commonFriends[2 * MAXN][MAXL]; obliv int commonSize; - for(i=0;imine[i][j], 1); - } - } - int k = size2 + size1 - 1; for(i=0; i < size2; i++) for(j=0; jmine[i][j], 2); + int totalSize = size1 + size2; int k = greatestPowerOfTwoLessThan(totalSize); - //bitonicSort(friends, totalSize, k); + + //bitonically sorting the list while(k>0){ for(i=0; i= totalSize) break; obliv if(oblivStrCmp(friends[i], friends[i+k])==1){ - //obliv if(true){ - obliv char temp[MAXL]; - addString(friends[i], temp); - addString(friends[i+k], friends[i]); - addString(temp, friends[i+k]); + swap(friends, i, i+k); } } k = greatestPowerOfTwoLessThan(k); @@ -147,15 +139,11 @@ void sortMutual(void* args){ //shuffling srand(time(NULL)); - int r1; - int r2; + int r1, r2; for(i = 0; icommonSize, commonSize, 0); for(i=0; i Date: Tue, 17 Jun 2014 18:04:49 -0400 Subject: [PATCH 24/29] fixed the bitonic sort method --- test/oblivc/mutual/mutual.c | 4 ++-- test/oblivc/mutual/mutual.h | 4 ++-- test/oblivc/mutual/mutual.oc | 28 +++++++++++----------------- 3 files changed, 15 insertions(+), 21 deletions(-) diff --git a/test/oblivc/mutual/mutual.c b/test/oblivc/mutual/mutual.c index 1a6d3e739..7bae85876 100644 --- a/test/oblivc/mutual/mutual.c +++ b/test/oblivc/mutual/mutual.c @@ -130,12 +130,12 @@ int main(int argc,char *argv[]) lap = wallClock(); //execYaoProtocol(&pd,mutualFriends, &io); //execDebugProtocol(&pd,mutualFriends, &io); - execYaoProtocol(&pd,sortMutual, &io); + execYaoProtocol(&pd,sortMutual, &io); //execDebugProtocol(&pd,sortMutual, &io); fprintf(stderr,"%s total time: %lf s\n",mySide(),wallClock()-lap); fprintf(stderr,"Gate Count: %u\n",yaoGateCount()); cleanupProtocol(&pd); - fprintf(stderr, "Result: %d %c\n", io.commonSize, io.common[0][0]); + fprintf(stderr, "Result: %d\n", io.commonSize); for(i=0; i0){ for(i=0; i= totalSize) - break; - obliv if(oblivStrCmp(friends[i], friends[i+k])==1){ + if((i/k)%2 == 1); + else{ + obliv if(oblivStrCmp(friends[i], friends[i+k])>0){ swap(friends, i, i+k); - } + }} } k = greatestPowerOfTwoLessThan(k); } @@ -133,7 +127,7 @@ void sortMutual(void* args){ for(i = 0; i < totalSize-1; i++){ obliv if(oblivStrCmp(friends[i], friends[i + 1])==0){ commonSize++; - addString(friends[i], commonFriends[i]); + addString(friends[i+1], commonFriends[i+1]); } } From cc89bbd42aa01ad5dcb579a3dff7cfbdaacf8310 Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Wed, 18 Jun 2014 11:49:40 -0400 Subject: [PATCH 25/29] More fix to bitonic sort --- test/oblivc/mutual/mutual.oc | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/test/oblivc/mutual/mutual.oc b/test/oblivc/mutual/mutual.oc index 14711e696..8d58d3b94 100644 --- a/test/oblivc/mutual/mutual.oc +++ b/test/oblivc/mutual/mutual.oc @@ -113,17 +113,18 @@ void sortMutual(void* args){ int k = greatestPowerOfTwoLessThan(totalSize); //bitonically sorting the list + int l = 0; while(k>0){ for(i=0; i0){ + obliv if(oblivStrCmp(friends[i], friends[i+k])<0){ swap(friends, i, i+k); }} } k = greatestPowerOfTwoLessThan(k); } - + fprintf(stderr, "%d\n", l); for(i = 0; i < totalSize-1; i++){ obliv if(oblivStrCmp(friends[i], friends[i + 1])==0){ commonSize++; From 9e3ace7661dad17ae36bc8c3141897dbb3a6418a Mon Sep 17 00:00:00 2001 From: Michael Mahoney Date: Thu, 19 Jun 2014 12:08:15 -0400 Subject: [PATCH 26/29] update to mutual files --- test/oblivc/mutualfriends/mutual.c | 146 +++++++++++++++++++++ test/oblivc/mutualfriends/mutual.h | 21 +++ test/oblivc/mutualfriends/mutual.oc | 190 ++++++++++++++++++++++++++++ 3 files changed, 357 insertions(+) create mode 100644 test/oblivc/mutualfriends/mutual.c create mode 100644 test/oblivc/mutualfriends/mutual.h create mode 100644 test/oblivc/mutualfriends/mutual.oc diff --git a/test/oblivc/mutualfriends/mutual.c b/test/oblivc/mutualfriends/mutual.c new file mode 100644 index 000000000..822b4bf36 --- /dev/null +++ b/test/oblivc/mutualfriends/mutual.c @@ -0,0 +1,146 @@ +//mutualfriends file + +#include +#include +#include +#include +#include + +#include "mutual.h" + +int currentParty; + +/* Function to merge the two haves arr[l..m] and arr[m+1..r] of array arr[] */ +void merge(char arr[MAXN][MAXL], int l, int m, int r) +{ + int i, j, k; + int n1 = m - l + 1; + int n2 = r - m; + + /* create temp arrays */ + char L[n1][100], R[n2][100]; + + /* Copy data to temp arrays L[] and R[] */ + for(i = 0; i < n1; i++) + strcpy(L[i], arr[l+i]); + for(j = 0; j < n2; j++) + strcpy(R[j], arr[m+1+j]); + + /* Merge the temp arrays back into arr[l..r]*/ + i = 0; + j = 0; + k = l; + while (i < n1 && j < n2) + { + if (strcmp(L[i],R[j]) < 0) + { + strcpy(arr[k], L[i]); + i++; + } + else + { + strcpy(arr[k], R[j]); + j++; + } + k++; + } + + /* Copy the remaining elements of L[], if there are any */ + while (i < n1) + { + strcpy(arr[k], L[i]); + i++; + k++; + } + + /* Copy the remaining elements of R[], if there are any */ + while (j < n2) + { + strcpy(arr[k], R[j]); + j++; + k++; + } +} + +/* l is for left index and r is right index of the sub-array + of arr to be sorted */ +void mergeSort(char arr[MAXN][MAXL], int l, int r) +{ + if (l < r) + { + int m = l+(r-l)/2; //Same as (l+r)/2, but avoids overflow for large l and h + mergeSort(arr, l, m); + mergeSort(arr, m+1, r); + merge(arr, l, m, r); + } +} + +const char* mySide() +{ + if(currentParty==1) return "Generator"; + else return "Evaluator"; +} + +double wallClock() +{ + struct timespec t; + int i = clock_gettime(CLOCK_REALTIME,&t); + return t.tv_sec+1e-9*t.tv_nsec; +} +double lap; + +int main(int argc,char *argv[]) +{ + //these variables are used everytime + ProtocolDesc pd; + protocolIO io; + + //checking that the input has the correct number of variables + if(argc<3) + { if(argc<2) fprintf(stderr,"Party missing\n"); + else fprintf(stderr,"friends missing\n"); + fprintf(stderr,"Usage: %s <1|2> \n",argv[0]); + return 1; + } + FILE *infile; + infile = fopen(argv[2], "r"); + if(infile==NULL){ + //Error("Unable to open file"); + fprintf(stderr, "ERROR!"); + return 1; + } + //TODO change input file so that it says how many friends there are + int i=0; + char buf[MAXN][MAXL]; + while(fgets(buf[i], MAXL, infile)!=NULL){ + strcpy(io.mine[i], buf[i]); + i++; + //buf[i] = malloc(20*sizeof(char)); + } + io.size = i; + mergeSort(io.mine, 0, io.size-1); + fprintf(stderr,"Result: %d\n", io.size); + + fclose(infile); + //standard setup + protocolUseStdio(&pd); + currentParty = (argv[1][0]=='1'?1:2); + setCurrentParty(&pd,currentParty); + setCurrentParty(&pd,currentParty); + lap = wallClock(); + //execYaoProtocol(&pd,mutualFriends, &io); + //execDebugProtocol(&pd,mutualFriends, &io); + execYaoProtocol(&pd,sortMutual, &io); + //execDebugProtocol(&pd,sortMutual, &io); + fprintf(stderr,"%s total time: %lf s\n",mySide(),wallClock()-lap); + //fprintf(stderr,"Gate Count: %u\n",yaoGateCount()); + cleanupProtocol(&pd); + +// fprintf(stderr, "Result: %d %c\n", io.commonSize, io.common[0][0]); + fprintf(stderr, "Result: %d\n", io.commonSize); + for(i=0; i +#include +#include + +#include "mutual.h" + +typedef obliv bool obool; + +typedef obliv int oint; + +int greatestPowerOfTwoLessThan(int n){ + int k = 1; + while(k < n) + k=k*2; + return k / 2; +} + +oint oblivStrCmp(obliv char* s1, obliv char* s2) obliv { + //return true; + obliv bool afternull = false; + int i; + oint ob = 0; + //return ob; + for( i = 0; i < MAXL; i++) { + obliv if (afternull) { + ; + } else { + obliv char c = s1[i]; + obliv if (c != s2[i]) { + obliv if(c < s2[i]){ + ob = 1; + afternull = true; + } + else{ + ob = -1; + afternull = true; + } + } else { + obliv if (c == '\0') { + afternull = true; + } + } + } + } + + //return ob; + //ob = true; + return ob; +} + +/* oint oblivStrCmp2(obliv char * s1, obliv char * s2) obliv{ */ +/* int i; */ +/* for(i = 0; i < MAXL; i++){ */ +/* obliv if(*s1 == *s2){ */ +/* obliv if(*s1==0) */ +/* //return 0; */ +/* // s1++; */ +/* //s2++; */ +/* } */ +/* } */ +/* return *(unsigned char *) s1 - *(unsigned char *) s2; */ +/* } */ + +void addString(obliv char* src, obliv char* dest) obliv{ + int i; + for(i=0; isize); + size2 = ocBroadcastInt(2, io->size); + for(i=0;imine[i][j], 1); + + for(i=0; imine[i][j], 2); + + for( i=0; icommonSize, commonSize, 0); + for(i=0; icommon[i][j],commonFriends[i][j],0); + } + + +void sortMutual(void* args){ + protocolIO *io = args; + int size1, size2; + int i, j; + size1 = ocBroadcastInt(1, io->size); + size2 = ocBroadcastInt(2, io->size); + obliv char friends[2 * MAXN][MAXL]; + obliv char commonFriends[2 * MAXN][MAXL]; + obliv int commonSize; + + for(i=0;imine[i][j], 1); + } + } +// int k = size2 + size1 - 1; + for(i=0; i < size2; i++) + for(j=0; jmine[i][j], 2); + int totalSize = size1 + size2; + int k = greatestPowerOfTwoLessThan(totalSize); + //bitonicSort(friends, totalSize, k); +while(k>0){ + for(i=0; i0){ + swap(friends, i, i+k); + }} + } + k = greatestPowerOfTwoLessThan(k); + } + + /*for(i=0; i= totalSize); + else{ + obliv if(oblivStrCmp(friends[i], friends[i+k]) < 0){ + swap(friends, i, i+k); + }} + } + k = greatestPowerOfTwoLessThan(k); + }*/ + + for(i = 0; i < totalSize-1; i++){ + obliv if(oblivStrCmp(friends[i], friends[i + 1])==0){ + commonSize++; + addString(friends[i], commonFriends[i/2]); + } + //else{ + // commonFriends[i+1][0] = '\0'; + //} + } + +fprintf(stderr, "Hello"); + + //shuffling + srand(time(NULL)); + int r1, r2; + for(i = 0; icommonSize, commonSize, 0); + for(i=0; icommon[i][j],commonFriends[i][j],0); +} From a923a794509ce3c63c2043ab69eadcda63a5cb89 Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Thu, 19 Jun 2014 12:48:46 -0400 Subject: [PATCH 27/29] Cleaned up mutual --- test/oblivc/mutualfriends/mutual.c | 6 +-- test/oblivc/mutualfriends/mutual.h | 4 +- test/oblivc/mutualfriends/mutual.oc | 66 +++++------------------------ 3 files changed, 14 insertions(+), 62 deletions(-) diff --git a/test/oblivc/mutualfriends/mutual.c b/test/oblivc/mutualfriends/mutual.c index 822b4bf36..7ec321c72 100644 --- a/test/oblivc/mutualfriends/mutual.c +++ b/test/oblivc/mutualfriends/mutual.c @@ -115,7 +115,6 @@ int main(int argc,char *argv[]) while(fgets(buf[i], MAXL, infile)!=NULL){ strcpy(io.mine[i], buf[i]); i++; - //buf[i] = malloc(20*sizeof(char)); } io.size = i; mergeSort(io.mine, 0, io.size-1); @@ -133,14 +132,13 @@ int main(int argc,char *argv[]) execYaoProtocol(&pd,sortMutual, &io); //execDebugProtocol(&pd,sortMutual, &io); fprintf(stderr,"%s total time: %lf s\n",mySide(),wallClock()-lap); - //fprintf(stderr,"Gate Count: %u\n",yaoGateCount()); + fprintf(stderr,"Gate Count: %u\n",yaoGateCount()); cleanupProtocol(&pd); -// fprintf(stderr, "Result: %d %c\n", io.commonSize, io.common[0][0]); fprintf(stderr, "Result: %d\n", io.commonSize); for(i=0; imine[i][j], 1); } } -// int k = size2 + size1 - 1; for(i=0; i < size2; i++) for(j=0; jmine[i][j], 2); int totalSize = size1 + size2; int k = greatestPowerOfTwoLessThan(totalSize); - //bitonicSort(friends, totalSize, k); -while(k>0){ - for(i=0; i0){ + for(i=0; i0){ + obliv if(oblivStrCmp(friends[i], friends[i+k])<0){ swap(friends, i, i+k); }} } k = greatestPowerOfTwoLessThan(k); } - /*for(i=0; i= totalSize); - else{ - obliv if(oblivStrCmp(friends[i], friends[i+k]) < 0){ - swap(friends, i, i+k); - }} - } - k = greatestPowerOfTwoLessThan(k); - }*/ - for(i = 0; i < totalSize-1; i++){ obliv if(oblivStrCmp(friends[i], friends[i + 1])==0){ commonSize++; addString(friends[i], commonFriends[i/2]); } - //else{ - // commonFriends[i+1][0] = '\0'; - //} } -fprintf(stderr, "Hello"); - //shuffling srand(time(NULL)); int r1, r2; @@ -178,10 +136,6 @@ fprintf(stderr, "Hello"); r1 = rand() % MAXN; r2 = rand() % MAXN; swap(commonFriends, r1, r2); - /*obliv char temp[MAXL]; - addString(commonFriends[r1], temp); - addString(commonFriends[r2], commonFriends[r1]); - addString(temp, commonFriends[r2]);*/ } revealOblivInt(&io->commonSize, commonSize, 0); for(i=0; i Date: Thu, 19 Jun 2014 12:54:31 -0400 Subject: [PATCH 28/29] Mutual example now in mutualfriends --- test/oblivc/MergeSort.c | 94 ---------------------- test/oblivc/mutual/Makefile | 5 -- test/oblivc/mutual/mutual.c | 143 ---------------------------------- test/oblivc/mutual/mutual.h | 19 ----- test/oblivc/mutual/mutual.oc | 147 ----------------------------------- 5 files changed, 408 deletions(-) delete mode 100644 test/oblivc/MergeSort.c delete mode 100644 test/oblivc/mutual/Makefile delete mode 100644 test/oblivc/mutual/mutual.c delete mode 100644 test/oblivc/mutual/mutual.h delete mode 100644 test/oblivc/mutual/mutual.oc diff --git a/test/oblivc/MergeSort.c b/test/oblivc/MergeSort.c deleted file mode 100644 index 570327b4a..000000000 --- a/test/oblivc/MergeSort.c +++ /dev/null @@ -1,94 +0,0 @@ -/* C program for merge sort */ -#include -#include -#include - -/* Function to merge the two haves arr[l..m] and arr[m+1..r] of array arr[] */ -void merge(char arr[45][100], int l, int m, int r) -{ - int i, j, k; - int n1 = m - l + 1; - int n2 = r - m; - - /* create temp arrays */ - char L[n1][100], R[n2][100]; - - /* Copy data to temp arrays L[] and R[] */ - for(i = 0; i < n1; i++) - strcpy(L[i], arr[l+i]); - for(j = 0; j < n2; j++) - strcpy(R[j], arr[m+1+j]); - - /* Merge the temp arrays back into arr[l..r]*/ - i = 0; - j = 0; - k = l; - while (i < n1 && j < n2) - { - if (strcmp(L[i],R[j]) == -1) - { - strcpy(arr[k], L[i]); - i++; - } - else - { - strcpy(arr[k], R[j]); - j++; - } - k++; - } - - /* Copy the remaining elements of L[], if there are any */ - while (i < n1) - { - strcpy(arr[k], L[i]); - i++; - k++; - } - - /* Copy the remaining elements of R[], if there are any */ - while (j < n2) - { - strcpy(arr[k], R[j]); - j++; - k++; - } -} - -/* l is for left index and r is right index of the sub-array - of arr to be sorted */ -void mergeSort(char arr[45][100], int l, int r) -{ - if (l < r) - { - int m = l+(r-l)/2; //Same as (l+r)/2, but avoids overflow for large l and h - mergeSort(arr, l, m); - mergeSort(arr, m+1, r); - merge(arr, l, m, r); //line 67 - } -} - -/* Driver program to test above functions */ -main() -{ - char arr[2][100]; - strcpy(arr[0], "bbb"); - strcpy(arr[1], "aaa"); -// printf("%s", arr[0]); -// printf("%s", arr[1]); - mergeSort(arr, 0, 1); - printf("%s", arr[0]); - printf("%s", arr[1]); - -// int arr[] = {12, 11, 13, 5, 6, 7}; -// int arr_size = sizeof(arr)/sizeof(arr[0]); - -// printf("Given array is \n"); -// printArray(arr, arr_size); - -// mergeSort(arr, 0, arr_size - 1); - -// printf("\nSorted array is \n"); -// printArray(arr, arr_size); - return 0; -} diff --git a/test/oblivc/mutual/Makefile b/test/oblivc/mutual/Makefile deleted file mode 100644 index 18131a2b9..000000000 --- a/test/oblivc/mutual/Makefile +++ /dev/null @@ -1,5 +0,0 @@ -all: - ~/obliv-c/bin/oblivcc mutual.c mutual.oc -I ./ -lrt - -test: - ~/cmd/cycle './a.out 1 alice2.txt | ./a.out 2 bob2.txt' diff --git a/test/oblivc/mutual/mutual.c b/test/oblivc/mutual/mutual.c deleted file mode 100644 index 7bae85876..000000000 --- a/test/oblivc/mutual/mutual.c +++ /dev/null @@ -1,143 +0,0 @@ -#include -#include -#include -#include -#include - -#include "mutual.h" - -int currentParty; - -/* Function to merge the two haves arr[l..m] and arr[m+1..r] of array arr[] */ -void merge(char arr[MAXN][MAXL], int l, int m, int r) -{ - int i, j, k; - int n1 = m - l + 1; - int n2 = r - m; - - /* create temp arrays */ - char L[n1][100], R[n2][100]; - - /* Copy data to temp arrays L[] and R[] */ - for(i = 0; i < n1; i++) - strcpy(L[i], arr[l+i]); - for(j = 0; j < n2; j++) - strcpy(R[j], arr[m+1+j]); - - /* Merge the temp arrays back into arr[l..r]*/ - i = 0; - j = 0; - k = l; - while (i < n1 && j < n2) - { - if (strcmp(L[i],R[j]) < 0) - { - strcpy(arr[k], L[i]); - i++; - } - else - { - strcpy(arr[k], R[j]); - j++; - } - k++; - } - - /* Copy the remaining elements of L[], if there are any */ - while (i < n1) - { - strcpy(arr[k], L[i]); - i++; - k++; - } - - /* Copy the remaining elements of R[], if there are any */ - while (j < n2) - { - strcpy(arr[k], R[j]); - j++; - k++; - } -} - -/* l is for left index and r is right index of the sub-array - of arr to be sorted */ -void mergeSort(char arr[MAXN][MAXL], int l, int r) -{ - if (l < r) - { - int m = (l+r) / 2; //Same as (l+r)/2, but avoids overflow for large l and h - mergeSort(arr, l, m); - mergeSort(arr, m+1, r); - merge(arr, l, m, r); - } -} - -const char* mySide() -{ - if(currentParty==1) return "Generator"; - else return "Evaluator"; -} - -double wallClock() -{ - struct timespec t; - int i = clock_gettime(CLOCK_REALTIME,&t); - return t.tv_sec+1e-9*t.tv_nsec; -} -double lap; - -int main(int argc,char *argv[]) -{ - //these variables are used everytime - ProtocolDesc pd; - protocolIO io; - - //checking that the input has the correct number of variables - if(argc<3) - { if(argc<2) fprintf(stderr,"Party missing\n"); - else fprintf(stderr,"friends missing\n"); - fprintf(stderr,"Usage: %s <1|2> \n",argv[0]); - return 1; - } - FILE *infile; - infile = fopen(argv[2], "r"); - if(infile==NULL){ - //Error("Unable to open file"); - fprintf(stderr, "ERROR!"); - return 1; - } - //TODO change input file so that it says how many friends there are - int i=0; - char buf[MAXN][MAXL]; - while(fgets(buf[i], MAXL, infile)!=NULL){ - strcpy(io.mine[i], buf[i]); - i++; - } - io.size = i; - - mergeSort(io.mine, 0, io.size-1); - - fprintf(stderr,"Result: %d\n", io.size); - - fclose(infile); - - //standard setup - protocolUseStdio(&pd); - currentParty = (argv[1][0]=='1'?1:2); - setCurrentParty(&pd,currentParty); - setCurrentParty(&pd,currentParty); - lap = wallClock(); - //execYaoProtocol(&pd,mutualFriends, &io); - //execDebugProtocol(&pd,mutualFriends, &io); - execYaoProtocol(&pd,sortMutual, &io); - //execDebugProtocol(&pd,sortMutual, &io); - fprintf(stderr,"%s total time: %lf s\n",mySide(),wallClock()-lap); - fprintf(stderr,"Gate Count: %u\n",yaoGateCount()); - cleanupProtocol(&pd); - fprintf(stderr, "Result: %d\n", io.commonSize); - for(i=0; i -#include -#include - -#include "mutual.h" - -typedef obliv bool obool; - -typedef obliv int oint; - - -int greatestPowerOfTwoLessThan(int n){ - int k = 1; - while(k < n) - k=k*2; - return k / 2; -} - -oint oblivStrCmp(obliv char* s1, obliv char* s2) obliv { - obliv bool afternull = false; - int i; - oint ob = 0; - for( i = 0; i < MAXL; i++) { - obliv if (afternull) { - ; - } else { - obliv char c1 = s1[i]; - obliv char c2 = s2[i]; - obliv if (c1 != c2) { - ob = c1 - c2; - afternull = true; - } - else - obliv if (c1 == '\0') - afternull = true; - } - } - return ob; -} - -void addString(obliv char* src, obliv char* dest) obliv{ - int i; - for(i=0; isize); - size2 = ocBroadcastInt(2, io->size); - for(i=0;imine[i][j], 1); - - for(i=0; imine[i][j], 2); - - for( i=0; icommonSize, commonSize, 0); - for(i=0; icommon[i][j],commonFriends[i][j],0); - } - -//must be given two lists that are sorted -void sortMutual(void* args){ - protocolIO *io = args; - int size1, size2; - int i, j; - size1 = ocBroadcastInt(1, io->size); - size2 = ocBroadcastInt(2, io->size); - obliv char friends[2 * MAXN][MAXL]; - obliv char commonFriends[2 * MAXN][MAXL]; - obliv int commonSize; - - //places the two lists into one list - //because they are sorted, the resulting list in bitonic - for(i=0;imine[i][j], 1); - for(i=0; i < size2; i++) - for(j=0; jmine[i][j], 2); - - int totalSize = size1 + size2; - int k = greatestPowerOfTwoLessThan(totalSize); - - //bitonically sorting the list - int l = 0; - while(k>0){ - for(i=0; icommonSize, commonSize, 0); - for(i=0; icommon[i][j],commonFriends[i][j],0); -} From 28c08f3954b841847a9d4d2afcb390d50bde2f0e Mon Sep 17 00:00:00 2001 From: mdh3hc Date: Fri, 20 Jun 2014 16:58:47 -0400 Subject: [PATCH 29/29] Final touches to mutual --- test/oblivc/mutualfriends/mutual.c | 11 ++++++----- test/oblivc/mutualfriends/mutual.h | 6 +++--- test/oblivc/mutualfriends/mutual.oc | 23 ++++++++++------------- 3 files changed, 19 insertions(+), 21 deletions(-) diff --git a/test/oblivc/mutualfriends/mutual.c b/test/oblivc/mutualfriends/mutual.c index 7ec321c72..e86e80346 100644 --- a/test/oblivc/mutualfriends/mutual.c +++ b/test/oblivc/mutualfriends/mutual.c @@ -118,8 +118,8 @@ int main(int argc,char *argv[]) } io.size = i; mergeSort(io.mine, 0, io.size-1); - fprintf(stderr,"Result: %d\n", io.size); - + fprintf(stderr,"Size: %d\n", io.size); + fclose(infile); //standard setup protocolUseStdio(&pd); @@ -136,9 +136,10 @@ int main(int argc,char *argv[]) cleanupProtocol(&pd); fprintf(stderr, "Result: %d\n", io.commonSize); - for(i=0; i0){ - for(i=0; i0) + swap(friends, i, i+k); k = greatestPowerOfTwoLessThan(k); } for(i = 0; i < totalSize-1; i++){ obliv if(oblivStrCmp(friends[i], friends[i + 1])==0){ commonSize++; - addString(friends[i], commonFriends[i/2]); + addString(friends[i+1], commonFriends[i+1]); } } //shuffling srand(time(NULL)); int r1, r2; - for(i = 0; icommonSize, commonSize, 0); - for(i=0; icommon[i][j],commonFriends[i][j],0); }