void rotate(vector<int> &a) { a.insert(a.begin(), a[a.size()-1]); a.pop_back(); }
void loop() { size_t iter = 0; while( (!Lambda.empty()) && (iter < max_iter) ) { if(verbosity >= 2) cout<<"Iteration: "<<iter<<endl; else if(verbosity == 1 && (iter%10)==0) cout<<"Iteration: "<<iter<<endl; Undefined u = Lambda.front(); Lambda.pop(); double energy2, m2, b2,min_m, min_b, min_energy; double energy3, m3, b3; //short_array min_x = minimizer->minimize( u.x_l, u.lambda, min_energy, min_m, min_b, true); short_array min_x = minimizer->minimize( u.x_l, u.lambda, min_energy, min_m, min_b, false); short_array x2 = minimizer->minimize( u.x_r, u.lambda, energy2, m2, b2, false); short_array x3 = minimizer->minimize( u.x_r, u.lambda, energy3, m3, b3, true); if(min_energy > energy2 && min_energy > energy3) e1++; else if( energy2 > energy3 && energy2 > min_energy) e2++; else if( energy3 > energy2 && energy3 > min_energy) e3++; if( energy2 < min_energy) { min_m = m2; min_b = b2; min_energy = energy2; min_x = x2; } if(energy3 < min_energy) { min_m = m3; min_b = b3; min_energy = energy3; min_x = x3; } //if( !compare( min_x, u.x_l, u.lambda) && !compare(min_x, u.x_r, u.lambda) ) { LineSegment l( min_m, min_b, lambda_min, lambda_max, false ); kmc.addLineSegment(l); if(verbosity >= 2) cout<<"* Adding line segment: "<<l<<endl; int num_intersections = kmc.num_intersections; if( num_intersections > 1 && (kmc.intersecting_lambda[0] != kmc.intersecting_lambda[num_intersections -1] ) ) { // had intersections cout.precision(16); if(verbosity >= 1) { cout<<"\t Had intersections at "<< kmc.intersecting_lambda[0]<<", "<<kmc.intersecting_lambda[num_intersections-1]<<endl; cout<<"\t\t Energies are: "<< fixed << kmc.intersecting_energies[0]<<", "<<fixed<<kmc.intersecting_energies[num_intersections-1]<<endl; } double lambda_l = kmc.intersecting_lambda[0]; double lambda_r = kmc.intersecting_lambda[num_intersections - 1]; int index_l = kmc.intersecting_indexes[0]; int index_r = kmc.intersecting_indexes[num_intersections - 1]; if(index_r - index_l > 1 ) labelings.erase( labelings.begin() + index_l + 1, labelings.begin() + index_r); Undefined u1( lambda_l, labelings[index_l], min_x ); Undefined u2( lambda_r, labelings[index_r], min_x ); Lambda.push(u1); Lambda.push(u2); labelings.insert( labelings.begin() + index_l + 1, min_x); } } //else //{ //} iter++; } if(iter == max_iter) cout<<"Maximum number of iterations reached"<<endl; cout<<"Done in "<<iter<<" iterations."<<endl; cout<<KBCYN<<"[e1, e2, e3] = ["<<e1<<", "<<e2<<", "<<e3<<"]"<<KNRM<<endl; if(verbosity >= 1) cout<<kmc<<endl; if(verbosity >= 2) { /*cout<<"labelings:"<<endl; for(size_t i = 0; i < labelings.size(); i++) { cout<<labelings[i][0]<<" "; } cout<<endl;*/ } }
END_EXTERNC BEGIN_EXTERNC static MI_Boolean ServerCallback( Selector* sel, Handler* handler, MI_Uint32 mask, MI_Uint64 currentTimeUsec) { char buf[BUFFER_SIZE]; MI_Result r; size_t n = 0; sel=sel; currentTimeUsec = currentTimeUsec; s_srv_h = handler; // Process READ events. if (mask & SELECTOR_READ) { for (;;) { // Read request: n = 0; r = Sock_Read(handler->sock, buf, sizeof(buf), &n); s_srv_data.insert(s_srv_data.end(), buf, buf + n); #if defined(TRACE_IO) printf("SERVER.READ[%u]\n", n); #endif if (r == MI_RESULT_WOULD_BLOCK) break; TEST_ASSERT(r == MI_RESULT_OK); // Did client close connection? if (n == 0) { return MI_FALSE; } // Save incoming data. // Now solicit read and write events. handler->mask = SELECTOR_READ|SELECTOR_WRITE; //break; // if event 'write' was already set and we have nothing to write // new event will never arrive // so we need to try to write data once it's available mask |= SELECTOR_WRITE; } } // Process WRITE events. if (mask & SELECTOR_WRITE) { for (;;) { n = 0; size_t m = 7 + (int)(rand() % 256); if (m >= s_srv_data.size()) m = s_srv_data.size(); // Write response: r = Sock_Write(handler->sock, &s_srv_data[0], m, &n); s_srv_data.erase(s_srv_data.begin(), s_srv_data.begin() + n); #if defined(TRACE_IO) printf("SERVER.WRITE[%u]\n", n); #endif if (s_srv_data.size() == 0) { /* Watch for read events (but not write events) */ handler->mask = SELECTOR_READ; break; } if (r == MI_RESULT_WOULD_BLOCK) break; TEST_ASSERT(r == MI_RESULT_OK); //break; } } if (mask & SELECTOR_REMOVE) { r = Sock_Close(handler->sock); TEST_ASSERT(r == MI_RESULT_OK); s_done = true; PAL_Free(handler); handler = 0; } if (mask & SELECTOR_DESTROY) { if (handler) { Sock_Close(handler->sock); PAL_Free(handler); } } return MI_TRUE; }
void ZeroSampleFiller::fill(const vector<double>& x, const vector<double>& y, vector<double>& xFilled, vector<double>& yFilled, size_t zeroSampleCount) { if (x.size() != y.size()) throw runtime_error("[ZeroSampleFiller::fill()] x and y arrays must be the same size"); // adjacent samples are expected to be within this tolerance const static double EPSILON = 1e-5; // start with the original data xFilled.assign(x.begin(), x.end()); yFilled.assign(y.begin(), y.end()); // insert flanking zeros around non-zero data points bool wasInData = false; bool nowInData = false; for (int i=y.size()-1; i >= 0; --i) { nowInData = yFilled[i] > 0.0; if (nowInData && !wasInData) { // step forward to check for missing samples // at i==0, fudge the first order delta double firstOrderDelta = i < 1 ? xFilled[i+1] - xFilled[i] : xFilled[i] - xFilled[i-1]; // at i==1 or when possibly between signals, assume no second order delta double secondOrderDelta = i < 2 || yFilled[i-1] == 0 ? 0 : firstOrderDelta - (xFilled[i-1] - xFilled[i-2]); double totalDelta = 0; for (int j=1; j <= (int) zeroSampleCount; ++j) { totalDelta += secondOrderDelta; double newX = xFilled[i+j-1] + firstOrderDelta + totalDelta; bool oob = i+j >= (int) y.size(); // sampleDelta should never be less than negative firstOrderDelta double sampleDelta = oob ? 0 : xFilled[i+j] - newX; if (sampleDelta < -firstOrderDelta) break; //throw std::runtime_error("[ZeroSampleFiller::fill()] miscalculated sample rate"); // if out of bounds or newX is a valid missing sample, insert a new zero point if (oob || sampleDelta > firstOrderDelta) { xFilled.insert(xFilled.begin()+(i+j), newX); yFilled.insert(yFilled.begin()+(i+j), 0.0); } } } wasInData = nowInData; } wasInData = false; for (int i=0, end=yFilled.size(); i < end; ++i, end=yFilled.size()) { nowInData = yFilled[i] > 0.0; if (nowInData && !wasInData) { // step backward to check for missing samples // at i==end-1, fudge the first order delta double firstOrderDelta = i == end-1 ? xFilled[i] - xFilled[i-1] : xFilled[i+1] - xFilled[i]; // at i==end-2 or when possibly between signals, assume no second order delta double secondOrderDelta = i == end-2 || yFilled[i+1] == 0 ? 0 : (xFilled[i+2] - xFilled[i+1]) - firstOrderDelta; double totalDelta = 0; for (int j=1; j <= (int) zeroSampleCount; ++j) { totalDelta += secondOrderDelta; double newX = (xFilled[i-j+1] - firstOrderDelta) - totalDelta; bool oob = i-j < 0; // xFilled[i-j] and newX should be nearly equal if they are the same sample // sampleDelta should never be greater than firstOrderDelta double sampleDelta = oob ? 0 : xFilled[i-j] - newX; if (sampleDelta > firstOrderDelta) break; //throw std::runtime_error("[ZeroSampleFiller::fill()] miscalculated sample rate"); // if out of bounds or newX is a valid missing sample, insert a new zero point if (oob || sampleDelta <= -firstOrderDelta ) { xFilled.insert(xFilled.begin()+(i-j+1), newX); yFilled.insert(yFilled.begin()+(i-j+1), 0.0); ++i; } } } wasInData = nowInData; } }
void addBoundaryWords(vector<string> &phrase) { phrase.insert(phrase.begin(), "<s>"); phrase.push_back("</s>"); }
void GraphsListN::addGraph( vector< short unsigned int > iVertices, const vector< bool > &bVerticesLinkable, const unsigned int &iType, bool bSpherical, const short unsigned int &iVertexSupp1, const short unsigned int &iVertexSupp2, const unsigned int &iDataSupp ) { unsigned int short iTemp, i; if( bSpherical ) { if( iType == 0 ) // An { // on veut une fois les A_n (et pas une fois pour chaque sens de lecture) if( iVertices.front( ) > iVertices.back( ) ) reverse( iVertices.begin( ), iVertices.end( ) ); } else if( iType == 1 ) // Bn { iVertices.push_back( iVertexSupp1 ); } else if( iType == 3 ) // Dn { if( iVerticesCount > 4 ) { iTemp = iVertices[ iVerticesCount - 2 ]; iVertices[ iVerticesCount - 2 ] = min( iTemp, iVertexSupp1 ); iVertices.push_back( max( iTemp, iVertexSupp1 ) ); } else { if( iVertices[0] > iVertices[2] ) { iTemp = iVertices[0]; iVertices[0] = iVertices[2]; iVertices[2] = iTemp; } if( iVertexSupp1 < iVertices[0] ) { iVertices.push_back( iVertices[2] ); iVertices[2] = iVertices[0]; iVertices[0] = iVertexSupp1; } else if( iVertexSupp1 < iVertices[2] ) { iVertices.push_back( iVertices[2] ); iVertices[2] = iVertexSupp1; } else iVertices.push_back( iVertexSupp1 ); } } else if( iType == 4 ) // En { if( iVerticesCount == 6 ) { if( iVertices.front( ) > iVertices.back( ) ) reverse( iVertices.begin( ), iVertices.end( ) ); } iVertices.push_back( iVertexSupp1 ); } else if( iType == 5 ) // Fn { iVertices.push_back( iVertexSupp1 ); if( iVertices.front( ) > iVertices.back( ) ) reverse( iVertices.begin( ), iVertices.end( ) ); } else if( iType == 7 ) // Hn { iVertices.push_back( iVertexSupp1 ); } } else { if( iType == 0 && iDataSupp ) { int iMinIndex(0); unsigned int iMinValue( iVertices[0] ); iVertices.push_back( iVertexSupp1 ); vector< short unsigned int > iVerticesTemp( iVertices ); // on répère le sommet avec l'indice le plus petit for( i = 1; i < iVerticesCount; i++ ) { if( iVertices[i] < iMinValue ) { iMinValue = iVertices[i]; iMinIndex = i; } } // et le sens de parcours int iDirection( iVertices[ !iMinIndex ? (iVerticesCount - 1) : (iMinIndex - 1) ] > iVertices[ iMinIndex == (int)( iVerticesCount - 1 ) ? 0 : ( iMinIndex + 1 ) ] ? 1 : -1 ); // on réordonne for( unsigned int j(0); j < iVerticesCount; j++ ) { iVertices[j] = iVerticesTemp[iMinIndex]; iMinIndex += iDirection; if( iMinIndex == -1 ) iMinIndex = iVerticesCount - 1; else if( iMinIndex == (int)iVerticesCount ) iMinIndex = 0; } } else if( iType == 1 ) // TBn { if( iVerticesCount == 4 ) // TB3 { i = iVertices[1]; iTemp = max( iVertices[0], iVertices[2] ); iVertices[1] = min( iVertices[0], iVertices[2] ); iVertices[2] = iTemp; iVertices[0] = i; iVertices.insert( iVertices.begin( ), iVertexSupp1 ); } else // autres \tilde Bn { iTemp = min( iVertices[ iVerticesCount - 3 ], iVertexSupp1 ); iVertices.push_back( max( iVertices[ iVerticesCount - 3 ], iVertexSupp1 ) ); iVertices[ iVerticesCount - 3 ] = iTemp; iVertices.insert( iVertices.begin( ), iVertexSupp2 ); } } else if( iType == 2 ) // \tilde Cn { iVertices.insert( iVertices.begin( ), iVertexSupp1 ); iVertices.push_back( iVertexSupp2 ); if( iVertices[0] > iVertices[ iVerticesCount - 1 ] ) reverse( iVertices.begin( ), iVertices.end( ) ); } else if( iType == 3 ) // \tilde Dn { if( iVerticesCount >= 6 ) { // le vecteur iVerticesBase contient la base (i.e. sans les 4 extrémités) #ifdef _MSC_VER vector< short unsigned int > iVerticesBase; iTemp = iVerticesCount - 3; for( i = 1; i < iTemp; i++ ) iVerticesBase.push_back( iVertices[i] ); #else vector< short unsigned int > iVerticesBase( iVertices.begin( ) + 1, iVertices.begin( ) + iVerticesCount - 3 ); // ne marche pas sous Visual Studio 2010 & 2012 malheureusement #endif // on regarde si on doit modifier l'ordre if( iVerticesBase[0] > iVerticesBase[ iVerticesCount - 5 ] ) { reverse( iVerticesBase.begin( ), iVerticesBase.end( ) ); // ajout des 4 extrémités iVerticesBase.push_back( min( iVertices[0], iVertexSupp1 ) ); iVerticesBase.push_back( max( iVertices[0], iVertexSupp1 ) ); iVerticesBase.insert( iVerticesBase.begin( ), max( iVertices[ iVerticesCount - 3 ], iVertexSupp2 ) ); iVerticesBase.insert( iVerticesBase.begin( ), min( iVertices[ iVerticesCount - 3 ], iVertexSupp2 ) ); } else { // ajout des 4 extrémités iVerticesBase.push_back( min( iVertices[ iVerticesCount - 3 ], iVertexSupp2 ) ); iVerticesBase.push_back( max( iVertices[ iVerticesCount - 3 ], iVertexSupp2 ) ); iVerticesBase.insert( iVerticesBase.begin( ), max( iVertices[0], iVertexSupp1 ) ); iVerticesBase.insert( iVerticesBase.begin( ), min( iVertices[0], iVertexSupp1 ) ); } iVertices = iVerticesBase; } else // le TD4, "+" est traité différemment { vector<short unsigned int> iVerticesTemp( 4, 0 ); iVerticesTemp[0] = iVertices[0]; iVerticesTemp[1] = iVertices[2]; iVerticesTemp[2] = iVertexSupp1; iVerticesTemp[3] = iVertexSupp2; sort( iVerticesTemp.begin( ), iVerticesTemp.end( ) ); iVerticesTemp.push_back( iVertices[1] ); iVertices = iVerticesTemp; } } else if( iType == 4 ) // \tilde En { if( iVerticesCount == 7 ) // TE6 { // TODO: refaire l'encodage de ce graphe et modifer la fonction bIsSubgraphOf_spherical_euclidean? vector< short unsigned int > iVerticesTemp; unsigned int iMin( min( min( iVertices[1], iVertices[3] ), iVertexSupp1 ) ); if( iMin == iVertices[1] ) { iVerticesTemp.push_back( iVertices[0] ); iVerticesTemp.push_back( iVertices[1] ); if( min( iVertices[3], iVertexSupp1 ) == iVertices[3] ) { iVerticesTemp.push_back( iVertices[3] ); iVerticesTemp.push_back( iVertices[4] ); iVerticesTemp.push_back( iVertexSupp1 ); iVerticesTemp.push_back( iVertexSupp2 ); } else { iVerticesTemp.push_back( iVertexSupp1 ); iVerticesTemp.push_back( iVertexSupp2 ); iVerticesTemp.push_back( iVertices[3] ); iVerticesTemp.push_back( iVertices[4] ); } } else if( iMin == iVertices[3] ) { iVerticesTemp.push_back( iVertices[4] ); iVerticesTemp.push_back( iVertices[3] ); if( min( iVertices[1], iVertexSupp1 ) == iVertices[1] ) { iVerticesTemp.push_back( iVertices[1] ); iVerticesTemp.push_back( iVertices[0] ); iVerticesTemp.push_back( iVertexSupp1 ); iVerticesTemp.push_back( iVertexSupp2 ); } else { iVerticesTemp.push_back( iVertexSupp1 ); iVerticesTemp.push_back( iVertexSupp2 ); iVerticesTemp.push_back( iVertices[1] ); iVerticesTemp.push_back( iVertices[0] ); } } else { iVerticesTemp.push_back( iVertexSupp2 ); iVerticesTemp.push_back( iVertexSupp1 ); if( min( iVertices[1], iVertices[3] ) == iVertices[1] ) { iVerticesTemp.push_back( iVertices[1] ); iVerticesTemp.push_back( iVertices[0] ); iVerticesTemp.push_back( iVertices[3] ); iVerticesTemp.push_back( iVertices[4] ); } else { iVerticesTemp.push_back( iVertices[3] ); iVerticesTemp.push_back( iVertices[4] ); iVerticesTemp.push_back( iVertices[1] ); iVerticesTemp.push_back( iVertices[0] ); } } iVerticesTemp.push_back( iVertices[2] ); iVertices = iVerticesTemp; } else if( iVerticesCount == 8 ) // TE7 { if( iVertices.front( ) > iVertices.back( ) ) // la base du \tilde E7 est symétrique reverse( iVertices.begin( ), iVertices.end( ) ); iVertices.push_back( iVertexSupp1 ); } else // TE8 { iVertices.push_back( iVertexSupp1 ); } } else if( iType == 5 ) { iVertices.push_back( iVertexSupp1 ); } else if( iType == 6 && iDataSupp ) // \tilde G_2 { iVertices.push_back( iVertexSupp1 ); } } Graph g( iVertices, ptr_map_vertices_indexToLabel, bVerticesLinkable, iType, bSpherical, iDataSupp ); auto it( lower_bound( graphs.begin(), graphs.end(), g ) ); if( it == graphs.end() || !(*it == g) ) graphs.insert( it, g ); }
bool Realigner::addClippedBasesToTags(vector<CigarOp>& cigar_data, vector<MDelement>& MD_data, unsigned int nr_read_bases) const { // Restore left end of cigar string incl. original soft clips vector<CigarOp>::const_iterator cigar_it = (clipped_anchors_.cigar_left.end()-1); if (cigar_it->Type == cigar_data.begin()->Type) { cigar_data.begin()->Length += cigar_it->Length; cigar_it--; } else if (cigar_data.begin()->Type == 'S') { if (verbose_) cout << "Error, invalid cigar: Soft clipping occurred after left anchor!" << endl; return false; } while (cigar_it > clipped_anchors_.cigar_left.begin()) { if (cigar_it->Length > 0) cigar_data.insert(cigar_data.begin(), *cigar_it); cigar_it--; } if (cigar_it == clipped_anchors_.cigar_left.begin() and cigar_it->Length > 0) cigar_data.insert(cigar_data.begin(), *cigar_it); // Restore right end of cigar string incl. original soft clips cigar_it = clipped_anchors_.cigar_right.end()-1; if (cigar_it->Type == (cigar_data.end()-1)->Type) { (cigar_data.end()-1)->Length += cigar_it->Length; cigar_it--; } else if ((cigar_data.end()-1)->Type == 'S') { if (verbose_) cout << "Error, invalid cigar: Soft clipping occurred before right anchor!" << endl; return false; } while (cigar_it > clipped_anchors_.cigar_right.begin()) { if (cigar_it->Length > 0) cigar_data.push_back(*cigar_it); cigar_it--; } if (cigar_it == clipped_anchors_.cigar_right.begin() and cigar_it->Length > 0) cigar_data.push_back(*cigar_it); // Restore left end of MD tag vector<MDelement>::const_iterator md_it = clipped_anchors_.md_left.end()-1; if (clipped_anchors_.md_left.size() > 0) { if (md_it->Type[0] != '=') { if (verbose_) cout << "Error, invalid md tag: Left clipping MD does not end with a match field!" << endl; return false; } MD_data.begin()->Length += md_it->Length; md_it--; while (md_it != (clipped_anchors_.md_left.begin()-1)) { MD_data.insert(MD_data.begin(), *md_it); md_it--; } } // Restore right end of MD tag if (clipped_anchors_.md_right.size() > 0) { md_it = clipped_anchors_.md_right.end()-1; if (md_it->Type[0] != '=') { if (verbose_) cout << "Error, invalid md tag: Right clipping MD does not end with a match field!" << endl; return false; } (MD_data.end()-1)->Length += md_it->Length; md_it--; while (md_it != (clipped_anchors_.md_right.begin()-1)) { MD_data.push_back(*md_it); md_it--; } } // Sanity check for newly created tag: unsigned int nr_bases = 0; for (cigar_it = cigar_data.begin(); cigar_it != cigar_data.end(); cigar_it++) { if (cigar_it->Type == 'S' or cigar_it->Type == 'M' or cigar_it->Type == 'I' or cigar_it->Type == '=' or cigar_it->Type == 'X') nr_bases += cigar_it->Length; } if (nr_bases != nr_read_bases) { if (verbose_) cout << "Warning: generated an erroneous cigar string. Not updating alignment." << endl; return false; } if (verbose_){ cout << "New cigar tag:"; for (vector<CigarOp>::const_iterator cigar = cigar_data.begin(); cigar != cigar_data.end(); ++cigar) cout << cigar->Length << cigar->Type; cout << endl << "New MD tag : " << GetMDstring(MD_data) << endl; } return true; }
bool InstructionContext::MakeExecutable(LPCTSTR szFile, const void* data, size_t dataSize, size_t dataSpaceSize) { ////////////////////////////////////////////////////////////////////////// // Finalizing code section { // safety net const BYTE exitCode[] = { 0x31, 0xC9, //xor ecx, ecx 0xFF, 0x15, 0, 0, 0, 0, //call [] }; imports["kernel32.dll"]["ExitProcess"].push_back(section.size() + 4); section.insert(section.end(), std::begin(exitCode), std::end(exitCode)); } const size_t codeEnd = section.size(); section.push_back(0xCC); Align(section, 4, 0xCC); const size_t exceptionHandler = section.size(); { // exception handler const BYTE exitCode[] = { 0x48, 0x8D, 0x0D, 0x45, 0x57, 0x00, 0x00, //lea rcx,[] 0xFF, 0x15, 0xFF, 0xA4, 0x00, 0x00, //call qword ptr [] 0x31, 0xC9, //xor ecx, ecx 0xFF, 0x15, 0, 0, 0, 0, //call [] }; const size_t offset = section.size(); imports["msvcrt.dll"]["printf"].push_back(offset + 9); imports["kernel32.dll"]["ExitProcess"].push_back(offset + 17); strings["Error: exception catched\n"].push_back(offset + 3); section.insert(section.end(), std::begin(exitCode), std::end(exitCode)); } section.push_back(0xCC); Align(section, 4, 0xCC); // strings for (auto it(strings.begin()), itEnd(strings.end()); it != itEnd; ++it) { for each(auto offset in it->second) { uint32_t* pos = (uint32_t*) §ion[offset]; *pos = section.size() - sizeof(uint32_t) - offset; } BYTE* data = (BYTE*) it->first.c_str(); section.insert(section.end(), data, data + it->first.length() + 1); } section.push_back(0); Align(section, 16, 0); // imports map<vector<size_t>*, size_t> importNames; vector<IMAGE_IMPORT_DESCRIPTOR> importDescriptors(imports.size()); auto itDescriptor = importDescriptors.begin(); for (auto itModule(imports.begin()); itModule != imports.end(); ++itModule, ++itDescriptor) { for (auto it(itModule->second.begin()), itEnd(itModule->second.end()); it != itEnd; ++it) { importNames[&it->second] = SECTIONALIGN + section.size(); section.push_back(0); section.push_back(0); BYTE* data = (BYTE*) it->first.c_str(); section.insert(section.end(), data, data + it->first.length() + 1); } } Align(section, 16, 0); itDescriptor = importDescriptors.begin(); for (auto itModule(imports.begin()); itModule != imports.end(); ++itModule, ++itDescriptor) { itDescriptor->OriginalFirstThunk = SECTIONALIGN + section.size(); for (auto it(itModule->second.begin()), itEnd(itModule->second.end()); it != itEnd; ++it) { uint64_t th = importNames[&it->second]; section.insert(section.end(), (BYTE*)&th, (BYTE*)(&th + 1)); } section.insert(section.end(), sizeof(uint64_t), 0); } Align(section, 16, 0); itDescriptor = importDescriptors.begin(); for (auto itModule(imports.begin()); itModule != imports.end(); ++itModule, ++itDescriptor) { itDescriptor->FirstThunk = SECTIONALIGN + section.size(); for (auto it(itModule->second.begin()), itEnd(itModule->second.end()); it != itEnd; ++it) { for each(auto offset in it->second) { uint32_t* pos = (uint32_t*) §ion[offset]; *pos = section.size() - sizeof(uint32_t) - offset; } uint32_t th = importNames[&it->second]; section.insert(section.end(), (BYTE*)&th, (BYTE*)(&th + 1)); section.insert(section.end(), 4, 0); } } Align(section, 16, 0); itDescriptor = importDescriptors.begin(); for (auto itModule(imports.begin()); itModule != imports.end(); ++itModule, ++itDescriptor) { itDescriptor->Name = SECTIONALIGN + section.size(); BYTE* data = (BYTE*) itModule->first.c_str(); section.insert(section.end(), data, data + itModule->first.length() + 1); } Align(section, 16, 0); // Exceptions UNWIND_INFO_ unwindInfo = {}; unwindInfo.Ver3_Flags = 1 + (UNW_FLAG_EHANDLER << 3); const size_t unwindData = section.size(); section.insert(section.end(), (BYTE*)&unwindInfo, (BYTE*)(&unwindInfo + 1)); Align(section, 4, 0); uint64_t th = SECTIONALIGN + exceptionHandler; section.insert(section.end(), (BYTE*)&th, (BYTE*)(&th + 1)); section.insert(section.end(), sizeof(uint64_t), 0); Align(section, 16, 0); RUNTIME_FUNCTION_ runtimeFunction = {}; runtimeFunction.FunctionStart = SECTIONALIGN; // AddressOfEntryPoint runtimeFunction.FunctionEnd = SECTIONALIGN + codeEnd; runtimeFunction.UnwindInfo = SECTIONALIGN + unwindData; const size_t exceptionRuntimeFunction = section.size(); section.insert(section.end(), (BYTE*)&runtimeFunction, (BYTE*)(&runtimeFunction + 1)); Align(section, 16, 0); // Done with code section const size_t codeSectionSize = section.size() + importDescriptors.size() * sizeof(IMAGE_IMPORT_DESCRIPTOR); const size_t codeSectionVirtualSize = Align(codeSectionSize, SECTIONALIGN); // Data //dataMappings for (auto itMappings(dataMappings.begin()), itMappingsEnd(dataMappings.end()) ; itMappings != itMappingsEnd ; ++itMappings) { for (auto it(itMappings->second.begin()), itEnd(itMappings->second.end()); it != itEnd; ++it) { const size_t dataOffset = codeSectionVirtualSize + it->first; for each(auto offset in it->second) { uint32_t* pos = (uint32_t*) §ion[offset]; *pos = dataOffset - sizeof(uint32_t) - offset - itMappings->first; } } } ////////////////////////////////////////////////////////////////////////// // Preparing executable header structures Headers64 headers64 = {}; headers64.dosHeader.e_magic = 'ZM'; headers64.dosHeader.e_lfanew = offsetof(Headers64, ntHeaders); headers64.ntHeaders.Signature = 'EP'; auto& fileHeader = headers64.ntHeaders.FileHeader; fileHeader.Machine = IMAGE_FILE_MACHINE_AMD64; fileHeader.NumberOfSections = NUMBEROFSECTIONS; fileHeader.SizeOfOptionalHeader = sizeof(headers64.ntHeaders.OptionalHeader); fileHeader.Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE | IMAGE_FILE_32BIT_MACHINE; auto& optionalHeader = headers64.ntHeaders.OptionalHeader; optionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC; //optionalHeader.AddressOfEntryPoint = EntryPoint - IMAGEBASE; optionalHeader.ImageBase = IMAGEBASE; optionalHeader.SectionAlignment = SECTIONALIGN; optionalHeader.FileAlignment = FILEALIGN; optionalHeader.MajorSubsystemVersion = 4; optionalHeader.SizeOfImage = 2 * SECTIONALIGN; optionalHeader.SizeOfHeaders = sizeof(Headers64); optionalHeader.Subsystem = IMAGE_SUBSYSTEM_WINDOWS_CUI; optionalHeader.NumberOfRvaAndSizes = 16; headers64.sectionHeaders[0].Misc.VirtualSize = SECTIONALIGN; headers64.sectionHeaders[0].VirtualAddress = SECTIONALIGN; headers64.sectionHeaders[0].SizeOfRawData = FILEALIGN; headers64.sectionHeaders[0].PointerToRawData = FILEALIGN; headers64.sectionHeaders[0].Characteristics = IMAGE_SCN_MEM_EXECUTE;// | IMAGE_SCN_MEM_WRITE; headers64.sectionHeaders[1].Misc.VirtualSize = SECTIONALIGN; headers64.sectionHeaders[1].VirtualAddress = SECTIONALIGN; headers64.sectionHeaders[1].SizeOfRawData = FILEALIGN; headers64.sectionHeaders[1].PointerToRawData = FILEALIGN; headers64.sectionHeaders[1].Characteristics = IMAGE_SCN_MEM_WRITE; optionalHeader.AddressOfEntryPoint = SECTIONALIGN;// + section.size(); optionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress = section.size() + SECTIONALIGN; optionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress = exceptionRuntimeFunction + SECTIONALIGN; optionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size = sizeof(RUNTIME_FUNCTION_); // Fixing sizes headers64.sectionHeaders[0].Misc.VirtualSize = codeSectionVirtualSize; // headers64.sectionHeaders[0].SizeOfRawData = Align(codeSectionSize, FILEALIGN); headers64.sectionHeaders[1].VirtualAddress = headers64.sectionHeaders[0].VirtualAddress + headers64.sectionHeaders[0].Misc.VirtualSize; headers64.sectionHeaders[1].PointerToRawData = headers64.sectionHeaders[0].PointerToRawData + headers64.sectionHeaders[0].SizeOfRawData; assert(dataSize <= dataSpaceSize); headers64.sectionHeaders[1].Misc.VirtualSize = Align(REGISTER_TABLE_SIZE + dataSpaceSize, SECTIONALIGN); // headers64.sectionHeaders[1].SizeOfRawData = (dataSize > 0) ? Align(REGISTER_TABLE_SIZE + dataSize, FILEALIGN) : 0; optionalHeader.SizeOfImage = SECTIONALIGN + headers64.sectionHeaders[0].Misc.VirtualSize + headers64.sectionHeaders[1].Misc.VirtualSize; ////////////////////////////////////////////////////////////////////////// // Writing exe image HANDLE handle = CreateFile( szFile, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_FLAG_SEQUENTIAL_SCAN, NULL); if (handle == INVALID_HANDLE_VALUE) { cerr << "Cannot create exe file.\n"; return false; } LARGE_INTEGER size; size.QuadPart = FILEALIGN + headers64.sectionHeaders[0].SizeOfRawData + headers64.sectionHeaders[1].SizeOfRawData; SetFilePointerEx(handle, size, 0, FILE_BEGIN); SetEndOfFile(handle); SetFilePointer(handle, 0, 0, FILE_BEGIN); DWORD numberOfBytesWritten = 0; WriteFile(handle, &headers64, sizeof(headers64), &numberOfBytesWritten, NULL); SetFilePointer(handle, FILEALIGN, 0, FILE_BEGIN); WriteFile(handle, section.data(), section.size(), &numberOfBytesWritten, NULL); WriteFile( handle, importDescriptors.data(), importDescriptors.size() * sizeof(IMAGE_IMPORT_DESCRIPTOR), &numberOfBytesWritten, NULL); // handle data if (dataSize > 0) { SetFilePointer(handle, FILEALIGN + headers64.sectionHeaders[0].SizeOfRawData + REGISTER_TABLE_SIZE, 0, FILE_BEGIN); WriteFile(handle, data, dataSize, &numberOfBytesWritten, NULL); } CloseHandle(handle); return true; }
bool ReadStarRecord(istream& in) { HipparcosStar star; char buf[HipStarRecordLength]; in.read(buf, HipStarRecordLength); if (sscanf(buf + 2, "%d", &star.HIPCatalogNumber) != 1) { cout << "Error reading catalog number.\n"; return false; } sscanf(buf + 390, "%d", &star.HDCatalogNumber); if (sscanf(buf + 41, "%f", &star.appMag) != 1) { cout << "Error reading magnitude.\n"; return false; } if (sscanf(buf + 79, "%f", &star.parallax) != 1) { // cout << "Error reading parallax.\n"; } bool coordReadError = false; if (sscanf(buf + 51, "%f", &star.ascension) != 1) coordReadError = true; if (sscanf(buf + 64, "%f", &star.declination) != 1) coordReadError = true; star.ascension = (float) (star.ascension * 24.0 / 360.0); // Read the lower resolution coordinates in hhmmss form if we failed // to read the coordinates in degrees. Not sure why the high resolution // coordinates are occasionally missing . . . if (coordReadError) { int hh = 0; int mm = 0; float seconds; if (sscanf(buf + 17, "%d %d %f", &hh, &mm, &seconds) != 3) { cout << "Error reading ascension.\n"; return false; } star.ascension = hh + (float) mm / 60.0f + (float) seconds / 3600.0f; char decSign; int deg; if (sscanf(buf + 29, "%c%d %d %f", &decSign, °, &mm, &seconds) != 4) { cout << "Error reading declination.\n"; return false; } star.declination = deg + (float) mm / 60.0f + (float) seconds / 3600.0f; if (decSign == '-') star.declination = -star.declination; } char* spectralType = buf + 435; spectralType[12] = '\0'; star.stellarClass = ParseStellarClass(spectralType); int asc = 0; int dec = 0; char decSign = ' '; if (sscanf(buf + 327, "%d%c%d", &asc, &decSign, &dec) == 3) { if (decSign == '-') dec = -dec; star.CCDMIdentifier = asc << 16 | (dec & 0xffff); int n = 1; sscanf(buf + 340, "%d", &n); star.starsWithCCDM = (uint8) n; sscanf(buf + 343, "%d", &n); star.nComponents = (uint8) n; } float parallaxError = 0.0f; if (sscanf(buf + 119, "%f", ¶llaxError) != 0) { if (star.parallax < 0.0f || parallaxError / star.parallax > 1.0f) star.parallaxError = (int8) 255; else star.parallaxError = (int8) (parallaxError / star.parallax * 200); } stars.insert(stars.end(), star); return true; }
bool DevEffect::GetPrecompiledBinary( vector<char> &data, const char *id, const char *path, const char *bpath, vector<D3DXMACRO> ¯os, byte hash[16], vector<byte> &bin) { ID3DXEffectCompiler *fxc = NULL; ID3DXBuffer *binbuff = NULL; ID3DXBuffer *errors = NULL; if(_load_scrambled(bpath,*(vector<byte>*)&bin) && bin.size()>16) { if(memcmp(&bin[0],hash,16)==0) { bin.erase(bin.begin(),bin.begin()+16); return true; } } for(int pass=0;pass<2;pass++) { HRESULT r; bool error; if( pass == 0 ) { r = D3DXCreateEffectCompiler(&data[0],(DWORD)data.size(),¯os[0],NULL, compile_flags,&fxc,&errors); error = !fxc; } else { r = fxc->CompileEffect(compile_flags,&binbuff,&errors); error = !binbuff; } if(FAILED(r) || errors || error) { if(errors) { last_error = format("%s:%s: %s",path,id,(char*)errors->GetBufferPointer()); if(!(flags&FXF_NO_ERROR_POPUPS)) if(MessageBox(NULL,last_error.c_str(),format("%s:%s",path,id).c_str(),MB_OKCANCEL)==IDCANCEL) ExitProcess(0); errors->Release(); if(fxc) fxc->Release(); if(binbuff) binbuff->Release(); return false; } else { last_error = format("%s:%s: Unknown error!",path,id); if(!(flags&FXF_NO_ERROR_POPUPS)) if(MessageBox(NULL,last_error.c_str(),format("%s:%s",path,id).c_str(),MB_OKCANCEL)==IDCANCEL) ExitProcess(0); if(fxc) fxc->Release(); if(binbuff) binbuff->Release(); return false; } } } bin.clear(); bin.insert(bin.end(),hash,hash+16); bin.insert(bin.end(),(byte*)binbuff->GetBufferPointer(),((byte*)binbuff->GetBufferPointer())+binbuff->GetBufferSize()); fxc->Release(); binbuff->Release(); _save_scrambled(bpath,bin); bin.erase(bin.begin(),bin.begin()+16); return true; }
bool InstructionContext::AddInstruction( BYTE instruction, signed char dst, signed char src, size_t instructionNumber, uint32_t dataSize) { const size_t offset = section.size(); trace("%4d ", instructionNumber); switch (instruction) { case 32: trace("NOP\n"); break; // nop case 40: // IN reg read hexadecimal value from standard input, and store in registry reg reg <- stdin { trace("IN reg%d <- stdin\n", dst); VERIFY_REGISTER_IDX (dst); const BYTE scanCode[] = { 0x48, 0x8D, 0x15, 0x18, 0x81, 0x00, 0x00, //lea rdx,[] 0x48, 0x8D, 0x0D, 0x51, 0x57, 0x00, 0x00, //lea rcx,[] 0xFF, 0x15, 0x0B, 0xA5, 0x00, 0x00, //call qword ptr [] 0x85, 0xC0, //test eax,eax 0x75, 0x15, //jne 0x48, 0x8D, 0x0D, 0x45, 0x57, 0x00, 0x00, //lea rcx,[] 0xFF, 0x15, 0xFF, 0xA4, 0x00, 0x00, //call qword ptr [] 0x31, 0xC9, //xor ecx, ecx 0xFF, 0x15, 0, 0, 0, 0, //call [] }; dataMappings[0][REGISTER_SIZE * dst].push_back(offset + 3); imports["msvcrt.dll"]["scanf"].push_back(offset + 16); strings["%I64X"].push_back(offset + 10); imports["msvcrt.dll"]["printf"].push_back(offset + 9 + 24); imports["kernel32.dll"]["ExitProcess"].push_back(offset + 17 + 24); strings["Error: Unable to read stdin\n"].push_back(offset + 3 + 24); section.insert(section.end(), std::begin(scanCode), std::end(scanCode)); } break; case 41: // OUT reg write hexadecimal value in registry reg to standard output stdout <- reg { trace("OUT stdout <- reg%d\n", dst); VERIFY_REGISTER_IDX (dst); const BYTE printCode[] = { 0x48, 0x8B, 0x15, 0x04, 0x81, 0x00, 0x00, //mov rdx,qword ptr [] 0x48, 0x8D, 0x0D, 0x45, 0x57, 0x00, 0x00, //lea rcx,[] 0xFF, 0x15, 0xFF, 0xA4, 0x00, 0x00, //call qword ptr [] }; imports["msvcrt.dll"]["printf"].push_back(offset + 16); strings["%016I64X\n"].push_back(offset + 10); dataMappings[0][REGISTER_SIZE * dst].push_back(offset + 3); section.insert(section.end(), std::begin(printCode), std::end(printCode)); } break; case 48: // STORE reg1,reg2 store value of reg2 in memory cell pointed by reg1 [reg1] = reg2 { trace("STORE [reg%d] = reg%d\n", dst, src); if (dataSize < REGISTER_SIZE) { cerr << "Error: dataSize is too small\n"; return false; } VERIFY_REGISTER_IDX (src); VERIFY_REGISTER_IDX (dst); const BYTE code[] = { 0x48, 0x8D, 0x05, 0x0D, 0x81, 0x00, 0x00, //lea rax,[] 0x48, 0x8B, 0x0D, 0x0E, 0x85, 0x00, 0x00, //mov rcx,qword ptr [] 0x48, 0x81, 0xF9, 0x10, 0x27, 0x00, 0x00, //cmp rcx,0x2710 0x7E, 0x15, //jle 0x48, 0x8D, 0x0D, 0x45, 0x57, 0x00, 0x00, //lea rcx,[] 0xFF, 0x15, 0xFF, 0xA4, 0x00, 0x00, //call qword ptr [] 0x31, 0xC9, //xor ecx, ecx 0xFF, 0x15, 0, 0, 0, 0, //call [] 0x48, 0x8B, 0x15, 0xFF, 0x84, 0x00, 0x00, //mov rdx,qword ptr [] 0x48, 0x89, 0x14, 0x08, //mov qword ptr [rax+rcx],rdx }; dataMappings[0][REGISTER_TABLE_SIZE].push_back(offset + 3); dataMappings[0][REGISTER_SIZE * dst].push_back(offset + 10); imports["msvcrt.dll"]["printf"].push_back(offset + 9 + 23); imports["kernel32.dll"]["ExitProcess"].push_back(offset + 17 + 23); strings["Error: Runtime memory offset out of bounds\n"].push_back(offset + 3 + 23); dataMappings[0][REGISTER_SIZE * src].push_back(offset + 17 + 30); section.insert(section.end(), std::begin(code), std::end(code)); uint32_t* pos = (uint32_t*) §ion[offset + 17]; *pos = dataSize - REGISTER_SIZE; } break; case 49: // LOAD reg1, reg2 load value from memory cell pointed by reg1 into register reg2 reg1 = [reg2] { trace("LOAD reg%d = [reg%d]\n", dst, src); if (dataSize < REGISTER_SIZE) { cerr << "Error: dataSize is too small\n"; return false; } VERIFY_REGISTER_IDX (src); VERIFY_REGISTER_IDX (dst); const BYTE code[] = { 0x48, 0x8D, 0x05, 0x0D, 0x81, 0x00, 0x00, //lea rax,[] 0x48, 0x8B, 0x0D, 0x0E, 0x85, 0x00, 0x00, //mov rcx,qword ptr [] 0x48, 0x81, 0xF9, 0x10, 0x27, 0x00, 0x00, //cmp rcx,0x2710 0x7E, 0x15, //jle 0x48, 0x8D, 0x0D, 0x45, 0x57, 0x00, 0x00, //lea rcx,[] 0xFF, 0x15, 0xFF, 0xA4, 0x00, 0x00, //call qword ptr [] 0x31, 0xC9, //xor ecx, ecx 0xFF, 0x15, 0, 0, 0, 0, //call [] 0x48, 0x8B, 0x04, 0x08, //mov rax,qword ptr [rax+rcx] 0x48, 0x89, 0x05, 0xFB, 0x84, 0x00, 0x00, //mov qword ptr [],rax }; dataMappings[0][REGISTER_TABLE_SIZE].push_back(offset + 3); dataMappings[0][REGISTER_SIZE * src].push_back(offset + 10); imports["msvcrt.dll"]["printf"].push_back(offset + 9 + 23); imports["kernel32.dll"]["ExitProcess"].push_back(offset + 17 + 23); strings["Error: Runtime memory offset out of bounds\n"].push_back(offset + 3 + 23); dataMappings[0][REGISTER_SIZE * dst].push_back(offset + 21 + 30); section.insert(section.end(), std::begin(code), std::end(code)); uint32_t* pos = (uint32_t*) §ion[offset + 17]; *pos = dataSize - REGISTER_SIZE; } break; case 50: // LDC reg, imm8 load 8-bit immediate value to reg reg = imm8 (unsigned) { const uint32_t imm = unsigned char(src); trace("LDC reg%d = %d\n", dst, imm); VERIFY_REGISTER_IDX (dst); const BYTE code[] = { 0x48, 0xC7, 0x05, 0xDC, 0x66, 0x00, 0x00, //mov qword ptr [value (140009558h)], ... }; dataMappings[4][REGISTER_SIZE * dst].push_back(offset + 3); section.insert(section.end(), std::begin(code), std::end(code)); section.insert(section.end(), (const BYTE*)&imm, (const BYTE*)(&imm + 1)); } break; case 64: // MOV reg1, reg2 copy value from register2 to register1 reg1 = reg2 { trace("MOV reg%d = reg%d\n", dst, src); VERIFY_REGISTER_IDX (src); VERIFY_REGISTER_IDX (dst); const BYTE code[] = { 0x48, 0x8B, 0x05, 0xD5, 0x66, 0x00, 0x00, //mov rax,qword ptr [] 0x48, 0x89, 0x05, 0xC6, 0x66, 0x00, 0x00, //mov qword ptr [],rax }; dataMappings[0][REGISTER_SIZE * src].push_back(offset + 3); dataMappings[0][REGISTER_SIZE * dst].push_back(offset + 10); section.insert(section.end(), std::begin(code), std::end(code)); } break; case 65: // ADD reg1, reg2 add value of reg2 to reg1, and save result in reg1 reg1 = reg1 + reg2 { trace("ADD reg%d += reg%d\n", dst, src); VERIFY_REGISTER_IDX (src); VERIFY_REGISTER_IDX (dst); const BYTE code[] = { 0x48, 0x8B, 0x05, 0xD5, 0x66, 0x00, 0x00, //mov rax,qword ptr [] 0x48, 0x8B, 0x0D, 0xC6, 0x66, 0x00, 0x00, //mov rcx,qword ptr [] 0x48, 0x03, 0xC8, //add rcx,rax 0x48, 0x8B, 0xC1, //mov rax,rcx 0x48, 0x89, 0x05, 0xB9, 0x66, 0x00, 0x00, //mov qword ptr [],rax }; dataMappings[0][REGISTER_SIZE * src].push_back(offset + 3); dataMappings[0][REGISTER_SIZE * dst].push_back(offset + 10); dataMappings[0][REGISTER_SIZE * dst].push_back(offset + 23); section.insert(section.end(), std::begin(code), std::end(code)); } break; case 66: // SUB reg1, reg2 subtract value of reg2 from reg1, and save result in reg1 { trace("SUB reg%d -= reg%d\n", dst, src); VERIFY_REGISTER_IDX (src); VERIFY_REGISTER_IDX (dst); const BYTE code[] = { 0x48, 0x8B, 0x05, 0xD5, 0x66, 0x00, 0x00, //mov rax,qword ptr [] 0x48, 0x8B, 0x0D, 0xC6, 0x66, 0x00, 0x00, //mov rcx,qword ptr [] 0x48, 0x2B, 0xC8, //sub rcx,rax 0x48, 0x8B, 0xC1, //mov rax,rcx 0x48, 0x89, 0x05, 0xB9, 0x66, 0x00, 0x00, //mov qword ptr [],rax }; dataMappings[0][REGISTER_SIZE * src].push_back(offset + 3); dataMappings[0][REGISTER_SIZE * dst].push_back(offset + 10); dataMappings[0][REGISTER_SIZE * dst].push_back(offset + 23); section.insert(section.end(), std::begin(code), std::end(code)); } break; case 67: // MUL reg1, reg2 multiplies value of reg1 by value of reg2 and save result in reg1 reg1 = reg1 * reg2 { trace("MUL reg%d *= reg%d\n", dst, src); VERIFY_REGISTER_IDX (src); VERIFY_REGISTER_IDX (dst); const BYTE code[] = { 0x48, 0x8B, 0x05, 0x97, 0x66, 0x00, 0x00, //mov rax,qword ptr [] 0x48, 0x0F, 0xAF, 0x05, 0x97, 0x66, 0x00, 0x00, //imul rax,qword ptr [] 0x48, 0x89, 0x05, 0x88, 0x66, 0x00, 0x00, //mov qword ptr [],rax }; dataMappings[0][REGISTER_SIZE * dst].push_back(offset + 3); dataMappings[0][REGISTER_SIZE * src].push_back(offset + 11); dataMappings[0][REGISTER_SIZE * dst].push_back(offset + 18); section.insert(section.end(), std::begin(code), std::end(code)); } break; case 68: // DIV reg1, reg2 divides value of reg1 by value of reg2 and save result in reg1 reg1 = reg1 / reg2 { trace("DIV reg%d /= reg%d\n", dst, src); VERIFY_REGISTER_IDX (src); VERIFY_REGISTER_IDX (dst); const BYTE code[] = { 0x48, 0x8B, 0x05, 0x81, 0x66, 0x00, 0x00, //mov rax,qword ptr [] 0x48, 0x99, //cqo 0x48, 0xF7, 0x3D, 0x80, 0x66, 0x00, 0x00, //idiv rax,qword ptr [] 0x48, 0x89, 0x05, 0x71, 0x66, 0x00, 0x00, //mov qword ptr [],rax }; dataMappings[0][REGISTER_SIZE * dst].push_back(offset + 3); dataMappings[0][REGISTER_SIZE * src].push_back(offset + 12); dataMappings[0][REGISTER_SIZE * dst].push_back(offset + 19); section.insert(section.end(), std::begin(code), std::end(code)); } break; case 69: // MOD reg1, reg2 calculates reminder of division of reg1 by reg2 and save result in reg1 reg1 = reg1 % reg2 { trace("MOD reg%d %%= reg%d\n", dst, src); VERIFY_REGISTER_IDX (src); VERIFY_REGISTER_IDX (dst); const BYTE code[] = { 0x48, 0x8B, 0x05, 0x6A, 0x66, 0x00, 0x00, //mov rax,qword ptr [] 0x48, 0x99, //cqo 0x48, 0xF7, 0x3D, 0x69, 0x66, 0x00, 0x00, //idiv rax,qword ptr [] 0x48, 0x8B, 0xC2, //mov rax,rdx 0x48, 0x89, 0x05, 0x57, 0x66, 0x00, 0x00, //mov qword ptr [],rax }; dataMappings[0][REGISTER_SIZE * dst].push_back(offset + 3); dataMappings[0][REGISTER_SIZE * src].push_back(offset + 12); dataMappings[0][REGISTER_SIZE * dst].push_back(offset + 22); section.insert(section.end(), std::begin(code), std::end(code)); } break; case 97: //JZ reg, imm8 if value of reg is zero, does relative jump. if reg1 == 0: IP = IP + imm8 { trace("JZ reg%d, %d\n", dst, src + instructionNumber + 1); VERIFY_REGISTER_IDX (dst); const BYTE code[] = { 0x48, 0x83, 0x3D, 0xCC, 0x66, 0x00, 0x00, 0x00, //cmp qword ptr [],0 0x75, 0x05, //jne 0xE9, 0x45, 0x01, 0x00, 0x00, //jmp $ }; dataMappings[1][REGISTER_SIZE * dst].push_back(offset + 3); jumps[instructionNumber + src].push_back(offset + 11); section.insert(section.end(), std::begin(code), std::end(code)); } break; case 98: //JL reg, imm8 if value of reg is less then zero, does relative jump. if reg1 < 0: IP = IP + imm8 { trace("JL reg%d, %d\n", dst, src + instructionNumber + 1); VERIFY_REGISTER_IDX (dst); const BYTE code[] = { 0x48, 0x83, 0x3D, 0xCC, 0x66, 0x00, 0x00, 0x00, //cmp qword ptr [],0 0x7D, 0x05, //jge 0xE9, 0x45, 0x01, 0x00, 0x00, //jmp $ }; dataMappings[1][REGISTER_SIZE * dst].push_back(offset + 3); jumps[instructionNumber + src].push_back(offset + 11); section.insert(section.end(), std::begin(code), std::end(code)); } break; case 99: //JUMP imm16 unconditional relative jump by imm16. IP = IP + imm16 { short imm16 = (short)MAKEWORD(dst, src); trace("JUMP %d\n", imm16 + instructionNumber + 1); const BYTE code[] = { 0xE9, 0x45, 0x01, 0x00, 0x00, //jmp $ }; jumps[instructionNumber + imm16].push_back(offset + 1); section.insert(section.end(), std::begin(code), std::end(code)); } break; case 100: // CALL imm16 stores next instruction pointer on internal stack and jumps by imm16. // save IP of next instruction to call stack JMP imm16 { short imm16 = (short)MAKEWORD(dst, src); trace("CALL %d\n", imm16 + instructionNumber + 1); const BYTE code[] = { 0xE8, 0x12, 0x00, 0x00, 0x00, //call }; jumps[instructionNumber + imm16].push_back(offset + 1); section.insert(section.end(), std::begin(code), std::end(code)); } break; case 101: //RET reads absolute instruction pointer from stack and jumps to it (returns to next instruction after corresponding CALL) // restore IP from call stack IP = saved_IP { trace("RET\n"); section.push_back(0xC3); // ret } break; case 126: // HLT ends program, terminates execution { trace("HLT\n"); const BYTE exitCode[] = { 0x31, 0xC9, //xor ecx, ecx 0xFF, 0x15, 0, 0, 0, 0, //call [] }; imports["kernel32.dll"]["ExitProcess"].push_back(offset + 4); section.insert(section.end(), std::begin(exitCode), std::end(exitCode)); } break; default: cerr << "Invalid instruction code.\n"; return false; } return true; }
void CodeGenerator::appendVectors(vector<string>& v1, vector<string> v2) { v1.reserve(v1.size() + v2.size()); v1.insert(v1.end(), v2.begin(), v2.end()); }
void intersect2Dcurves(const ParamCurve* cv1, const ParamCurve* cv2, double epsge, vector<pair<double,double> >& intersections, vector<int>& pretopology, vector<pair<pair<double,double>, pair<double,double> > >& int_crvs) //************************************************************************ // // Intersect two 2D spline curves. Collect intersection parameters // and pretopology information. // //*********************************************************************** { // First make sure that the curves are spline curves. ParamCurve* tmpcv1 = const_cast<ParamCurve*>(cv1); ParamCurve* tmpcv2 = const_cast<ParamCurve*>(cv2); SplineCurve* sc1 = tmpcv1->geometryCurve(); SplineCurve* sc2 = tmpcv2->geometryCurve(); if (sc1 == NULL || sc2 == NULL) THROW("ParamCurves doesn't have a spline representation."); MESSAGE_IF(cv1->dimension() != 2, "Dimension different from 2, pretopology not reliable."); // Make sisl curves and call sisl. SISLCurve *pc1 = Curve2SISL(*sc1, false); SISLCurve *pc2 = Curve2SISL(*sc2, false); int kntrack = 0; int trackflag = 0; // Do not make tracks. SISLTrack **track =0; int knpt=0, kncrv=0; double *par1=0, *par2=0; int *pretop = 0; SISLIntcurve **vcrv = 0; int stat = 0; sh1857(pc1, pc2, 0.0, epsge, trackflag, &kntrack, &track, &knpt, &par1, &par2, &pretop, &kncrv, &vcrv, &stat); ALWAYS_ERROR_IF(stat<0,"Error in intersection, code: " << stat); // Remember intersections points. int ki; for (ki=0; ki<knpt; ki++) { intersections.push_back(std::make_pair(par1[ki],par2[ki])); pretopology.insert(pretopology.end(), pretop+4*ki, pretop+4*(ki+1)); } // Remember intersection curves for (ki=0; ki<kncrv; ++ki) int_crvs.push_back(std::make_pair(std::make_pair(vcrv[ki]->epar1[0], vcrv[ki]->epar2[0]), std::make_pair(vcrv[ki]->epar1[vcrv[ki]->ipoint-1], vcrv[ki]->epar2[vcrv[ki]->ipoint-1]))); if (kncrv > 0) freeIntcrvlist(vcrv, kncrv); if (par1 != 0) free(par1); if (par2 != 0) free(par2); if (pc1 != 0) freeCurve(pc1); if (pc2 != 0) freeCurve(pc2); if (pretop != 0) free(pretop); delete sc1; delete sc2; }
int main(int argc, char *argv[]) { //get the initial coordinate positions for(int i = 0; i < argc; i++) { if(argv[i][0] == '+') { sscanf(argv[i], "+%d,%d,%d", &cur_file_posy, &cury, &curx); } } //create interrupt ^C to break signal(SIGINT, finish); //initialize library initscr(); if(has_colors()) { start_color(); init_pair(1, COLOR_GREEN, COLOR_BLACK); init_pair(2, COLOR_BLACK, COLOR_WHITE); attron(COLOR_PAIR(1)); } //enable keyboard mapping keypad(stdscr, TRUE); //do not convert \n to \r\n nonl(); //take input one character at a time and do not wait for \n cbreak(); //disable automatic echo noecho(); idlok(stdscr, TRUE); scrollok(stdscr, TRUE); //keep track of the current mode it_mode_t mode = mode_base; getmaxyx(stdscr, winy, winx); winy = winy - footer_height; //get the buffer_lines from the program string istringstream program_str_stream(program_str); string line; while(getline(program_str_stream, line)) { program_lines.push_back(line); } buffer_lines.insert(buffer_lines.begin(), program_lines.begin(), program_lines.end()); //ensure our specified initial starting coordinates do not go past the max if(cur_file_posy > buffer_lines.size()-1) { cur_file_posy = buffer_lines.size()-1; } if(cury > cur_file_posy) { cury = cur_file_posy; } if(curx > buffer_lines[cur_file_posy].size()) { curx = buffer_lines[cur_file_posy].size(); } //print the screen with the program string rewrite_buffer(cur_file_posy, curx, cury); //get the initial coordinate positions for(int i = 0; i < argc; i++) { string arg = argv[i]; if(arg == "-r") { move(winy+1, 0); attron(COLOR_PAIR(2)); addstr("REWRITE SUCCESS"); attron(COLOR_PAIR(1)); move(cury, curx); } } //infinitely loop over getting input int buffer_contents = it_buffer_program; for(;;) { getyx(stdscr, cury, curx); getmaxyx(stdscr, winy, winx); winy = winy - footer_height; switch(mode) { case mode_base: { int c = getch(); //enter insert mode if(c == 'i') { if(buffer_contents == it_buffer_program) { mode = mode_insert; } } //quit else if(c == 'q') { finish(0); } //rewrite the program else if(c == 'w') { //save the buffer into the lines of the program program_lines.clear(); program_lines.insert(program_lines.begin(), buffer_lines.begin(), buffer_lines.end()); //recreate the program string program_str = ""; for(auto line : program_lines) { program_str += line + '\n'; } rewrite_program(program_str, &compile_output); //determine and show the result if(compile_output.size() > 0) { move(winy+1, 0); attron(COLOR_PAIR(2)); addstr("REWRITE ERROR: type 'o' in command mode to see the output"); attron(COLOR_PAIR(1)); move(cury, curx); } else { move(winy+1, 0); addstr("REWRITE SUCCESS"); move(cury, curx); string restart_str = "./it +" + to_string(cur_file_posy) + "," + to_string(cury) + "," + to_string(curx) + " -r"; system(restart_str.c_str()); finish(0); } } //show compile output else if(c == 'o') { if(buffer_contents == it_buffer_program) { program_lines.clear(); program_lines.insert(program_lines.begin(), buffer_lines.begin(), buffer_lines.end()); buffer_lines.clear(); buffer_lines.insert(buffer_lines.begin(), compile_output.begin(), compile_output.end()); buffer_contents = it_buffer_compile_output; pcury = cury; pcurx = curx; p_start_posy = cur_file_posy; rewrite_buffer(0, 0, 0); } else if(buffer_contents == it_buffer_compile_output) { buffer_lines.clear(); buffer_lines.insert(buffer_lines.begin(), program_lines.begin(), program_lines.end()); buffer_contents = it_buffer_program; cury = pcury; curx = pcurx; rewrite_buffer(p_start_posy, curx, cury); } } //save to file else if(c == 's') { FILE *fp = fopen("main.cpp", "w"); for(auto line : buffer_lines) { string newline = line + "\n"; fwrite(newline.c_str(), sizeof(char), newline.size(), fp); } } //move the cursor around with hjkl else if(c == 'h' || c == 'j' || c == 'k' || c == 'l') { //remove any messages move(winy+footer_height-1, 0); clrtoeol(); if(c == 'h') { if(cur_file_posx > 0) { cur_file_posx = curx-1; curx = cur_file_posx; } } else if(c == 'j') { if(cury < min(winy-1, buffer_lines.size()-1)) { cur_file_posy++; cury++; } else if(cur_file_posy < buffer_lines.size()-1) { scroll(stdscr); cur_file_posy++; move(cury, 0); addstr(buffer_lines[cur_file_posy].c_str()); } //ensure we are placed correctly on the x axis curx = cur_file_posx; } else if(c == 'k') { if(cury > 0) { cur_file_posy--; cury--; } else if(cur_file_posy > 0) { scrl(-1); cur_file_posy--; move(cury, 0); addstr(buffer_lines[cur_file_posy].c_str()); } //clear the footer lines for(int i = winy; i < winy+footer_height; i++) { move(i, 0); clrtoeol(); } //ensure we are placed correctly on the x axis curx = cur_file_posx; } else if(c == 'l') { if(curx < winx) { cur_file_posx = curx+1; curx = cur_file_posx; } } //restrict the cursor's x coordinate to the length of the string if(curx >= buffer_lines[cur_file_posy].size()) { curx = buffer_lines[cur_file_posy].size(); } move(cury, curx); } break; } case mode_insert: { int c = getch(); //go back to base mode if(c == 27) { mode = mode_base; } //handle newlines by scrolling up and splitting buffer_lines else if(c == '\r') { string line_start = buffer_lines[cur_file_posy].substr(0, curx); string line_end = buffer_lines[cur_file_posy].substr(curx, buffer_lines[cur_file_posy].size()-curx); //rewrite the current line buffer_lines[cur_file_posy] = line_start; clrtoeol(); //add the new line buffer_lines.insert(buffer_lines.begin()+cur_file_posy+1, line_end); //reprint all the buffer_lines after for(int i = cur_file_posy+1; i < buffer_lines.size(); i++) { if(cury+i-cur_file_posy >= winy) { break; } move(cury+i-cur_file_posy, 0); clrtoeol(); addstr(buffer_lines[i].c_str()); } //move the cursor down the cursor cur_file_posy++; cury++; //scroll if the cursor passed the screen move(cury, 0); if(cury >= winy) { scroll(stdscr); cury = winy-1; move(cury, 0); addstr(buffer_lines[cur_file_posy].c_str()); move(cury, 0); } } //delete or backspace else if(c == 127 || c == 8) { if(curx > 0) { string line = buffer_lines[cur_file_posy]; buffer_lines[cur_file_posy] = line.substr(0, curx-1) + line.substr(curx, line.size()-curx); cur_file_posx--; curx--; move(cury, curx); delch(); } else if(cur_file_posy > 0) { int new_posx = buffer_lines[cur_file_posy-1].size(); string bigger_line = buffer_lines[cur_file_posy-1] + buffer_lines[cur_file_posy]; buffer_lines[cur_file_posy-1] = bigger_line; buffer_lines.erase(buffer_lines.begin()+cur_file_posy); if(cury > 0) { //reprint all buffer_lines after for(int i = cur_file_posy-1; i < buffer_lines.size(); i++) { if(cury+i-cur_file_posy >= winy) { break; } move(cury+i-cur_file_posy, 0); clrtoeol(); addstr(buffer_lines[i].c_str()); } //move the cursor cur_file_posy--; cury--; move(cury, new_posx); cur_file_posx = new_posx; } else { move(cury, 0); clrtoeol(); addstr(buffer_lines[cur_file_posy].c_str()); move(cury, new_posx); cur_file_posx = new_posx; } } } //regular character else { //add the character to the line string line_end = (char)c + buffer_lines[cur_file_posy].substr(curx, buffer_lines[cur_file_posy].size()-curx); buffer_lines[cur_file_posy] = buffer_lines[cur_file_posy].substr(0, curx) + line_end; move(cury, curx); addstr(line_end.c_str()); curx++; cur_file_posx = curx; move(cury, curx); } break; } } } finish(0); return 0; }
//Subdivide the empty voxels into cells. void PVSGenerator::generateCellsFromEmptyVoxelsUsingTiles( VoxelContainer& voxelContainer, vector<shared_ptr<Cell>>& cells ) const { Point3i minVoxelPoint, maxVoxelPoint; int lastProgress = 0; int progress; int tileIndex; int expectedEmptyVoxels; int numberOfVoxelsInsideCell; int cellsCreated = 0; int cellsCreatedForTile = 0; int tilesProcessed=0; SceneTile* currentTile; try { //Process the SceneTiles in parallel. Each one has it's own collection of Cells and can read the voxel container concurrently. #pragma omp parallel for private(currentTile, tileIndex, expectedEmptyVoxels, minVoxelPoint, maxVoxelPoint, numberOfVoxelsInsideCell, cellsCreatedForTile ) shared(lastProgress, voxelContainer, cells, progress, cellsCreated, tilesProcessed) for( tileIndex = 0 ; tileIndex < (int) m_sceneTiles.size() ; ++tileIndex) { currentTile = (m_sceneTiles[tileIndex]).get(); cellsCreatedForTile = 0; //How many empty voxels are we expecting to have in this tile. expectedEmptyVoxels = currentTile->getNumberOfVoxelsInside() - currentTile->getNumberOfSolidVoxelsInside(); //If all the Tile is solid, don't generate a cell. if( expectedEmptyVoxels == 0 ) continue; //Do while there are no pending empty voxels left in the tile while ( expectedEmptyVoxels > 0 ) { //Take first seed voxel index. minVoxelPoint = maxVoxelPoint = findSeedPointInTile( *currentTile, voxelContainer ); //Expand the cell until there is something that blocks the growth in that direction, then continue with the other directions. testExpansion( minVoxelPoint, maxVoxelPoint, VoxelContainer::POSITIVE_X, voxelContainer, *currentTile ); testExpansion( minVoxelPoint, maxVoxelPoint, VoxelContainer::POSITIVE_Y, voxelContainer, *currentTile ); testExpansion( minVoxelPoint, maxVoxelPoint, VoxelContainer::POSITIVE_Z, voxelContainer, *currentTile ); testExpansion( minVoxelPoint, maxVoxelPoint, VoxelContainer::NEGATIVE_X, voxelContainer, *currentTile ); testExpansion( minVoxelPoint, maxVoxelPoint, VoxelContainer::NEGATIVE_Y, voxelContainer, *currentTile ); testExpansion( minVoxelPoint, maxVoxelPoint, VoxelContainer::NEGATIVE_Z, voxelContainer, *currentTile ); //Calculate how many voxels are inside the cell found. numberOfVoxelsInsideCell = (maxVoxelPoint.x - minVoxelPoint.x + 1) * (maxVoxelPoint.y - minVoxelPoint.y + 1) * (maxVoxelPoint.z - minVoxelPoint.z + 1); //Expect less voxels to explore. expectedEmptyVoxels -= numberOfVoxelsInsideCell; //Create the cell and add it to the Tile. currentTile->addCell( shared_ptr<Cell>(new Cell(minVoxelPoint, maxVoxelPoint ) )); cellsCreatedForTile++; } //Show progress on the log. #pragma omp critical { tilesProcessed++; cellsCreated += cellsCreatedForTile; progress = (int) (((float)tilesProcessed / (float) m_sceneTiles.size()) * 100.0f); if( progress - lastProgress >= 10 ) { std::stringstream str; str << "Tiles processed %: " << progress << " (" << cellsCreated << " cells)"; Logger::Log( str.str() ); lastProgress = progress; } } } //With all the cells created in each Tile, merge them all into the unified cells vector. for( unsigned int tileIndex = 0 ; tileIndex < m_sceneTiles.size() ; ++tileIndex) { const vector<shared_ptr<Cell>>& tileCells = m_sceneTiles[tileIndex]->getCells(); cells.insert( cells.end(), tileCells.begin(), tileCells.end() ); } }catch( bad_alloc& ) { Logger::Log("Error allocating memory for Cells. Consider increasing the Max Cell size or increasing SceneTile size."); exit(1); } }
bool ReadComponentRecord(istream& in) { HipparcosComponent component; char buf[HipComponentRecordLength]; in.read(buf, HipComponentRecordLength); uint32 hip; if (sscanf(buf + 42, "%ud", &hip) != 1) { cout << "Missing HIP catalog number for component.\n"; return false; } component.star = findStar(hip); if (component.star == NULL) { cout << "Nonexistent HIP catalog number for component.\n"; return false; } if (sscanf(buf + 40, "%c", &component.componentID) != 1) { cout << "Missing component identifier.\n"; return false; } if (sscanf(buf + 175, "%c", &component.refComponentID) != 1) { cout << "Error reading reference component.\n"; return false; } if (component.refComponentID == ' ') component.refComponentID = component.componentID; // Read astrometric information if (sscanf(buf + 88, "%f", &component.ascension) != 1) { cout << "Missing ascension for component.\n"; return false; } component.ascension = (float) (component.ascension * 24.0 / 360.0); if (sscanf(buf + 101, "%f", &component.declination) != 1) { cout << "Missing declination for component.\n"; return false; } // Read photometric information if (sscanf(buf + 49, "%f", &component.appMag) != 1) { cout << "Missing magnitude for component.\n"; return false; } // vMag and bMag may be necessary to guess the spectral type if (sscanf(buf + 62, "%f", &component.bMag) != 1 || sscanf(buf + 69, "%f", &component.vMag) != 1) { component.bMag = component.vMag = component.appMag; } else { component.hasBV = true; } if (component.componentID != component.refComponentID) { if (sscanf(buf + 177, "%f", &component.positionAngle) != 1) { cout << "Missing position angle for component.\n"; return false; } if (sscanf(buf + 185, "%f", &component.separation) != 1) { cout << "Missing separation for component.\n"; return false; } } components.insert(components.end(), component); return true; };
// adjusts the allele to have a new start // returns the ref/alt sequence obtained by subtracting length from the left end of the allele void Allele::subtract( int subtractFromRefStart, int subtractFromRefEnd, string& substart, string& subend, vector<pair<int, string> >& cigarStart, vector<pair<int, string> >& cigarEnd, vector<short>& qsubstart, vector<short>& qsubend ) { substart.clear(); subend.clear(); cigarStart.clear(); cigarEnd.clear(); qsubstart.clear(); qsubend.clear(); // prepare to adjust cigar list<pair<int, string> > cigarL = splitCigarList(cigar); // walk the cigar string to determine where to make the left cut in the alternate sequence int subtractFromAltStart = 0; if (subtractFromRefStart) { int refbpstart = subtractFromRefStart; pair<int, string> c; while (!cigarL.empty()) { c = cigarL.front(); cigarL.pop_front(); char op = c.second[0]; switch (op) { case 'M': case 'X': refbpstart -= c.first; subtractFromAltStart += c.first; break; case 'I': subtractFromAltStart += c.first; break; case 'D': refbpstart -= c.first; break; default: break; } cigarStart.push_back(c); if (refbpstart < 0) { // split/adjust the last cigar element cigarL.push_front(c); cigarL.front().first = -refbpstart; cigarStart.back().first += refbpstart; switch (op) { case 'M': case 'X': case 'I': subtractFromAltStart += refbpstart; break; case 'D': default: break; } break; // we're done } } } int subtractFromAltEnd = 0; // walk the cigar string to determine where to make the right cut in the alternate sequence if (subtractFromRefEnd) { int refbpend = subtractFromRefEnd; pair<int, string> c; while (!cigarL.empty() && refbpend > 0) { c = cigarL.back(); cigarL.pop_back(); char op = c.second[0]; switch (op) { case 'M': case 'X': subtractFromAltEnd += c.first; refbpend -= c.first; break; case 'I': subtractFromAltEnd += c.first; break; case 'D': refbpend -= c.first; break; default: break; } cigarEnd.insert(cigarEnd.begin(), c); if (refbpend < 0) { // split/adjust the last cigar element cigarL.push_back(c); cigarL.back().first = -refbpend; cigarEnd.front().first += refbpend; switch (op) { case 'M': case 'X': case 'I': subtractFromAltEnd += refbpend; break; case 'D': default: break; } break; // drop out of loop, we're done } } } // adjust the alternateSequence substart = alternateSequence.substr(0, subtractFromAltStart); subend = alternateSequence.substr(alternateSequence.size() - subtractFromAltEnd, subtractFromAltEnd); alternateSequence.erase(0, subtractFromAltStart); alternateSequence.erase(alternateSequence.size() - subtractFromAltEnd, subtractFromAltEnd); // adjust the quality string qsubstart.insert(qsubstart.begin(), baseQualities.begin(), baseQualities.begin() + subtractFromAltStart); qsubend.insert(qsubend.begin(), baseQualities.begin() + baseQualities.size() - subtractFromAltEnd, baseQualities.end()); baseQualities.erase(baseQualities.begin(), baseQualities.begin() + subtractFromAltStart); baseQualities.erase(baseQualities.begin() + baseQualities.size() - subtractFromAltEnd, baseQualities.end()); // reset the cigar cigarL.erase(remove_if(cigarL.begin(), cigarL.end(), isEmptyCigarElement), cigarL.end()); cigar = joinCigarList(cigarL); // reset the length length = alternateSequence.size(); // update the type specification updateTypeAndLengthFromCigar(); // adjust the position position += subtractFromRefStart; // assumes the first-base of the alleles is reference==, not ins //referenceLength -= subtractFromRefStart; //referenceLength -= subtractFromRefEnd; referenceLength = referenceLengthFromCigar(); }
int main(int argc, char* argv[]) { assert(sizeof(StellarClass) == 2); // Read star records from the primary HIPPARCOS catalog { ifstream mainDatabase(MainDatabaseFile.c_str(), ios::in | ios::binary); if (!mainDatabase.good()) { cout << "Error opening " << MainDatabaseFile << '\n'; exit(1); } cout << "Reading HIPPARCOS data set.\n"; while (mainDatabase.good()) { ReadStarRecord(mainDatabase); if (stars.size() % 10000 == 0) cout << stars.size() << " records.\n"; } } cout << "Read " << stars.size() << " stars from main database.\n"; cout << "Adding the Sun...\n"; stars.insert(stars.end(), TheSun()); cout << "Sorting stars...\n"; { starIndex.reserve(stars.size()); for (vector<HipparcosStar>::iterator iter = stars.begin(); iter != stars.end(); iter++) { starIndex.insert(starIndex.end(), iter); } HIPCatalogComparePredicate pred; // It may not even be necessary to sort the records, if the // HIPPARCOS catalog is strictly ordered by catalog number. I'm not // sure about this however, random_shuffle(starIndex.begin(), starIndex.end()); sort(starIndex.begin(), starIndex.end(), pred); } // Read component records { ifstream componentDatabase(ComponentDatabaseFile.c_str(), ios::in | ios::binary); if (!componentDatabase.good()) { cout << "Error opening " << ComponentDatabaseFile << '\n'; exit(1); } cout << "Reading HIPPARCOS component database.\n"; while (componentDatabase.good()) { ReadComponentRecord(componentDatabase); } } cout << "Read " << components.size() << " components.\n"; { int aComp = 0, bComp = 0, cComp = 0, dComp = 0, eComp = 0, otherComp = 0; int bvComp = 0; for (int i = 0; i < components.size(); i++) { switch (components[i].componentID) { case 'A': aComp++; break; case 'B': bComp++; break; case 'C': cComp++; break; case 'D': dComp++; break; case 'E': eComp++; break; default: otherComp++; break; } if (components[i].hasBV && components[i].componentID != 'A') bvComp++; } cout << "A:" << aComp << " B:" << bComp << " C:" << cComp << " D:" << dComp << " E:" << eComp << '\n'; cout << "Components with B-V mag: " << bvComp << '\n'; } cout << "Building catalog of multiple star systems.\n"; BuildMultistarSystemCatalog(); int nMultipleSystems = starSystems.size(); cout << "Stars in multiple star systems: " << nMultipleSystems << '\n'; ConstrainComponentParallaxes(); CorrectErrors(); // CreateCompanionList(); cout << "Companion stars: " << companions.size() << '\n'; cout << "Total stars: " << stars.size() + companions.size() << '\n'; ShowStarsWithComponents(); char* outputFile = "stars.dat"; if (argc > 1) outputFile = argv[1]; cout << "Writing processed star records to " << outputFile << '\n'; ofstream out(outputFile, ios::out | ios::binary); if (!out.good()) { cout << "Error opening " << outputFile << '\n'; exit(1); } binwrite(out, stars.size() + companions.size()); { vector<HipparcosStar>::iterator iter; for (iter = stars.begin(); iter != stars.end(); iter++) iter->write(out); for (iter = companions.begin(); iter != companions.end(); iter++) iter->write(out); } #if 0 char* hdOutputFile = "hdxref.dat"; cout << "Writing out HD cross reference to " << hdOutputFile << '\n'; ofstream hdout(hdOutputFile, ios::out | ios::binary); if (!out.good()) { cout << "Error opening " << hdOutputFile << '\n'; exit(1); } { int nHD = 0; vector<HipparcosStar>::iterator iter; for (iter = stars.begin(); iter != stars.end(); iter++) { if (iter->HDCatalogNumber != NullCatalogNumber) nHD++; } binwrite(hdout, nHD); cout << nHD << " stars have HD numbers.\n"; for (iter = stars.begin(); iter != stars.end(); iter++) { if (iter->HDCatalogNumber != NullCatalogNumber) { binwrite(hdout, iter->HDCatalogNumber); binwrite(hdout, iter->HIPCatalogNumber); } } } #endif return 0; }
bool LTKGrammar::replacePaths(string term,vector<vector<string> >& originalVector,vector<vector<string> >& replaceVector) { LOG(LTKLogger::LTK_LOGLEVEL_DEBUG) <<"Entering LTKGrammar::replacePaths" <<endl; bool found=false; //indicates whether is search term is found int iValue=0,jValue=0; //indices whether the term is found bool checkedForRecursion=false; int recursionCount=0; //indicates how many times the term replacement happens while(true) { ++recursionCount; if(recursionCount>150) { LOG(LTKLogger::LTK_LOGLEVEL_ERR) << "Cyclic dependency exists! Unable to find paths!" <<endl; throw LTKException(ECYCLIC_DEPENDENCY); return false; } bool foundTerm=false; //searching for the term in the paths determined so far for(int i=iValue;i<originalVector.size();++i) { for(int j=0;j<originalVector[i].size();++j) { if(originalVector[i][j]==term) { iValue=i; jValue=j; if(!checkedForRecursion) { checkedForRecursion=true; for(int c=0;c<replaceVector.size();++c) { for(int d=0;d<replaceVector[c].size();++d) { if(replaceVector[c][d]==term) { LOG(LTKLogger::LTK_LOGLEVEL_ERR) << "Cyclic dependency exists! Unable to find paths!" <<endl; throw LTKException(ECYCLIC_DEPENDENCY); return false; } } } } originalVector[i].erase(originalVector[i].begin()+j); foundTerm=true; break; } } if(foundTerm) { break; } } if(foundTerm) //Replacing the found term with its production values { originalVector.insert(originalVector.begin()+iValue+1,replaceVector.size()-1,*(originalVector.begin()+iValue)); for(int k=iValue;k<(iValue+replaceVector.size());++k) { originalVector[k].insert(originalVector[k].begin()+jValue,replaceVector[k-iValue].begin(),replaceVector[k-iValue].end()); } found=true; continue; } else { break; } } LOG(LTKLogger::LTK_LOGLEVEL_DEBUG) << "Exiting LTKGrammar::replacePaths" <<endl; return found; }
void BackgroundUtil::AddBackgroundChange( vector<BackgroundChange> &vBackgroundChanges, BackgroundChange seg ) { vector<BackgroundChange>::iterator it; it = upper_bound( vBackgroundChanges.begin(), vBackgroundChanges.end(), seg, CompareBackgroundChanges ); vBackgroundChanges.insert( it, seg ); }
void ClsMultiThread::FindSimilarKmer(map<string, St_KmerIndex>& mpCombine, vector<St_KmerInfo>& vKmerRegular) { //1: Get the number of CPU string strNum = exec("nproc"); if(strNum.substr(strNum.length()-1,1) == "\n") strNum = strNum.substr(0, strNum.length()-1); int iCpuNum = atoi(strNum.c_str()); //2: Divid KmerRegular Table evenly by the number of cpu int iLen = ceil((float)vKmerRegular.size() / iCpuNum); vector<St_SimilarKmer> vSubGroupKmer; vSubGroupKmer.resize(iCpuNum); for(int i=0; i<iCpuNum; i++) { int iStart = i * iLen; int iEnd = (i+1)*iLen; if(iEnd < vKmerRegular.size()) vSubGroupKmer[i].vRegKmer.insert(vSubGroupKmer[i].vRegKmer.end(), vKmerRegular.begin() + iStart, vKmerRegular.begin() + iEnd); else vSubGroupKmer[i].vRegKmer.insert(vSubGroupKmer[i].vRegKmer.end(), vKmerRegular.begin() + iStart, vKmerRegular.end()); vSubGroupKmer[i].mpSuperKmer.insert(mpCombine.begin(), mpCombine.end()); } //Create Threads int start_s = time(NULL); pthread_t tids[iCpuNum]; pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); for(int i=0; i<iCpuNum; i++) { int ret = pthread_create(&tids[i], &attr, ClsThreadFunc::SimilarDetect, (void*)&(vSubGroupKmer[i])); if(ret != 0) cout << "Thread error: " << ret << endl; } pthread_attr_destroy(&attr); void* status; for(int i=0; i<iCpuNum; i++) { int ret = pthread_join(tids[i], &status); if(ret != 0) cout << "Thread Error: " << ret << endl; else cout << "Thread Status: " << (long)status << endl; } //pthread_exit(NULL); int stop_s = time(NULL); double dRuningTime = difftime(stop_s, start_s); string strTimeFormat = ::GetHMSTimeFormat(dRuningTime); cout << "Running Time: " << strTimeFormat << endl; //Arrange the kmer for(map<string, St_KmerIndex>::iterator itr = mpCombine.begin(); itr != mpCombine.end(); itr++) { int iBase = itr->second.iCount; int iAccumulate = 0; for(vector<St_SimilarKmer>::iterator subItr = vSubGroupKmer.begin(); subItr != vSubGroupKmer.end(); subItr++) { iAccumulate += subItr->mpSuperKmer[itr->first].iCount - iBase; } itr->second.iCount = iBase + iAccumulate; } //好折腾啊!!!!!!!! //2: 将剩下的没能归组的再进行合并,得到总的没有归组的kmer vKmerRegular.clear(); for(vector<St_SimilarKmer>::iterator itr = vSubGroupKmer.begin(); itr != vSubGroupKmer.end(); itr++) { vKmerRegular.insert(vKmerRegular.end(), itr->vRegKmer.begin(), itr->vRegKmer.end()); } }
bool EvalScript(vector<vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, int nHashType) { CAutoBN_CTX pctx; CScript::const_iterator pc = script.begin(); CScript::const_iterator pend = script.end(); CScript::const_iterator pbegincodehash = script.begin(); opcodetype opcode; valtype vchPushValue; vector<bool> vfExec; vector<valtype> altstack; if (script.size() > 10000) return false; int nOpCount = 0; try { while (pc < pend) { bool fExec = !count(vfExec.begin(), vfExec.end(), false); // // Read instruction // if (!script.GetOp(pc, opcode, vchPushValue)) return false; if (vchPushValue.size() > 520) return false; if (opcode > OP_16 && ++nOpCount > 201) return false; if (opcode == OP_CAT || opcode == OP_SUBSTR || opcode == OP_LEFT || opcode == OP_RIGHT || opcode == OP_INVERT || opcode == OP_AND || opcode == OP_OR || opcode == OP_XOR || opcode == OP_2MUL || opcode == OP_2DIV || opcode == OP_MUL || opcode == OP_DIV || opcode == OP_MOD || opcode == OP_LSHIFT || opcode == OP_RSHIFT) return false; if (fExec && 0 <= opcode && opcode <= OP_PUSHDATA4) stack.push_back(vchPushValue); else if (fExec || (OP_IF <= opcode && opcode <= OP_ENDIF)) switch (opcode) { // // Push value // case OP_1NEGATE: case OP_1: case OP_2: case OP_3: case OP_4: case OP_5: case OP_6: case OP_7: case OP_8: case OP_9: case OP_10: case OP_11: case OP_12: case OP_13: case OP_14: case OP_15: case OP_16: { // ( -- value) CBigNum bn((int)opcode - (int)(OP_1 - 1)); stack.push_back(bn.getvch()); } break; // // Control // case OP_NOP: case OP_NOP1: case OP_NOP2: case OP_NOP3: case OP_NOP4: case OP_NOP5: case OP_NOP6: case OP_NOP7: case OP_NOP8: case OP_NOP9: case OP_NOP10: break; case OP_IF: case OP_NOTIF: { // <expression> if [statements] [else [statements]] endif bool fValue = false; if (fExec) { if (stack.size() < 1) return false; valtype& vch = stacktop(-1); fValue = CastToBool(vch); if (opcode == OP_NOTIF) fValue = !fValue; popstack(stack); } vfExec.push_back(fValue); } break; case OP_ELSE: { if (vfExec.empty()) return false; vfExec.back() = !vfExec.back(); } break; case OP_ENDIF: { if (vfExec.empty()) return false; vfExec.pop_back(); } break; case OP_VERIFY: { // (true -- ) or // (false -- false) and return if (stack.size() < 1) return false; bool fValue = CastToBool(stacktop(-1)); if (fValue) popstack(stack); else return false; } break; case OP_RETURN: { return false; } break; // // Stack ops // case OP_TOALTSTACK: { if (stack.size() < 1) return false; altstack.push_back(stacktop(-1)); popstack(stack); } break; case OP_FROMALTSTACK: { if (altstack.size() < 1) return false; stack.push_back(altstacktop(-1)); popstack(altstack); } break; case OP_2DROP: { // (x1 x2 -- ) if (stack.size() < 2) return false; popstack(stack); popstack(stack); } break; case OP_2DUP: { // (x1 x2 -- x1 x2 x1 x2) if (stack.size() < 2) return false; valtype vch1 = stacktop(-2); valtype vch2 = stacktop(-1); stack.push_back(vch1); stack.push_back(vch2); } break; case OP_3DUP: { // (x1 x2 x3 -- x1 x2 x3 x1 x2 x3) if (stack.size() < 3) return false; valtype vch1 = stacktop(-3); valtype vch2 = stacktop(-2); valtype vch3 = stacktop(-1); stack.push_back(vch1); stack.push_back(vch2); stack.push_back(vch3); } break; case OP_2OVER: { // (x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2) if (stack.size() < 4) return false; valtype vch1 = stacktop(-4); valtype vch2 = stacktop(-3); stack.push_back(vch1); stack.push_back(vch2); } break; case OP_2ROT: { // (x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2) if (stack.size() < 6) return false; valtype vch1 = stacktop(-6); valtype vch2 = stacktop(-5); stack.erase(stack.end()-6, stack.end()-4); stack.push_back(vch1); stack.push_back(vch2); } break; case OP_2SWAP: { // (x1 x2 x3 x4 -- x3 x4 x1 x2) if (stack.size() < 4) return false; swap(stacktop(-4), stacktop(-2)); swap(stacktop(-3), stacktop(-1)); } break; case OP_IFDUP: { // (x - 0 | x x) if (stack.size() < 1) return false; valtype vch = stacktop(-1); if (CastToBool(vch)) stack.push_back(vch); } break; case OP_DEPTH: { // -- stacksize CBigNum bn(stack.size()); stack.push_back(bn.getvch()); } break; case OP_DROP: { // (x -- ) if (stack.size() < 1) return false; popstack(stack); } break; case OP_DUP: { // (x -- x x) if (stack.size() < 1) return false; valtype vch = stacktop(-1); stack.push_back(vch); } break; case OP_NIP: { // (x1 x2 -- x2) if (stack.size() < 2) return false; stack.erase(stack.end() - 2); } break; case OP_OVER: { // (x1 x2 -- x1 x2 x1) if (stack.size() < 2) return false; valtype vch = stacktop(-2); stack.push_back(vch); } break; case OP_PICK: case OP_ROLL: { // (xn ... x2 x1 x0 n - xn ... x2 x1 x0 xn) // (xn ... x2 x1 x0 n - ... x2 x1 x0 xn) if (stack.size() < 2) return false; int n = CastToBigNum(stacktop(-1)).getint(); popstack(stack); if (n < 0 || n >= stack.size()) return false; valtype vch = stacktop(-n-1); if (opcode == OP_ROLL) stack.erase(stack.end()-n-1); stack.push_back(vch); } break; case OP_ROT: { // (x1 x2 x3 -- x2 x3 x1) // x2 x1 x3 after first swap // x2 x3 x1 after second swap if (stack.size() < 3) return false; swap(stacktop(-3), stacktop(-2)); swap(stacktop(-2), stacktop(-1)); } break; case OP_SWAP: { // (x1 x2 -- x2 x1) if (stack.size() < 2) return false; swap(stacktop(-2), stacktop(-1)); } break; case OP_TUCK: { // (x1 x2 -- x2 x1 x2) if (stack.size() < 2) return false; valtype vch = stacktop(-1); stack.insert(stack.end()-2, vch); } break; // // Splice ops // case OP_CAT: { // (x1 x2 -- out) if (stack.size() < 2) return false; valtype& vch1 = stacktop(-2); valtype& vch2 = stacktop(-1); vch1.insert(vch1.end(), vch2.begin(), vch2.end()); popstack(stack); if (stacktop(-1).size() > 520) return false; } break; case OP_SUBSTR: { // (in begin size -- out) if (stack.size() < 3) return false; valtype& vch = stacktop(-3); int nBegin = CastToBigNum(stacktop(-2)).getint(); int nEnd = nBegin + CastToBigNum(stacktop(-1)).getint(); if (nBegin < 0 || nEnd < nBegin) return false; if (nBegin > vch.size()) nBegin = vch.size(); if (nEnd > vch.size()) nEnd = vch.size(); vch.erase(vch.begin() + nEnd, vch.end()); vch.erase(vch.begin(), vch.begin() + nBegin); popstack(stack); popstack(stack); } break; case OP_LEFT: case OP_RIGHT: { // (in size -- out) if (stack.size() < 2) return false; valtype& vch = stacktop(-2); int nSize = CastToBigNum(stacktop(-1)).getint(); if (nSize < 0) return false; if (nSize > vch.size()) nSize = vch.size(); if (opcode == OP_LEFT) vch.erase(vch.begin() + nSize, vch.end()); else vch.erase(vch.begin(), vch.end() - nSize); popstack(stack); } break; case OP_SIZE: { // (in -- in size) if (stack.size() < 1) return false; CBigNum bn(stacktop(-1).size()); stack.push_back(bn.getvch()); } break; // // Bitwise logic // case OP_INVERT: { // (in - out) if (stack.size() < 1) return false; valtype& vch = stacktop(-1); for (int i = 0; i < vch.size(); i++) vch[i] = ~vch[i]; } break; case OP_AND: case OP_OR: case OP_XOR: { // (x1 x2 - out) if (stack.size() < 2) return false; valtype& vch1 = stacktop(-2); valtype& vch2 = stacktop(-1); MakeSameSize(vch1, vch2); if (opcode == OP_AND) { for (int i = 0; i < vch1.size(); i++) vch1[i] &= vch2[i]; } else if (opcode == OP_OR) { for (int i = 0; i < vch1.size(); i++) vch1[i] |= vch2[i]; } else if (opcode == OP_XOR) { for (int i = 0; i < vch1.size(); i++) vch1[i] ^= vch2[i]; } popstack(stack); } break; case OP_EQUAL: case OP_EQUALVERIFY: //case OP_NOTEQUAL: // use OP_NUMNOTEQUAL { // (x1 x2 - bool) if (stack.size() < 2) return false; valtype& vch1 = stacktop(-2); valtype& vch2 = stacktop(-1); bool fEqual = (vch1 == vch2); // OP_NOTEQUAL is disabled because it would be too easy to say // something like n != 1 and have some wiseguy pass in 1 with extra // zero bytes after it (numerically, 0x01 == 0x0001 == 0x000001) //if (opcode == OP_NOTEQUAL) // fEqual = !fEqual; popstack(stack); popstack(stack); stack.push_back(fEqual ? vchTrue : vchFalse); if (opcode == OP_EQUALVERIFY) { if (fEqual) popstack(stack); else return false; } } break; // // Numeric // case OP_1ADD: case OP_1SUB: case OP_2MUL: case OP_2DIV: case OP_NEGATE: case OP_ABS: case OP_NOT: case OP_0NOTEQUAL: { // (in -- out) if (stack.size() < 1) return false; CBigNum bn = CastToBigNum(stacktop(-1)); switch (opcode) { case OP_1ADD: bn += bnOne; break; case OP_1SUB: bn -= bnOne; break; case OP_2MUL: bn <<= 1; break; case OP_2DIV: bn >>= 1; break; case OP_NEGATE: bn = -bn; break; case OP_ABS: if (bn < bnZero) bn = -bn; break; case OP_NOT: bn = (bn == bnZero); break; case OP_0NOTEQUAL: bn = (bn != bnZero); break; default: assert(!"invalid opcode"); break; } popstack(stack); stack.push_back(bn.getvch()); } break; case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: case OP_MOD: case OP_LSHIFT: case OP_RSHIFT: case OP_BOOLAND: case OP_BOOLOR: case OP_NUMEQUAL: case OP_NUMEQUALVERIFY: case OP_NUMNOTEQUAL: case OP_LESSTHAN: case OP_GREATERTHAN: case OP_LESSTHANOREQUAL: case OP_GREATERTHANOREQUAL: case OP_MIN: case OP_MAX: { // (x1 x2 -- out) if (stack.size() < 2) return false; CBigNum bn1 = CastToBigNum(stacktop(-2)); CBigNum bn2 = CastToBigNum(stacktop(-1)); CBigNum bn; switch (opcode) { case OP_ADD: bn = bn1 + bn2; break; case OP_SUB: bn = bn1 - bn2; break; case OP_MUL: if (!BN_mul(&bn, &bn1, &bn2, pctx)) return false; break; case OP_DIV: if (!BN_div(&bn, NULL, &bn1, &bn2, pctx)) return false; break; case OP_MOD: if (!BN_mod(&bn, &bn1, &bn2, pctx)) return false; break; case OP_LSHIFT: if (bn2 < bnZero || bn2 > CBigNum(2048)) return false; bn = bn1 << bn2.getulong(); break; case OP_RSHIFT: if (bn2 < bnZero || bn2 > CBigNum(2048)) return false; bn = bn1 >> bn2.getulong(); break; case OP_BOOLAND: bn = (bn1 != bnZero && bn2 != bnZero); break; case OP_BOOLOR: bn = (bn1 != bnZero || bn2 != bnZero); break; case OP_NUMEQUAL: bn = (bn1 == bn2); break; case OP_NUMEQUALVERIFY: bn = (bn1 == bn2); break; case OP_NUMNOTEQUAL: bn = (bn1 != bn2); break; case OP_LESSTHAN: bn = (bn1 < bn2); break; case OP_GREATERTHAN: bn = (bn1 > bn2); break; case OP_LESSTHANOREQUAL: bn = (bn1 <= bn2); break; case OP_GREATERTHANOREQUAL: bn = (bn1 >= bn2); break; case OP_MIN: bn = (bn1 < bn2 ? bn1 : bn2); break; case OP_MAX: bn = (bn1 > bn2 ? bn1 : bn2); break; default: assert(!"invalid opcode"); break; } popstack(stack); popstack(stack); stack.push_back(bn.getvch()); if (opcode == OP_NUMEQUALVERIFY) { if (CastToBool(stacktop(-1))) popstack(stack); else return false; } } break; case OP_WITHIN: { // (x min max -- out) if (stack.size() < 3) return false; CBigNum bn1 = CastToBigNum(stacktop(-3)); CBigNum bn2 = CastToBigNum(stacktop(-2)); CBigNum bn3 = CastToBigNum(stacktop(-1)); bool fValue = (bn2 <= bn1 && bn1 < bn3); popstack(stack); popstack(stack); popstack(stack); stack.push_back(fValue ? vchTrue : vchFalse); } break; // // Crypto // case OP_RIPEMD160: case OP_SHA1: case OP_SHA256: case OP_HASH160: case OP_HASH256: { // (in -- hash) if (stack.size() < 1) return false; valtype& vch = stacktop(-1); valtype vchHash((opcode == OP_RIPEMD160 || opcode == OP_SHA1 || opcode == OP_HASH160) ? 20 : 32); if (opcode == OP_RIPEMD160) RIPEMD160(&vch[0], vch.size(), &vchHash[0]); else if (opcode == OP_SHA1) SHA1(&vch[0], vch.size(), &vchHash[0]); else if (opcode == OP_SHA256) SHA256(&vch[0], vch.size(), &vchHash[0]); else if (opcode == OP_HASH160) { uint160 hash160 = Hash160(vch); memcpy(&vchHash[0], &hash160, sizeof(hash160)); } else if (opcode == OP_HASH256) { uint256 hash = Hash(vch.begin(), vch.end()); memcpy(&vchHash[0], &hash, sizeof(hash)); } popstack(stack); stack.push_back(vchHash); } break; case OP_CODESEPARATOR: { // Hash starts after the code separator pbegincodehash = pc; } break; case OP_CHECKSIG: case OP_CHECKSIGVERIFY: { // (sig pubkey -- bool) if (stack.size() < 2) return false; valtype& vchSig = stacktop(-2); valtype& vchPubKey = stacktop(-1); ////// debug print //PrintHex(vchSig.begin(), vchSig.end(), "sig: %s\n"); //PrintHex(vchPubKey.begin(), vchPubKey.end(), "pubkey: %s\n"); // Subset of script starting at the most recent codeseparator CScript scriptCode(pbegincodehash, pend); // Drop the signature, since there's no way for a signature to sign itself scriptCode.FindAndDelete(CScript(vchSig)); bool fSuccess = CheckSig(vchSig, vchPubKey, scriptCode, txTo, nIn, nHashType); popstack(stack); popstack(stack); stack.push_back(fSuccess ? vchTrue : vchFalse); if (opcode == OP_CHECKSIGVERIFY) { if (fSuccess) popstack(stack); else return false; } } break; case OP_CHECKMULTISIG: case OP_CHECKMULTISIGVERIFY: { // ([sig ...] num_of_signatures [pubkey ...] num_of_pubkeys -- bool) int i = 1; if (stack.size() < i) return false; int nKeysCount = CastToBigNum(stacktop(-i)).getint(); if (nKeysCount < 0 || nKeysCount > 20) return false; nOpCount += nKeysCount; if (nOpCount > 201) return false; int ikey = ++i; i += nKeysCount; if (stack.size() < i) return false; int nSigsCount = CastToBigNum(stacktop(-i)).getint(); if (nSigsCount < 0 || nSigsCount > nKeysCount) return false; int isig = ++i; i += nSigsCount; if (stack.size() < i) return false; // Subset of script starting at the most recent codeseparator CScript scriptCode(pbegincodehash, pend); // Drop the signatures, since there's no way for a signature to sign itself for (int k = 0; k < nSigsCount; k++) { valtype& vchSig = stacktop(-isig-k); scriptCode.FindAndDelete(CScript(vchSig)); } bool fSuccess = true; while (fSuccess && nSigsCount > 0) { valtype& vchSig = stacktop(-isig); valtype& vchPubKey = stacktop(-ikey); // Check signature if (CheckSig(vchSig, vchPubKey, scriptCode, txTo, nIn, nHashType)) { isig++; nSigsCount--; } ikey++; nKeysCount--; // If there are more signatures left than keys left, // then too many signatures have failed if (nSigsCount > nKeysCount) fSuccess = false; } while (i-- > 0) popstack(stack); stack.push_back(fSuccess ? vchTrue : vchFalse); if (opcode == OP_CHECKMULTISIGVERIFY) { if (fSuccess) popstack(stack); else return false; } } break; default: return false; } // Size limits if (stack.size() + altstack.size() > 1000) return false; } } catch (...) { return false; } if (!vfExec.empty()) return false; return true; }
int LinesSampler::decodeRowCount(const int symbolsPerLine, vector<vector<int> > &detectedCodeWords, vector<int> &insertLinesAt) { // Use the information in the first and last column to determin the number of rows and find more missing rows. // For missing rows insert blank space, so the error correction can try to fill them in. map<int, int> rowCountVotes; map<int, int> ecLevelVotes; map<int, int> rowNumberVotes; int lastRowNumber = -1; insertLinesAt.clear(); for (int i = 0; i + 2 < (int)detectedCodeWords.size(); i += 3) { rowNumberVotes.clear(); int firstCodewordDecodedLeft = -1; int secondCodewordDecodedLeft = -1; int thirdCodewordDecodedLeft = -1; int firstCodewordDecodedRight = -1; int secondCodewordDecodedRight = -1; int thirdCodewordDecodedRight = -1; if (detectedCodeWords[i][0] != 0) { firstCodewordDecodedLeft = BitMatrixParser::getCodeword(detectedCodeWords[i][0]); } if (detectedCodeWords[i + 1][0] != 0) { secondCodewordDecodedLeft = BitMatrixParser::getCodeword(detectedCodeWords[i + 1][0]); } if (detectedCodeWords[i + 2][0] != 0) { thirdCodewordDecodedLeft = BitMatrixParser::getCodeword(detectedCodeWords[i + 2][0]); } if (detectedCodeWords[i][detectedCodeWords[i].size() - 1] != 0) { firstCodewordDecodedRight = BitMatrixParser::getCodeword(detectedCodeWords[i][detectedCodeWords[i].size() - 1]); } if (detectedCodeWords[i + 1][detectedCodeWords[i + 1].size() - 1] != 0) { secondCodewordDecodedRight = BitMatrixParser::getCodeword(detectedCodeWords[i + 1][detectedCodeWords[i + 1].size() - 1]); } if (detectedCodeWords[i + 2][detectedCodeWords[i + 2].size() - 1] != 0) { thirdCodewordDecodedRight = BitMatrixParser::getCodeword(detectedCodeWords[i + 2][detectedCodeWords[i + 2].size() - 1]); } if (firstCodewordDecodedLeft != -1 && secondCodewordDecodedLeft != -1) { int leftRowCount = ((firstCodewordDecodedLeft % 30) * 3) + ((secondCodewordDecodedLeft % 30) % 3); int leftECLevel = (secondCodewordDecodedLeft % 30) / 3; rowCountVotes[leftRowCount] = rowCountVotes[leftRowCount] + 1; ecLevelVotes[leftECLevel] = ecLevelVotes[leftECLevel] + 1; } if (secondCodewordDecodedRight != -1 && thirdCodewordDecodedRight != -1) { int rightRowCount = ((secondCodewordDecodedRight % 30) * 3) + ((thirdCodewordDecodedRight % 30) % 3); int rightECLevel = (thirdCodewordDecodedRight % 30) / 3; rowCountVotes[rightRowCount] = rowCountVotes[rightRowCount] + 1; ecLevelVotes[rightECLevel] = ecLevelVotes[rightECLevel] + 1; } if (firstCodewordDecodedLeft != -1) { int rowNumber = firstCodewordDecodedLeft / 30; rowNumberVotes[rowNumber] = rowNumberVotes[rowNumber] + 1; } if (secondCodewordDecodedLeft != -1) { int rowNumber = secondCodewordDecodedLeft / 30; rowNumberVotes[rowNumber] = rowNumberVotes[rowNumber] + 1; } if (thirdCodewordDecodedLeft != -1) { int rowNumber = thirdCodewordDecodedLeft / 30; rowNumberVotes[rowNumber] = rowNumberVotes[rowNumber] + 1; } if (firstCodewordDecodedRight != -1) { int rowNumber = firstCodewordDecodedRight / 30; rowNumberVotes[rowNumber] = rowNumberVotes[rowNumber] + 1; } if (secondCodewordDecodedRight != -1) { int rowNumber = secondCodewordDecodedRight / 30; rowNumberVotes[rowNumber] = rowNumberVotes[rowNumber] + 1; } if (thirdCodewordDecodedRight != -1) { int rowNumber = thirdCodewordDecodedRight / 30; rowNumberVotes[rowNumber] = rowNumberVotes[rowNumber] + 1; } int rowNumber = getValueWithMaxVotes(rowNumberVotes).getVote(); if (lastRowNumber + 1 < rowNumber) { for (int j = lastRowNumber + 1; j < rowNumber; j++) { insertLinesAt.push_back(i); insertLinesAt.push_back(i); insertLinesAt.push_back(i); } } lastRowNumber = rowNumber; } for (int i = 0; i < (int)insertLinesAt.size(); i++) { detectedCodeWords.insert(detectedCodeWords.begin() + insertLinesAt[i] + i, vector<int>(symbolsPerLine, 0)); } int rowCount = getValueWithMaxVotes(rowCountVotes).getVote(); // int ecLevel = getValueWithMaxVotes(ecLevelVotes); #if PDF417_DIAG && OUTPUT_EC_LEVEL { cout << "EC Level: " << ecLevel << " (" << ((1 << (ecLevel + 1)) - 2) << " EC Codewords)" << endl; } #endif rowCount += 1; return rowCount; }
singleStepOutput simOneTimeStep( vector<int> lattice, vector<int> mrna, vector<int> unfoldedPos, vector<int> occupiedPos, vector<int> ribState, double alpha, double beta, vector<double> gamma, vector<int> delta, double refold, int w){ vector<int> newLattice(lattice); // calculate total arrival rate int canEnter = initiateQ( lattice, w ); double sumRates = 0; int sizeProp = occupiedPos.size() + 1; // does mRNA refold? for (int i=0; i < unfoldedPos.size(); ++i){ if (refold <= ((double) rand() / (RAND_MAX))){ mrna.at(unfoldedPos.at(i)) = 0; } } // now simulate if ( canEnter == 1 ){ sumRates += alpha; } for ( int j=0; j < occupiedPos.size(); ++j){ if ( ribState.at(j) == 0 ) { // cout << "i have no trna " << endl; // cout << occupiedPos.at(j) << " " << ribState.at(j) << endl; sumRates += gamma.at(occupiedPos.at(j)); // sizeProp += 1; } else { double canMove = moveToRightQ( lattice, mrna, ribState.at(j), occupiedPos.at(j), w ); // cout << "can I move " << canMove << endl; // cout << "lattice "; // for (int i = 0; i <= lattice.size()-1; ++i){ // cout << lattice.at(i); // } if ( occupiedPos.at(j) != lattice.size() - 1){ sumRates += canMove*delta.at(occupiedPos.at(j)); } else { if ( ribState.at(j) == 1 ) { sumRates += beta; // sizeProp += 1; } else { sumRates += gamma.at(occupiedPos.at(j)); // sizeProp += 1; } } } } vector<double> prop(sizeProp,0); // propensity function // add on initiation if ( canEnter == 1 ) { prop.at(0) = alpha/sumRates; } else{ prop.at(0) = 0; } // cumulative sum over elongation rates for ( int j = 0; j < occupiedPos.size(); ++j ){ if ( occupiedPos.at(j) < lattice.size() - 1 ){ if ( ribState.at(j) == 0 ) { prop.at(j+1) = prop.at(j) + gamma.at(occupiedPos.at(j))/sumRates; } else if ( ribState.at(j) == 1 ) { double canMove = moveToRightQ( lattice, mrna, ribState.at(j), occupiedPos.at(j), w ); prop.at(j+1) = prop.at(j) + canMove*delta.at(occupiedPos.at(j))/sumRates;; } } else { if ( ribState.at(j) == 0 ) { prop.at(j+1) = prop.at(j) + gamma.at(occupiedPos.at(j))/sumRates; } else if ( ribState.at(j) == 1 ) { prop.at(j+1) = prop.at(j) + beta/sumRates; } } } // which ribosome will jump? double u = ((double) rand() / (RAND_MAX)); int whichMove = 0; while ( prop.at(whichMove) < u ){ whichMove++; } // cout << "ribosome " << whichMove << " moves" << endl; // now the jump! (or not) if ( whichMove == 0 ){ // cout << "enter " << endl; newLattice.at(0) = 1; occupiedPos.insert(occupiedPos.begin(), 0); ribState.insert(ribState.begin(), 1); } else { // cout << "it is at " << occupiedPos.at(whichMove-1) << endl; // cout << "it is in state " << ribState.at(whichMove-1) << endl; if ( occupiedPos.at(whichMove-1) < lattice.size() - 1 ) { if ( ribState.at(whichMove-1) == 1 ) { newLattice.at(occupiedPos.at(whichMove-1)) = 0; mrna.at(occupiedPos.at(whichMove-1)) = 1; unfoldedPos.insert(unfoldedPos.begin(), whichMove-1); newLattice.at(occupiedPos.at(whichMove-1)+1) = 1; occupiedPos.at(whichMove-1) += 1; ribState.at(whichMove-1) = 0; // cout << "now it is at " << occupiedPos.at(whichMove-1) << endl; // cout << "see " << newLattice.at(occupiedPos.at(whichMove-1)) << endl; // cout << "it is at state " << ribState.at(whichMove-1) << endl; } else { ribState.at(whichMove-1) = 1; } } else if ( occupiedPos.at(whichMove-1) == lattice.size() - 1 ) { if ( ribState.at(whichMove-1) == 1 ){ occupiedPos.pop_back(); ribState.pop_back(); newLattice.at( newLattice.size() - 1 ) = 0; } else { // cout << "i should come here " << endl; ribState.at(whichMove-1) = 1; } } } singleStepOutput result; result.lattice = newLattice; result.arrRate = sumRates; result.pos = occupiedPos; result.states = ribState; result.mrna = mrna; result.foldpos = unfoldedPos; return result; }
/** * Get the prediction response for the given image. * @param originImage image, which should be predicted * @param resultLayer the name of the result layer * @param dataLayer the name of the data layer * @param predictions the predictions */ void CaffeClassifier::predict(std::vector<cv::Mat>& originImages, std::vector<int> labels, string resultLayer, string dataLayer, vector<float> & predictions) { vector<Datum> vecDatum; for (int i = 0; i < originImages.size(); i++) { cv::Mat originImage = originImages[i]; // resize image Mat image; if (originImage.cols != imageSize.width || originImage.rows != imageSize.height) { resize(originImage, image, imageSize); // std::cout << "Image does not have correct size. Exiting." << std::endl; // exit(99); } else image = originImage; // check channels if (channels != image.channels()) { cerr << "Error: the channel number of input image is invalid for CNN classifier!" << endl; exit(1); } // mat to datum Datum datum; CVMatToDatum(image, &datum); datum.set_label(labels[i]); vecDatum.push_back(datum); image.release(); } // get the data layer const caffe::shared_ptr<MemoryDataLayer<float>> memDataLayer = boost::static_pointer_cast<MemoryDataLayer<float>> (caffeNet->layer_by_name(dataLayer)); // push new image data memDataLayer->AddDatumVector(vecDatum); //memDataLayer->ExactNumBottomBlobs(); // do forward pass vector<Blob<float>*> inputVec; caffeNet->Forward(inputVec); // get results const caffe::shared_ptr<Blob<float> > featureBlob = caffeNet->blob_by_name(resultLayer); int batchSize = featureBlob->num(); int dimFeatures = featureBlob->count() / batchSize; // std::cout << "Batch size is " << batchSize << "/ dim features is " << dimFeatures << std::endl; // get output from each channel for (int n = 0; n < batchSize; ++n) { float* fs = featureBlob->mutable_cpu_data() + featureBlob->offset(n); if (sizeof(fs) > 0) { vector<float> feature_vector(fs, fs + dimFeatures); predictions.insert(predictions.end(), feature_vector.begin(), feature_vector.end()); } } // release data // for (Datum d : vecDatum) { // d.release_data(); // } }
double Interpreter::evaluateInfix(vector<string> v) { //std::cout << "In postfix" << std::endl; printVector(v); //std::cout << "--------lol---------" << std::endl; stack<string> *operators = new stack<string>(); stack<double> *doubles = new stack<double>(); vector<string> *postfix = new vector<string>(); v.push_back(")"); v.insert(v.begin(), "("); for (; !v.empty();) { string element = v[0]; if (isalpha(element.front())) { postfix->push_back(to_string(variableMap.at(element))); } else if (isNumber(element)) { postfix->push_back(element); } else if (element == "(") { operators->push(element); } else if (isOperator(element)) { for (; precedence(operators);) { postfix->push_back(operators->top()); operators->pop(); } operators->push(element); } else { while (operators->top() != "(") { postfix->push_back(operators->top()); operators->pop(); } operators->pop(); } v.erase(v.begin()); } // std::cout << "postfix : "; printVector(*postfix); while (!postfix->empty()) { if (isOperator(postfix->at(0))) { char x = postfix->front().front(); double first = doubles->top(); doubles->pop(); double second = doubles->top(); doubles->pop(); double result; switch (x) { case '+': result = second + first; break; case '-': result = second - first; break; case '*': result = second * first; break; case '/': result = second / first; break; } doubles->push(result); } else { doubles->push(stod(postfix->at(0))); } //std::cout << "doubles : "; printStack(*doubles); postfix->erase(postfix->begin()); } // std::cout << "-------------------------" << std::endl; if (doubles->size() == 1) return doubles->top(); else return NULL; }
BEGIN_EXTERNC static MI_Boolean ClientCallback( Selector* sel, Handler* handler, MI_Uint32 mask, MI_Uint64 currentTimeUsec) { MI_Result r; sel=sel; currentTimeUsec = currentTimeUsec; s_cln_h = handler; /* Process write event */ if (mask & SELECTOR_WRITE) { for (;;) { if (!s_cln_connected) { // Generate random data sequence. GenRandData(s_data); s_cln_out = s_data; // Watch for READ and WRITE events. handler->mask = SELECTOR_READ|SELECTOR_WRITE; s_cln_connected = true; //break; } // Write out data to server. if (s_cln_out.size()) { size_t n = 0; size_t m = 7 + (int)(rand() % 256); if (m > s_cln_out.size()) m = s_cln_out.size(); r = Sock_Write(handler->sock, &s_cln_out[0], m, &n); s_cln_out.erase(s_cln_out.begin(), s_cln_out.begin() + n); #if defined(TRACE_IO) printf("CLIENT.WROTE[%u]\n", n); #endif // If all data written, then quit watching for write. if (s_cln_out.size() == 0) { handler->mask = SELECTOR_READ; } if (r == MI_RESULT_WOULD_BLOCK) break; TEST_ASSERT(r == MI_RESULT_OK); } else break; } } /* Process read event */ if (mask & SELECTOR_READ) { for (;;) { char buf[BUFFER_SIZE]; size_t n = 0; r = Sock_Read(handler->sock, buf, sizeof(buf), &n); s_cln_in.insert(s_cln_in.end(), buf, buf + n); #if defined(TRACE_IO) printf("CLIENT.READ[%u]\n", n); #endif // All data has been written (check whether it is identical). if (s_cln_in.size() == s_data.size()) { TEST_ASSERT(s_cln_in == s_data); return MI_FALSE; } if (r == MI_RESULT_WOULD_BLOCK) break; TEST_ASSERT(r == MI_RESULT_OK); break; } } if (mask & SELECTOR_REMOVE) { Sock_Close(handler->sock); PAL_Free(handler); handler = 0; } if (mask & SELECTOR_DESTROY) { if (handler) { Sock_Close(handler->sock); PAL_Free(handler); } } return MI_TRUE; }
Figura(string descrip,string descrip2){ vector <string> result; vector <string> result2; int x,y; descrip=descrip.substr(0,descrip.size()-1); descrip2=descrip2.substr(0,descrip2.size()-5); StringExplode(descrip, "{", &result); StringExplode(descrip2, "]", &result2); tam=0; for (int i = 0; i<result.size(); i++){ tam++; result2[i]=result2[i].substr(2,result2[i].size()); vector <string> datos; result[i]=result[i].substr(0,result[i].size()-2); StringExplode(result[i], " ", &datos); vector <string> puntos; datos[0]=datos[0].substr(1,datos[0].size()-1); StringExplode(datos[0], ",", &puntos); x = atoi(puntos[0].c_str() ); y = atoi(puntos[1].c_str() ); vector <string> caract; StringExplode(result2[i], ",", &caract); string conexion; string curvatura; string longitud; string convexidad; int con, cu, lo, co; conexion=caract[0]; curvatura = caract[1]; convexidad = caract[3]; longitud = caract[2]; if (convexidad.compare("convex")==0){ co=1; } else{ co=0; } if (curvatura.compare("very_acute")==0){ cu=1; } else if (curvatura.compare("acute")==0){ cu=2; } else if (curvatura.compare("right")==0){ cu=3; } else if (curvatura.compare("obtuse")==0){ cu=4; } else if (curvatura.compare("very_obtuse")==0){ cu=5; } else{ cerr<<"Error curvatura desconocida"<<curvatura<<endl; } if (conexion.compare("line-line")==0){ con=1; } else{ con=0; } if (longitud.compare("msh")==0){ lo=0; } else if (longitud.compare("hl")==0){ lo=1; } else if (longitud.compare("qsh")==0){ lo=2; } else if (longitud.compare("sl")==0){ lo=3; } else if (longitud.compare("ql")==0){ lo=4; } else if (longitud.compare("dl")==0){ lo=5; } else if (longitud.compare("ml")==0){ lo=6; } else{ cerr<<"Error longitud desconocida:"<<longitud<<endl; } Vertice ver(x, y, con, cu, lo, co); vertices.push_back(ver); } int eje = 0; int min = vertices[0].pos->y; for (int i = 1; i< vertices.size(); i++){ if (abs(vertices[eje].pos->y - vertices[i].pos->y) <= UMBRAL && vertices[i].pos->x < vertices[eje].pos->x) eje = i; } Posicion peje (vertices[eje].pos->x, vertices[eje].pos->y); while (!vertices[0].pos->EsIgual(peje)){ Vertice aux (vertices[tam-1].pos->x, vertices[tam-1].pos->y, vertices[tam-1].conexion, vertices[tam-1].curvatura, vertices[tam-1].longitud, vertices[tam-1].convexidad); vertices.pop_back(); vector<Vertice>::iterator it; it=vertices.begin(); vertices.insert(it, aux); } }
// Encrypt data in vector void RC5Simple::RC5_Encrypt(vector<unsigned char> &in, vector<unsigned char> &out) { // Clear output vector out.clear(); // No crypt null data if(in.size()==0) return; // Save input data size unsigned int clean_data_size=in.size(); RC5_LOG(( "Input data size: %d\n", clean_data_size )); // IV block unsigned char iv[RC5_BLOCK_LEN]; for(int i=0; i<RC5_BLOCK_LEN; i++) iv[i]=(unsigned char)RC5_Rand(0, 0xFF); // Block with data size unsigned char data_size[RC5_BLOCK_LEN]; for(int i=0; i<RC5_BLOCK_LEN; i++) { data_size[i]=RC5_GetByteFromInt( clean_data_size, i ); RC5_LOG(( "Data size byte %d: %.2X\n", i, data_size[i] )); } // Insert data size to begin data in.insert( in.begin(), RC5_BLOCK_LEN, 0); for(int i=0; i<RC5_BLOCK_LEN; i++) in[i]=data_size[i]; // Align end of data to block size int last_unalign_len=clean_data_size%RC5_BLOCK_LEN; RC5_LOG(( "Last unalign len: %d\n", last_unalign_len )); if(last_unalign_len>0) { // Add random data to end for align to block size for(int i=0; i<(RC5_BLOCK_LEN-last_unalign_len); i++) { RC5_LOG(( "Add byte: %d\n", i )); in.push_back( (unsigned char)RC5_Rand(0, 0xFF) ); } } #if RC5_ENABLE_DEBUG_PRINT==1 RC5_LOG(( "Data size after crypt setup: %d\n", in.size() )); RC5_LOG(( "Plain byte after crypt setup: " )); for(int i=0; i<in.size(); i++) RC5_LOG(( "%.2X ", in[i] )); RC5_LOG(( "\n" )); #endif // ------ // Encode // ------ // Create cell in output vector out.resize(in.size()+RC5_BLOCK_LEN, 0); // Save start IV to first block in output data for(int i=0; i<RC5_BLOCK_LEN; i++) out[i]=iv[i]; // Set secret key for encrypt RC5_Setup(rc5_key); // Encode by blocks unsigned int block=0; while( (RC5_BLOCK_LEN*(block+1))<=in.size() ) { unsigned int shift=block*RC5_BLOCK_LEN; // Temp input buffer for dont modify input data unsigned char temp_in[RC5_BLOCK_LEN]; // XOR block with current IV for(int i=0; i<RC5_BLOCK_LEN; i++) temp_in[i]=in[shift+i] ^ iv[i]; RC5_TWORD temp_word_1; RC5_TWORD temp_word_2; RC5_TWORD pt[RC5_WORDS_IN_BLOCK]; RC5_TWORD ct[RC5_WORDS_IN_BLOCK]; RC5_LOG(( "Block num %d, shift %d\n", block, shift )); temp_word_1=RC5_GetWordFromByte(temp_in[0], temp_in[1], temp_in[2], temp_in[3]); temp_word_2=RC5_GetWordFromByte(temp_in[RC5_WORD_LEN+0], temp_in[RC5_WORD_LEN+1], temp_in[RC5_WORD_LEN+2], temp_in[RC5_WORD_LEN+3]); pt[0]=temp_word_1; pt[1]=temp_word_2; // Encode RC5_EncryptBlock(pt, ct); #if RC5_ENABLE_DEBUG_PRINT==1 RC5_LOG(( "Pt %.8X, %.8X\n", pt[0], pt[1] )); RC5_LOG(( "Ct %.8X, %.8X\n", ct[0], ct[1] )); #endif // Save crypt data for(int i=0; i<RC5_WORD_LEN; i++) { // Save crypt data with shift to RC5_BLOCK_LEN // btw. in first block putted IV out[RC5_BLOCK_LEN+shift+i]=RC5_GetByteFromWord(ct[0], i); out[RC5_BLOCK_LEN+shift+RC5_WORD_LEN+i]=RC5_GetByteFromWord(ct[1], i); } // Generate next IV for Cipher Block Chaining (CBC) for(int i=0; i<RC5_BLOCK_LEN; i++) iv[i]=out[RC5_BLOCK_LEN+shift+i]; block++; } // Cleaning IV for(int i=0; i<RC5_BLOCK_LEN; i++) iv[i]=0; // ----------------------------------- // Return input vector to firsted data // ----------------------------------- // Clear input vector from service data in.erase(in.begin(), in.begin()+RC5_BLOCK_LEN); // Remove from input vector last random byte for aligning if(in.size()>clean_data_size) in.erase(in.begin()+clean_data_size, in.end()); }
static void Append(vector<wstring>& toWhat, const WHAT& what) { toWhat.insert(toWhat.end(), what.begin(), what.end()); }