void des(const std::string& inp, std::string& key, std::string& p_encrypted) { boost::uint32_t c = bpermute(key.data(), 28, PC1[0]); boost::uint32_t d = bpermute(key.data(), 28, PC1[1]); boost::uint32_t l = rrotate(bpermute(inp.data(), 32, IP[0]),31); boost::uint32_t r = rrotate(bpermute(inp.data(), 32, IP[1]),31); boost::uint32_t rot=1; for(boost::uint32_t i=0;i<16;++i){ boost::uint32_t k[2]= { permute(rrotate28(c,rot),24,PC2[1]), permute(rrotate28(d,rot),24,PC2[0]) }; for(boost::uint32_t j=0; j<8; ++j){ boost::uint32_t x=k[j>>2]>>(j&3)*6; boost::uint32_t b=(rrotate(r,j*4)^x)&0x3f; boost::uint32_t s=(S[j][b>>3]>>((b&7)*4))&0xf; l^=rrotate(permute(s<<j*4,32,P),31); } boost::uint32_t t=l; l=r; r=t; ++rot; if(i!=0 && i!=7 && i!=14) ++rot; } char v[8]={}; packbe(v,0,rrotate(r,1)); packbe(v,4,rrotate(l,1)); l=bpermute(v,32,FP[0]); r=bpermute(v,32,FP[1]); char out[8]={}; packbe(out,0,l); packbe(out,4,r); p_encrypted.assign(out, 8); }

/* Function to print permutations of string This function takes three parameters: 1. String 2. Starting index of the string 3. Ending index of the string. */ void permute(char *a, int i, int n) { int j; if (i == n && a[0]!=0) printf("%s\n", a); else { for (j = i; j <= n; j++) { swap((a + i), (a + j)); permute(a, i + 1, n); swap((a + i), (a + j)); //backtrack } } }

void main() { size_t * perm = malloc(sizeof(size_t) * 1000); struct rtree_t t = {0}; int i, j, k; float pos[1000][3]; float sml[1000]; intptr_t key[1000]; int l = 0; for(i = 0; i < 10; i++) { for(j = 0; j < 10; j++) { for(k = 0; k < 10; k++) { pos[l][0] = i * 0.1 * (1<<20); pos[l][1] = j * 0.1 * (1<<20); pos[l][2] = k * 0.1 * (1<<20); sml[l] = 0; key[l] = peano_hilbert_key(pos[l][0], pos[l][1], pos[l][2], 20); l++; } } } gsl_heapsort_index(perm, key, 1000, sizeof(intptr_t), (void*)intptr_t_compare); float (*__pos)[3] = permute(perm, pos, 3 * sizeof(float), 3 * sizeof(float), 1000, 1000); float * __sml = permute(perm, sml, sizeof(float), sizeof(float), 1000, 1000); intptr_t * __key = permute(perm, key, sizeof(intptr_t), sizeof(intptr_t), 1000, 1000); rtree_build(&t, __pos, __sml, __key, 1000); float dist[10]; intptr_t nei[10]; int nused = 0; float hhint = 100000; float p[3] = {499999, 499999,499999}; rtree_neighbours(&t, p, __pos, 1000, nei, dist, 10, &nused, NULL); printf("hello\n"); }

void permute(char *a, int i, int n) { int j; if (i == n) { strcpy(perm_head -> w, a); perm_head -> next = malloc(sizeof(permutes)); perm_head = perm_head -> next; } else { for (j = i; j <= n; j++) { swap(a+i, a+j); permute(a, i+1, n); swap(a+i, a+j); } } }

void permute(char *a, int i, int n) { int j; if (i == n) printf("%s\n", a); else { for (j = i; j <= n; j++) { swap((a+i), (a+j)); permute(a, i+1, n); swap((a+i), (a+j)); } } }

void permute (char * str, int start, int end) { if (start == end) printf ("%s\n", str); else { int j; for (j = start; j <= end; j++) { swap ((str + start), (str + j)); permute (str, start + 1, end); swap ((str + start), (str + j)); } } }

void permute(char *a, int i, int n) { int j; if (i == n-1) printf("%s\n", a); else { for (j = i; j <n; j++) { swap(&a[i], &a[j]); permute(a, i+1, n); swap(&a[i], &a[j]);//backtrack } } }

//function to generate permuted array and make the corresponding trees simultaneously with help from above function void permute(int *a, int i, int n) { int j; if(i==n) { maketree(a,n); } else { for (j = i; j <= n; j++) { swap((a+i), (a+j)); permute(a, i+1, n); swap((a+i), (a+j)); //backtrack } } }

// with extra space void permute(vector<int> &container, vector<bool> &visited, vector<int> &num, vector<vector<int> > &result) { if(container.size() == num.size()) { result.push_back(container); return; } for(int i = 0; i < num.size(); ++i) { if(!visited[i]) { visited[i] = true; container.push_back(num[i]); permute(container, visited, num, result); visited[i] = false; container.pop_back(); } } }

void permute(int *v, const int start, const int n) { // print(v, n); test(v, n); if (start < n) { int i, j; for (i = n-2; i >= start; i--) { for (j = i + 1; j < n; j++) { swap(v, i, j); permute(v, i+1, n); } // for j rotateLeft(v, i, n); } // for i } } // permute

void CStreamMerger::primeRows(const void * * rows) { assertex(first && (activeInputs == 0)); first = false; for(unsigned i = 0; i < numInputs; i++) { if ((pending[i] = rows[i]) != NULL) { mergeheap[activeInputs++] = i; pendingMatches[i] = true; } } permute(); }

/* Function to print permutations of string This function takes three parameters: 1. String 2. Starting index of the string 3. Ending index of the string. */ void permute(char *str, int start, int end) { int i; if (start == end) printf("%s\n", str); else { for (i = start; i <= end; i++) { swap( (str + start), ( str + i) ); permute(str, start+1, end); swap( (str + start), ( str + i) ); // swap back to previous condition. } } }

void permute(vector<int>& nums,int n, map<int,int> numToCount, vector<vector<int>>& res,vector<int>& perm,int count){ if(count==n){ res.push_back(vector<int>(perm)); return; } for(map<int,int>::iterator it=numToCount.begin();it!=numToCount.end();++it){ if(it->second==0) continue; perm.push_back(it->first); it->second--; permute(nums,n,numToCount,res,perm,count+1); perm.pop_back(); it->second++; } }

void permute(int start, int end, char *str) { if(start>end) { return; } if(start==end) { printf("%s\n",str); return; } int i=start; for(;i<=end;i++) { swap(str+start, str+i); permute(start+1, end, str); swap(str+i, str+start); } }

void permute(vector<vector<int>>& ans, vector<int>& perm, int begin) { if (begin == perm.size()) { ans.push_back(perm); return; } for (int i=begin; i<perm.size(); i++) { if (i!=begin && perm[i] == perm[begin]) continue; swap(perm[i], perm[begin]); permute(ans, perm, begin+1); swap(perm[i], perm[begin]); } }

void genShapes(int k) { int * array; array = malloc(sizeof(int)*k); int i=0; for(i = 0; i < k; i++) { array[i] = i; // printf("array[%d] = %d\n", i, array[i]); } permute(array, k); //printf return; }

//to generate all the permutation of the keys void permute(int *a, int i, int n) { int j; if(i==n) printArray(a,n); else { for (j = i; j <= n; j++) { swap((a+i), (a+j)); permute(a, i+1, n); swap((a+i), (a+j)); } } }

int permute(char *a, int i, int n) { int j; if(i==n) return a; else { for(j=i;j<=n;j++) { swap((a+i), (a+j)); permute(a, i+1, n); swap((a+i), (a+j)); } } }

/* Function to print permutations of string This function takes three parameters: 1. String 2. Starting index of the string 3. Ending index of the string. */ void permute(char *a, int l, int r) { int i; if (l == r) printf("%s\n", a); else { for (i = l; i <= r; i++) { swap((a+l), (a+i)); permute(a, l+1, r); swap((a+l), (a+i)); //backtrack } } }

void QR_decomposition(double **A, double *gamma, int rows, int columns, int *permutation) { int k; double t, *norms, *max; norms = malloc(columns * sizeof(double)); max = malloc(columns * sizeof(double)); for (k = 0; k < columns; k ++) { update_norms_vector(A, rows, columns, norms, k, max); permute(A, rows, columns, permutation, norms, k); t = generating_Q(rows, A, k, gamma, norms); update_matrix(A, gamma, rows, columns, k); A[k][k] = -t; } free(max); free(norms); }

/* Function to print permutations of string This function takes three parameters: 1. String 2. Starting index of the string 3. Ending index of the string. */ void permute(char *a, int i, int n) { int j; if (i == n) printf("%s\n", a); else { for (j = i; j <= n; j++) { swap((a+i), (a+j)); permute(a, i+1, n); swap((a+i), (a+j)); //backtrack } } }

static unsigned int transform_blk (void *c, const unsigned char *data) { MD2_CONTEXT *ctx = c; int j; for (j = 0; j < 16; j++) { ctx->C[j] ^= S[data[j] ^ ctx->L]; ctx->L = ctx->C[j]; } permute(ctx->X, data); return /* burn stack */ 4 + 5 * sizeof(void*); }

void permute(char res[PERM_LEV+1], int full[PERM_LEV], int level){ if(level == PERM_LEV){ res[PERM_LEV] = '\0'; if(prime(strtol(res, NULL, 10))) printf("%s\n",res); return; } for(int i = 0;i < PERM_LEV;i++){ if(full[i] != 1){ res[level] = 49 + i; full[i] = 1; permute(res, full, level + 1); full[i] = 0; } } }

int main() { int n, k, j, y, z; int * arr; /*scanf("%d %d", &n,&k);*/ k=2; for (n=0; n<20; n++) { int empty[n]; for (j=0; j<n; j++) empty[j] = 0; arr = empty; z = permute(arr, n, n, k); printf("%d\n",z); } return 0; }

void test02 ( int32_t argc, char * argv[] ) { char dig[] = "0123456789"; uint64_t y = 10*9*8*7*6*5*4*3*2*1; g_cnt=0; permute(dig,0,10); info_print("y = %llu",y); info_print("g_cnt = %llu",g_cnt); /* memset(d,0,11); memcpy(d,dig,k); permute(d,0,k); */ }

void permute(char *str, const int begin, const int end) { int i = begin; int j; for (i = begin; i < end-1; ++i) { for (j = i+1; j < end; ++j) { swap(str + i, str + j); permute(str, i+1, end); swap(str + i, str + j); } } printf("%s\n", str); }

/* permute [set[begin], set[end]) */ int permute(char* set, int begin, int end) { int i; int range = end - begin; if (range == 1) { //printf("set: %s\n", set); } else { for(i=0; i<range; i++) { swap(&set[begin], &set[begin+i]); permute(set, begin+1, end); swap(&set[begin], &set[begin+i]); /* set back */ } } return 0; }

int main() { char *str; size_t maxchar=20; int len=0; getline(&str,&maxchar,stdin); printf("String entered is:"); puts(str); len=strlen(str); permute(str,0,len-1); return 0; }

void permute(string& res, vector<int>& nums, int n, int k) { if(n == 1) { res.push_back(nums[1] + '0'); return; } int length = 1, tmpn = n; tmpn--; while(tmpn != 1) { length *= tmpn; tmpn--; } int digit = ceil(double(k)/length); res.push_back(nums[digit] + '0'); nums.erase(nums.begin() + digit); permute(res, nums, n-1, k-(digit-1)*length); }

void permute(char * str, int i, int length) { if(i == length) { printf("%s\n", str); return; } for(int j = i; j < length; j++) { swap(str + i, str + j); permute(str, i + 1, length); swap(str + i, str + j); } return; }