Upload folder using huggingface_hub (part 4)

code/train/C++/0000525_main.cpp

@@ -0,0 +1,176 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <stdio.h>
+#include <time.h>
+#include <algorithm>
+#include <vector>
+#include <map>
+
+// OpenCV headers
+#include <cv.h>
+#include <highgui.h>
+
+#include <opencv2/contrib/contrib.hpp>
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+
+#include <opencv_workbench/utils/Stream.h>
+#include <opencv_workbench/syllo/syllo.h>
+
+#include <opencv_workbench/utils/AnnotationParser.h>
+#include <opencv_workbench/plot/Plot.h>
+
+#include <opencv_workbench/detector/Detector.h>
+#include <opencv_workbench/plugin_manager/PluginManager.h>
+
+#include <opencv_workbench/syllo/syllo.h>
+
+using std::cout;
+using std::endl;
+
+PluginManager<Detector, Detector_maker_t> plugin_manager_;
+
+bool myfunction (std::map<std::string,double> i, std::map<std::string,double> j) 
+{
+     if (i["FPR"] == j["FPR"]) {
+          return (i["TPR"] < j["TPR"]);     
+     } else {
+          return (i["FPR"] < j["FPR"]);     
+     }
+}
+
+int main(int argc, char *argv[])
+{              
+     std::string xml_dir = "";
+     
+     int c;
+     int create_roc_file = 0;
+     int output_file_set = 0;
+     std::string output_file = "";
+     std::string output_dir = "./";
+     while ((c = getopt (argc, argv, "f:o:d:")) != -1) {
+          switch (c) {
+          //case 'a':
+          //     aflag = 1;
+          //     break;
+          //case 'b':
+          //     bflag = 1;
+          //     break;
+          case 'o':
+               output_dir = std::string(optarg);
+               create_roc_file = 1;
+               break;
+          case 'f':
+               output_file = std::string(optarg);
+               output_file_set = 1;
+               break;
+          case 'd':
+               xml_dir = std::string(optarg);
+               break;          
+          case '?':
+               if (optopt == 'd') {
+                    fprintf (stderr, "Option -%c requires an argument.\n", optopt);
+               } else if (isprint (optopt)) {
+                    fprintf (stderr, "Unknown option `-%c'.\n", optopt);
+               } else {
+                    fprintf (stderr,
+                             "Unknown option character `\\x%x'.\n",
+                             optopt);
+               }
+               return 1;
+          default:
+               abort ();
+          }
+     }
+
+     // Check existence of xml directory
+     if ( !boost::filesystem::exists( fs::path(xml_dir) ) ) {
+          cout << "Error: XML Directory doesn't exist." << endl;
+          return -1;
+     }
+     
+     // Open each xml file and count metrics
+     std::vector<fs::path> file_paths;
+     syllo::get_files_with_ext(fs::path(xml_dir), ".xml", 
+                               file_paths,true);   
+     
+          
+     std::vector< std::map<std::string,double> > metrics_vector;
+     
+     int TP = 0, TN = 0, FP = 0, FN = 0;        
+     for (std::vector<fs::path>::iterator it = file_paths.begin(); 
+          it != file_paths.end(); it++) {
+          cout << "File: " << it->string() << endl;          
+          
+          AnnotationParser parser;
+          int retcode = parser.ParseFile(it->string());
+          if (retcode != 0) {
+               cout << "Failed to parse: " << it->string();
+               continue;
+          }
+          std::map<std::string,double> metrics = parser.get_metrics();          
+          
+          metrics_vector.push_back(metrics);          
+     }     
+     
+     std::sort(metrics_vector.begin(), metrics_vector.end(), myfunction);     
+
+     std::string roc_fn;
+     if (output_file_set == 1) {
+          roc_fn = output_dir + "/" + output_file;
+     } else {
+          // time string generation
+          time_t rawtime;
+          struct tm * timeinfo;
+          char buffer [80];     
+          time (&rawtime);
+          timeinfo = localtime (&rawtime);     
+          strftime (buffer,80,"%Y-%m-%d-%H-%M-%S",timeinfo);
+          std::string time_str = std::string(buffer);
+     
+          roc_fn = output_dir + "/" + time_str + "_ROC.csv";
+     }
+     
+     std::ofstream roc_stream;
+     if (create_roc_file) {
+          cout << "ROC Output file: " << roc_fn << endl;
+          roc_stream.open (roc_fn.c_str(), std::ofstream::out);
+          roc_stream << "# FPR,TPR,thresh,FP,FN,TP,TN," << endl;
+     }
+
+     for(std::vector< std::map<std::string,double> >::iterator it = metrics_vector.begin();
+         it != metrics_vector.end(); it++) {          
+          
+          // 0 for threshold place holder for now: TODO
+          roc_stream << (*it)["FPR"] <<","<< (*it)["TPR"] << ",0,"
+                     << (*it)["FP"] <<","<< (*it)["FN"] <<","
+                     << (*it)["TP"] <<","<< (*it)["TN"] <<","
+                     << endl;
+          
+          TP += (*it)["TP"];
+          TN += (*it)["TN"];
+          FP += (*it)["FP"];
+          FN += (*it)["FN"];
+     }
+     
+     roc_stream.close();
+     
+     double TPR = 0, FPR = 0;
+     
+     TPR = (double)TP / (double)(TP + FN) ; 
+     FPR = (double)FP / (double)(FP + TN) ;      
+     
+     // Display results
+     syllo::fill_line("+");
+     cout << "Totals... " << endl;
+     cout << "True Positives: " << TP << endl;
+     cout << "True Negatives: " << TN << endl;
+     cout << "False Positives: " << FP << endl;
+     cout << "False Negatives: " << FN << endl;     
+     cout << "True Positive Rate: " << TPR << endl;
+     cout << "False Positive Rate: " << FPR << endl;
+     syllo::fill_line("+");               
+          
+     return 0;
+}

code/train/C++/0000584_main.cpp

@@ -0,0 +1,170 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** BSD License Usage
+** Alternatively, you may use this file under the terms of the BSD license
+** as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of The Qt Company Ltd nor the names of its
+**     contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtGui>
+
+#include "rasterwindow.h"
+
+//! [5]
+class AnalogClockWindow : public RasterWindow
+{
+public:
+    AnalogClockWindow();
+
+protected:
+    void timerEvent(QTimerEvent *) override;
+    void render(QPainter *p) override;
+
+private:
+    int m_timerId;
+};
+//! [5]
+
+
+//! [6]
+AnalogClockWindow::AnalogClockWindow()
+{
+    setTitle("Analog Clock");
+    resize(200, 200);
+
+    m_timerId = startTimer(1000);
+}
+//! [6]
+
+//! [7]
+void AnalogClockWindow::timerEvent(QTimerEvent *event)
+{
+    if (event->timerId() == m_timerId)
+        renderLater();
+}
+//! [7]
+
+//! [1] //! [14]
+void AnalogClockWindow::render(QPainter *p)
+{
+//! [14]
+//! [8]
+    static const QPoint hourHand[3] = {
+        QPoint(7, 8),
+        QPoint(-7, 8),
+        QPoint(0, -40)
+    };
+    static const QPoint minuteHand[3] = {
+        QPoint(7, 8),
+        QPoint(-7, 8),
+        QPoint(0, -70)
+    };
+
+    QColor hourColor(127, 0, 127);
+    QColor minuteColor(0, 127, 127, 191);
+//! [8]
+
+//! [9]
+    p->setRenderHint(QPainter::Antialiasing);
+//! [9] //! [10]
+    p->translate(width() / 2, height() / 2);
+
+    int side = qMin(width(), height());
+    p->scale(side / 200.0, side / 200.0);
+//! [1] //! [10]
+
+//! [11]
+    p->setPen(Qt::NoPen);
+    p->setBrush(hourColor);
+//! [11]
+
+//! [2]
+    QTime time = QTime::currentTime();
+
+    p->save();
+    p->rotate(30.0 * ((time.hour() + time.minute() / 60.0)));
+    p->drawConvexPolygon(hourHand, 3);
+    p->restore();
+//! [2]
+
+//! [12]
+    p->setPen(hourColor);
+
+    for (int i = 0; i < 12; ++i) {
+        p->drawLine(88, 0, 96, 0);
+        p->rotate(30.0);
+    }
+//! [12] //! [13]
+    p->setPen(Qt::NoPen);
+    p->setBrush(minuteColor);
+//! [13]
+
+//! [3]
+    p->save();
+    p->rotate(6.0 * (time.minute() + time.second() / 60.0));
+    p->drawConvexPolygon(minuteHand, 3);
+    p->restore();
+//! [3]
+
+//! [4]
+    p->setPen(minuteColor);
+
+    for (int j = 0; j < 60; ++j) {
+        if ((j % 5) != 0)
+            p->drawLine(92, 0, 96, 0);
+        p->rotate(6.0);
+    }
+//! [4]
+}
+
+int main(int argc, char **argv)
+{
+    QGuiApplication app(argc, argv);
+
+    AnalogClockWindow clock;
+    clock.show();
+
+    return app.exec();
+}

code/train/C++/0000623_asgn8.cpp

@@ -0,0 +1,263 @@
+/******************************************************************************
+CSCI 240 - Program 7 - Spring 2008
+
+Name: Joe Dan Parker
+Z-Number: 158012
+Section: 8
+TA: Kalpana Mangalarapu
+
+Purpose: Create a program that will analyze three types of household utility
+         expenses (gas, electricity and water) over 12 months.
+******************************************************************************/
+
+#include <iostream>
+#include <iomanip>
+#include <fstream>
+
+using namespace std;
+	
+// I initialized these variables outside of any function, so that they are available to the entire program, not just within any one scope.
+string caption;
+
+int numScores;
+
+double mean;
+int median;
+int hi;
+int lo;
+	
+int ar[200];
+
+/* Function Prototypes */
+
+int buildArray( int[] );
+
+void showArray( string, int[], int );
+
+void sortArray( int[], int );
+
+void doStatsRef( int[], int, double&, int&, int&, int& );
+
+void meanAndMedianRef( int[], int, double&, int& );
+
+void hiAndLoRef( int[], int, int&, int& );
+
+double calcAverage( int[], int );
+
+int calcMedian( int[], int );
+
+int calcLo( int[], int );
+
+int calcHi( int[], int);
+
+void getScores(int[], int, int[]);
+
+int main()
+  {
+  int counts[6] = {0,0,0,0,0};
+  
+  numScores = buildArray( ar );
+  
+  showArray( "*** Scores ***", ar, numScores );
+  
+  doStatsRef( ar, numScores, mean, median, hi, lo );
+  
+  getScores( ar, numScores, counts );
+  
+  cout << "Mean = " << mean << endl;
+  cout << "Median = " << median << endl;
+  cout << "Highest Score = " << hi << endl;
+  cout << "Lowest Score = " << lo << endl;
+  cout << endl;
+  cout << "Number of A's = " << counts[0] << endl;
+  cout << "Number of B's = " << counts[1] << endl;
+  cout << "Number of C's = " << counts[2] << endl;
+  cout << "Number of D's = " << counts[3] << endl;
+  cout << "Number of E's = " << counts[4] << endl;
+  cout << "Number of F's = " << counts[5] << endl;
+  }
+
+/**********  Code your Functions below this line  **********/
+
+int buildArray( int ar[] )
+  {
+  ifstream inFile;
+  
+  int i = 0,
+  	  num;
+  
+  inFile.open("scores.txt");
+  if (inFile.fail())
+    {
+    cout << "Unable to open scores.txt file\n";
+    exit(1);
+    }
+  inFile >> num;
+   
+  while ( inFile )
+    {
+	ar[i] = num;
+	i++;
+	inFile >> num;
+	}
+	
+  inFile.close();
+  return i;
+  }
+
+void showArray( string caption, int ar[], int numScores )
+  {
+  int temp_int = 0,
+  	  i;
+  
+  cout << caption << endl << endl;
+  
+  while ( temp_int < numScores )
+    {
+	for (i = 1; i <= 8; i++ )
+      {
+	  if ( ar[temp_int] != 0 )
+	  {
+	  cout << ar[temp_int] << ' ';
+	  temp_int ++;
+	  }
+	  }
+	  cout << endl;
+	}
+  cout << endl << temp_int + 1 << " Scores" << endl << endl;
+  }
+
+void sortArray(int ar[], int numScores)
+  {
+  int i, j;
+  int max;
+  int temp;
+
+  for (i = 0; i <= numScores; i++)
+  {
+    max = i;
+    for (j = i+1; j <= numScores; j++)
+    {
+      if (ar[j] > ar[max])
+        max = j;
+    }
+    temp = ar[i];
+    ar[i] = ar[max];
+    ar[max] = temp;
+    }
+  }
+  
+void doStatsRef( int ar[], int numScores, double & mean, int & median, int & hi, int & lo )
+  {
+  int sortedAr[200],
+  i;
+  
+  for (i = 0; i <= 200; i++)
+    {
+	sortedAr[i] = ar[i];
+	}
+  sortArray( sortedAr, numScores );
+  
+  meanAndMedianRef( sortedAr, numScores, mean, median );
+  
+  hiAndLoRef( sortedAr, numScores, hi, lo );
+  }
+  
+void meanAndMedianRef( int sortedAr[], int numScores, double & mean, int & median )
+  {
+  mean = calcAverage(sortedAr, numScores);
+  
+  median = calcMedian(sortedAr, numScores);  
+  }
+  
+void hiAndLoRef( int sortedAr[], int numScores, int& hi, int& lo )
+  {
+  hi = calcHi( sortedAr, numScores );
+  
+  lo = calcLo( sortedAr, numScores );
+  }
+  
+double calcAverage( int sortedAr[], int numScores )
+  {
+  int i;
+  
+  int temp_int = 0;
+  
+  for ( i = 1; i <= numScores; i ++ )
+    {
+    temp_int += sortedAr[i];
+	}
+	return ((double) temp_int / (double) numScores);
+  }
+  
+int calcMedian( int sortedAr[], int numScores )
+  {
+  return sortedAr[(( numScores / 2 ) + 1)];
+  }
+
+int calcHi( int ar[], int numScores )
+  {
+  int i,
+      j = 1;
+  
+  int temp_int = 0;
+  
+  for ( i = 0; i <= numScores; i ++ )
+    {
+    if (ar[j] < ar[i])
+	  {
+	  ar[j] = ar[i];
+	  }
+	}
+  return ar[j];
+  }
+
+int calcLo( int ar[], int numScores )
+  {
+  int i,
+      j = 1;
+  
+  double temp_int = 0;
+  
+  for ( i = 0; i <= numScores; i ++ )
+    {
+    if (ar[j] > ar[i])
+	  {
+	  ar[j] = ar[i];
+	  }
+	}
+  return ar[j];
+  }  
+
+void getScores ( int sortedAr[], int numScores, int counts[] )
+  {
+  int i;
+  for (i = 0; i <= numScores; i++)
+    {
+	if ( sortedAr[i] >= 90 )
+	  {
+	  counts[0]++;
+	  }
+	  else if ( sortedAr[i] < 90 && sortedAr[i] >= 80 )
+	    {
+		counts[1]++;
+		}
+		else if ( sortedAr[i] < 80 && sortedAr[i] >= 70 )
+	      {
+	  	  counts[2]++;
+	  	  }
+		  else if ( sortedAr[i] < 70 && sortedAr[i] >= 60 )
+	        {
+	    	counts[3]++;
+	    	}
+		    else if ( sortedAr[i] < 60 && sortedAr[i] >= 50 )
+	          {
+	      	  counts[4]++;
+	      	  }
+		      if ( sortedAr[i] < 50 )
+	            {
+	            counts[5]++;
+	            }
+    }
+  }
+

code/train/C++/0000658_DoAHeuristicPreferredAngle.cpp

@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * This file is part of openWNS (open Wireless Network Simulator)
+ * _____________________________________________________________________________
+ *
+ * Copyright (C) 2004-2009
+ * Chair of Communication Networks (ComNets)
+ * Kopernikusstr. 5, D-52074 Aachen, Germany
+ * phone: ++49-241-80-27910,
+ * fax: ++49-241-80-22242
+ * email: info@openwns.org
+ * www: http://www.openwns.org
+ * _____________________________________________________________________________
+ *
+ * openWNS is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License version 2 as published by the
+ * Free Software Foundation;
+ *
+ * openWNS is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ******************************************************************************/
+
+#include "DoAHeuristicPreferredAngle.hpp"
+
+#include <WNS/pyconfig/View.hpp>
+#include <WNS/StaticFactory.hpp>
+
+#include <list>
+#include <math.h>
+#include <algorithm>
+
+using namespace wns::scheduler;
+using namespace wns::scheduler::grouper;
+
+
+STATIC_FACTORY_REGISTER_WITH_CREATOR(DoAHeuristicPreferredAngle, GroupingProviderInterface, "DoAHeuristicPreferredAngle", wns::PyConfigViewCreator);
+
+
+DoAHeuristicPreferredAngle::DoAHeuristicPreferredAngle(const wns::pyconfig::View& config)
+	: DoATreeBasedGrouper(config),
+	  minAngle(config.get<float>("minAngleDegree")*M_PI/180.0),
+	  weight(config.get<float>("weight"))
+{
+}
+
+
+float
+DoAHeuristicPreferredAngle::groupingCostForAUser(UserSet group, UserID newUser) {
+	float cost = 0.0;
+	float threshold = minAngle;
+//	float threshold = 20.0 / 180.0 * M_PI;
+	float penalty = 1000.0;
+	float min = M_PI;
+
+	float newUserDoA = getNormalizedDoA(newUser);
+
+// 	if (Debug)
+// 		std::cout << "New user at " << rad2deg(newUserDoA) << " degrees\n";
+
+	for (UserSet::const_iterator iter = group.begin();
+		 iter != group.end(); ++iter) {
+		float userDoA = getNormalizedDoA(*iter);
+
+// 		if (Debug)
+// 			std::cout << "Group user at " << rad2deg(userDoA) << " degrees\n";
+
+		float diff = userDoA - newUserDoA;
+		// normalize angles to [0.0, M_PI]
+		if (diff < 0.0)
+			diff = diff + 2*M_PI;
+		if (diff > M_PI)
+			diff = 2*M_PI - diff;
+
+		if (fabs(diff) < min)
+			min = fabs(diff);
+	}
+
+// 	if (Debug)
+// 		std::cout << "Minimum " << rad2deg(min) << " degrees\n";
+
+    // calculate cost to add user
+	if (min < threshold)
+		cost = penalty;
+	else
+	{
+		// 0..threshold verboten
+		// threshold .. 2.5X threshold erwuenscht mit minimalen kosten bei 2x
+		// threshold. von 2.5x threshold bis 180 konstanter langsam wachsender
+		// wert auf 1+mincost
+
+		float minCost = threshold / M_PI;
+		if (min < 2.5*threshold)
+			cost = weight*(fabs(min-2*threshold)/threshold+minCost);
+		else
+			// fange bei 2.5*th mit 0.5+minCost an, dann steiger dich auf
+			// 1+minCost bei M_PI
+			cost = weight*((min-2.5*threshold)*(0.5/(M_PI-2.5*threshold)) +0.5+minCost );
+
+	}
+
+// 	if (Debug)
+// 		std::cout << "Resulting in cost of " << cost << " \n\n";
+
+	return cost;
+}
+
+
+
+
+
+

code/train/C++/0000762_statistic.cpp

@@ -0,0 +1,16 @@
+#include <iostream>
+#include <cstdio>
+using namespace std;
+#define INF 0x3f3f3f3f
+int main() {
+    int n = 0, mmin = INF, mmax = -INF, sum = 0;
+    int x;
+    while(scanf("%d", &x) == 1){
+        n ++;
+        sum += x;
+        if(x > mmax) mmax = x;
+        if(x < mmin) mmin = x;
+    }
+    printf("%d %d %.3f",mmin, mmax, (double)sum / n);
+    return 0;
+}

code/train/C++/0000894_7771448.cpp

@@ -0,0 +1,110 @@
+//Language: GNU C++
+
+
+#include<cstdio>
+#include<set>
+#include<cstring>
+#include<iostream>
+#include<stdlib.h>
+#include<vector>
+#include<map>
+#include<stack>
+#include<algorithm>
+#include<queue>
+#include<cmath>
+#include<functional>
+#include<string>
+#include<assert.h>
+using namespace std;
+
+#define LL long long
+#define uLL unsigned long long
+#define B puts("^_^");
+#define FILEIN freopen("in", "r", stdin);
+#define MP make_pair
+#define PB push_back
+#define fi first
+#define se second
+#define PI pair<int, int>
+#define VI vector<int>
+#define FOR(i, x, y) for(int i=(x); i<(y); ++i) 
+#define F(x) for(int i=0; i<(x); ++i)
+#define F1(x) for(int i=1; i<=(x); ++i)
+#define FJ(x) for(int j=0; j<(x); ++j)
+#define FJ1(x) for(int j=1; j<=(x); ++j)
+#define FK(x) for(int k=0; k<=(x); ++k)
+#define lson (u<<1)
+#define rson (u<<1|1)
+const int N=500005;
+const int INF=0x3f3f3f3f;
+//const int M=7+1e9;
+inline int IN() {int x; scanf("%d", &x); return x;}
+#define GET(x) int x=IN()
+inline void OUT(int x) {printf("%d\n", x);}
+
+int fst[N], nxt[N], from[N], to[N], w[N], h;
+#define bian for(int i=fst[u]; ~i; i=nxt[i])
+void jiabian(int u, int v, int x){
+	nxt[h]=fst[u], from[h]=u, to[h]=v, w[h]=x, fst[u]=h++;
+}
+
+int n, m;
+int d[N], t[N][20], _t[N];
+int fa[N][20];
+VI ch[N];
+vector<pair<int, int> > query;
+int zuo[N];
+int _root[N];
+
+void dfs(int u, int f){
+	if(f==-1) fa[u][0]=u, d[u]=0;
+	else t[u][0]=_t[u], fa[u][0]=f, d[u]=d[f]+1;
+	F1(19) fa[u][i]=fa[fa[u][i-1]][i-1], t[u][i]=max(t[fa[u][i-1]][i-1], t[u][i-1]);
+	int sz=ch[u].size();
+	F(sz){
+		int v=ch[u][i];
+		dfs(v, u);
+	}
+}
+
+int get(int u, int d){
+	F(20) if(d&(1<<i)) u=fa[u][i];
+	return u;
+}
+
+int rmq(int u, int d){
+	int ret=-1;
+	F(20) if(d&(1<<i)) ret=max(ret, t[u][i]), u=fa[u][i];
+	return ret;
+}
+
+int main(){
+	//FILEIN
+	n=IN(), m=IN();
+	int T=0;
+	F(m){
+		int o=IN();
+		int x, y;
+		if(o==1){
+			x=IN(), y=IN();
+			_t[x]=T, ch[y].PB(x);
+		} else if(o==2){
+			int x=IN();
+			zuo[++T]=x;
+		} else{
+			int x=IN(), y=IN();
+			query.PB(MP(x, y));
+		}
+	}
+	F1(n) FJ(ch[i].size()) _root[ch[i][j]]=1;
+	F1(n) if(!_root[i]) ch[0].PB(i);
+	dfs(0, -1);
+	int sz=query.size();
+	F(sz){
+		int f=query[i].fi, u=zuo[query[i].se];
+		if(d[u]<d[f] || get(u, d[u]-d[f])!=f || rmq(u, d[u]-d[f])>=query[i].se)
+			puts("NO");
+		else puts("YES");
+	}
+	return 0;
+}

code/train/C++/0001490_bip32_tests.cpp

@@ -0,0 +1,154 @@
+// Copyright (c) 2013-2019 TurboCoin
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <boost/test/unit_test.hpp>
+
+#include <key.h>
+#include <key_io.h>
+#include <uint256.h>
+#include <util/system.h>
+#include <util/strencodings.h>
+#include <test/setup_common.h>
+
+#include <string>
+#include <vector>
+
+struct TestDerivation {
+    std::string pub;
+    std::string prv;
+    unsigned int nChild;
+};
+
+struct TestVector {
+    std::string strHexMaster;
+    std::vector<TestDerivation> vDerive;
+
+    explicit TestVector(std::string strHexMasterIn) : strHexMaster(strHexMasterIn) {}
+
+    TestVector& operator()(std::string pub, std::string prv, unsigned int nChild) {
+        vDerive.push_back(TestDerivation());
+        TestDerivation &der = vDerive.back();
+        der.pub = pub;
+        der.prv = prv;
+        der.nChild = nChild;
+        return *this;
+    }
+};
+
+TestVector test1 =
+  TestVector("000102030405060708090a0b0c0d0e0f")
+    ("xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8",
+     "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi",
+     0x80000000)
+    ("xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw",
+     "xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7",
+     1)
+    ("xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHKkNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ",
+     "xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs",
+     0x80000002)
+    ("xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5",
+     "xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM",
+     2)
+    ("xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJAyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV",
+     "xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Tyh8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334",
+     1000000000)
+    ("xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy",
+     "xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76",
+     0);
+
+TestVector test2 =
+  TestVector("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542")
+    ("xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB",
+     "xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U",
+     0)
+    ("xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH",
+     "xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt",
+     0xFFFFFFFF)
+    ("xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ85ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a",
+     "xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYEeEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9",
+     1)
+    ("xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5EwVvmdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon",
+     "xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd25UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef",
+     0xFFFFFFFE)
+    ("xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL",
+     "xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc",
+     2)
+    ("xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt",
+     "xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j",
+     0);
+
+TestVector test3 =
+  TestVector("4b381541583be4423346c643850da4b320e46a87ae3d2a4e6da11eba819cd4acba45d239319ac14f863b8d5ab5a0d0c64d2e8a1e7d1457df2e5a3c51c73235be")
+    ("xpub661MyMwAqRbcEZVB4dScxMAdx6d4nFc9nvyvH3v4gJL378CSRZiYmhRoP7mBy6gSPSCYk6SzXPTf3ND1cZAceL7SfJ1Z3GC8vBgp2epUt13",
+     "xprv9s21ZrQH143K25QhxbucbDDuQ4naNntJRi4KUfWT7xo4EKsHt2QJDu7KXp1A3u7Bi1j8ph3EGsZ9Xvz9dGuVrtHHs7pXeTzjuxBrCmmhgC6",
+      0x80000000)
+    ("xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrADWgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y",
+     "xprv9uPDJpEQgRQfDcW7BkF7eTya6RPxXeJCqCJGHuCJ4GiRVLzkTXBAJMu2qaMWPrS7AANYqdq6vcBcBUdJCVVFceUvJFjaPdGZ2y9WACViL4L",
+      0);
+
+static void RunTest(const TestVector &test) {
+    std::vector<unsigned char> seed = ParseHex(test.strHexMaster);
+    CExtKey key;
+    CExtPubKey pubkey;
+    key.SetSeed(seed.data(), seed.size());
+    pubkey = key.Neuter();
+    for (const TestDerivation &derive : test.vDerive) {
+        unsigned char data[74];
+        key.Encode(data);
+        pubkey.Encode(data);
+
+        // Test private key
+        BOOST_CHECK(EncodeExtKey(key) == derive.prv);
+        BOOST_CHECK(DecodeExtKey(derive.prv) == key); //ensure a base58 decoded key also matches
+
+        // Test public key
+        BOOST_CHECK(EncodeExtPubKey(pubkey) == derive.pub);
+        BOOST_CHECK(DecodeExtPubKey(derive.pub) == pubkey); //ensure a base58 decoded pubkey also matches
+
+        // Derive new keys
+        CExtKey keyNew;
+        BOOST_CHECK(key.Derive(keyNew, derive.nChild));
+        CExtPubKey pubkeyNew = keyNew.Neuter();
+        if (!(derive.nChild & 0x80000000)) {
+            // Compare with public derivation
+            CExtPubKey pubkeyNew2;
+            BOOST_CHECK(pubkey.Derive(pubkeyNew2, derive.nChild));
+            BOOST_CHECK(pubkeyNew == pubkeyNew2);
+        }
+        key = keyNew;
+        pubkey = pubkeyNew;
+
+        CDataStream ssPub(SER_DISK, CLIENT_VERSION);
+        ssPub << pubkeyNew;
+        BOOST_CHECK(ssPub.size() == 75);
+
+        CDataStream ssPriv(SER_DISK, CLIENT_VERSION);
+        ssPriv << keyNew;
+        BOOST_CHECK(ssPriv.size() == 75);
+
+        CExtPubKey pubCheck;
+        CExtKey privCheck;
+        ssPub >> pubCheck;
+        ssPriv >> privCheck;
+
+        BOOST_CHECK(pubCheck == pubkeyNew);
+        BOOST_CHECK(privCheck == keyNew);
+    }
+}
+
+BOOST_FIXTURE_TEST_SUITE(bip32_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(bip32_test1) {
+    RunTest(test1);
+}
+
+BOOST_AUTO_TEST_CASE(bip32_test2) {
+    RunTest(test2);
+}
+
+BOOST_AUTO_TEST_CASE(bip32_test3) {
+    RunTest(test3);
+}
+
+BOOST_AUTO_TEST_SUITE_END()

code/train/C++/0002138_A.cpp

@@ -0,0 +1,34 @@
+// This is a personal academic project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+// PVS-settings
+
+// PVS-settings end
+#include<iostream>
+#include<vector>
+#include<algorithm>
+
+using namespace std;
+
+int main()
+{
+	int n, a, m;
+	cin >> n;
+	vector<pair<int, int> > arr(n);
+	for (int i = 0; i < n; ++i)
+	{
+		cin >> a;
+		arr[i] = make_pair(a, i + 1);
+	}
+	sort(arr.begin(), arr.end());
+	m = 2000000005;
+	for (int i = 1; i < n; ++i)
+		if (arr[i].first - arr[i - 1].first < m)
+		{
+			a = i;
+			m = arr[i].first - arr[i - 1].first;
+		}
+	cout << m << endl <<
+		((arr[a - 1].second > arr[a].second) ? arr[a].second : arr[a - 1].second) << ' ' <<
+		((arr[a - 1].second > arr[a].second) ? arr[a - 1].second : arr[a].second);
+	return 0;
+}

code/train/C++/0002412_authmessagevalidator.cpp

@@ -0,0 +1,117 @@
+/*****************************************************************************
+ * PokerTH - The open source texas holdem engine                             *
+ * Copyright (C) 2006-2012 Felix Hammer, Florian Thauer, Lothar May          *
+ *                                                                           *
+ * This program is free software: you can redistribute it and/or modify      *
+ * it under the terms of the GNU Affero General Public License as            *
+ * published by the Free Software Foundation, either version 3 of the        *
+ * License, or (at your option) any later version.                           *
+ *                                                                           *
+ * This program is distributed in the hope that it will be useful,           *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
+ * GNU Affero General Public License for more details.                       *
+ *                                                                           *
+ * You should have received a copy of the GNU Affero General Public License  *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.     *
+ *                                                                           *
+ *                                                                           *
+ * Additional permission under GNU AGPL version 3 section 7                  *
+ *                                                                           *
+ * If you modify this program, or any covered work, by linking or            *
+ * combining it with the OpenSSL project's OpenSSL library (or a             *
+ * modified version of that library), containing parts covered by the        *
+ * terms of the OpenSSL or SSLeay licenses, the authors of PokerTH           *
+ * (Felix Hammer, Florian Thauer, Lothar May) grant you additional           *
+ * permission to convey the resulting work.                                  *
+ * Corresponding Source for a non-source form of such a combination          *
+ * shall include the source code for the parts of OpenSSL used as well       *
+ * as that of the covered work.                                              *
+ *****************************************************************************/
+
+#include <net/validation/authmessagevalidator.h>
+#include <net/validation/validationhelper.h>
+
+using namespace std;
+
+
+AuthMessageValidator::AuthMessageValidator()
+{
+	m_validationMap.insert(make_pair(AuthMessage_AuthMessageType_Type_AuthClientRequestMessage, ValidateAuthClientRequestMessage));
+	m_validationMap.insert(make_pair(AuthMessage_AuthMessageType_Type_AuthServerChallengeMessage, ValidateAuthServerChallengeMessage));
+	m_validationMap.insert(make_pair(AuthMessage_AuthMessageType_Type_AuthClientResponseMessage, ValidateAuthClientResponseMessage));
+	m_validationMap.insert(make_pair(AuthMessage_AuthMessageType_Type_AuthServerVerificationMessage, ValidateAuthServerVerificationMessage));
+}
+
+bool
+AuthMessageValidator::IsValidMessage(const AuthMessage &msg) const
+{
+	// Default: Invalid packet.
+	bool retVal = false;
+	ValidateFunctorMap::const_iterator pos = m_validationMap.find(msg.messagetype());
+	if (pos != m_validationMap.end()) {
+		// Call validation functor.
+		retVal = pos->second(msg);
+	}
+	return retVal;
+}
+
+bool
+AuthMessageValidator::ValidateAuthClientRequestMessage(const AuthMessage &msg)
+{
+	bool retVal = false;
+	if (msg.has_authclientrequestmessage()) {
+		const AuthClientRequestMessage &request = msg.authclientrequestmessage();
+		if (VALIDATE_IS_UINT16(request.requestedversion().majorversion())
+				&& VALIDATE_IS_UINT16(request.requestedversion().minorversion())
+				&& (!request.has_mylastsessionid() || request.mylastsessionid().size() == 16)
+				&& (!request.has_authserverpassword() || VALIDATE_STRING_SIZE(request.authserverpassword(), 1, 64))
+				&& (!request.has_nickname() || VALIDATE_STRING_SIZE(request.nickname(), 1, 64))
+				&& (!request.has_clientuserdata() || VALIDATE_STRING_SIZE(request.clientuserdata(), 1, 256))
+				&& (!request.has_avatarhash() || request.avatarhash().size() == 16)) {
+
+			retVal = true;
+		}
+	}
+	return retVal;
+}
+
+bool
+AuthMessageValidator::ValidateAuthServerChallengeMessage(const AuthMessage &msg)
+{
+	bool retVal = false;
+	if (msg.has_authserverchallengemessage()) {
+		const AuthServerChallengeMessage &challenge = msg.authserverchallengemessage();
+		if (VALIDATE_STRING_SIZE(challenge.serverchallenge(), 1, 256)) {
+			retVal = true;
+		}
+	}
+	return retVal;
+}
+
+bool
+AuthMessageValidator::ValidateAuthClientResponseMessage(const AuthMessage &msg)
+{
+	bool retVal = false;
+	if (msg.has_authclientresponsemessage()) {
+		const AuthClientResponseMessage &response = msg.authclientresponsemessage();
+		if (VALIDATE_STRING_SIZE(response.clientresponse(), 1, 256)) {
+			retVal = true;
+		}
+	}
+	return retVal;
+}
+
+bool
+AuthMessageValidator::ValidateAuthServerVerificationMessage(const AuthMessage &msg)
+{
+	bool retVal = false;
+	if (msg.has_authserververificationmessage()) {
+		const AuthServerVerificationMessage &verification = msg.authserververificationmessage();
+		if (VALIDATE_STRING_SIZE(verification.serververification(), 1, 256)) {
+			retVal = true;
+		}
+	}
+	return retVal;
+}
+

code/train/C++/0002530_AppMoblet.cpp

@@ -0,0 +1,285 @@
+/* Copyright 2013 David Axmark
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+ * @file AppMoblet.cpp
+ * @author Bogdan Iusco
+ *
+ * AppMoblet class shows how to:
+ * - open and close contacts list.
+ * - create contact item.
+ * - remove contact item from the list.
+ */
+
+// Minimum number of values for drag events.
+#define MIN_DRAG_VALUES 5
+
+#include <conprint.h>
+#include <IX_PIM.h>
+#include <maapi.h>
+
+#include "AppMoblet.h"
+#include "Util.h"
+#include "PIMContact.h"
+
+/**
+ * Constructor.
+ */
+AppMoblet::AppMoblet() :
+	Moblet(),
+	mHandlePointerEvent(false)
+{
+	this->startPIM();
+}
+
+/**
+ * Destructor.
+ */
+AppMoblet::~AppMoblet()
+{
+
+}
+
+/**
+ *  This function is called with a coordinate when a pointer is moved.
+ */
+void AppMoblet::pointerMoveEvent(MAPoint2d point)
+{
+	if (mHandlePointerEvent)
+	{
+		mDragValues.add(point.x);
+	}
+}
+
+/**
+ *  This function is called with a coordinate when a pointer is released.
+ */
+void AppMoblet::pointerReleaseEvent(MAPoint2d point)
+{
+	// Handle this event only if no PIM action is on progress.
+	if (mHandlePointerEvent)
+	{
+		// Check if there are enough drag events for analysis.
+		if (MIN_DRAG_VALUES > mDragValues.size())
+		{
+			return;
+		}
+
+		// Check if drag is from left to right of from right to left.
+		bool dragFromLeftToRight = true;
+		bool dragFromRightToLeft = true;
+		int previousValue = mDragValues[0];
+		for (int i = 1; (i < mDragValues.size()) && (dragFromLeftToRight
+			|| dragFromRightToLeft); i++)
+		{
+			int currentValue = mDragValues[i];
+			if (previousValue > currentValue)
+			{
+				dragFromLeftToRight = false;
+			}
+			if (previousValue < currentValue)
+			{
+				dragFromRightToLeft = false;
+			}
+
+			previousValue = currentValue;
+		}
+
+		// If drag is from left to right print the next contact, otherwise
+		// close the PIM contacts list.
+		if (dragFromLeftToRight)
+		{
+			this->printNextContact();
+		}
+		else if (dragFromRightToLeft)
+		{
+			this->closePIMContactsList();
+		}
+	}
+}
+
+/**
+ * Called when the screen is touched.
+ */
+void AppMoblet::pointerPressEvent(MAPoint2d point)
+{
+	if (mHandlePointerEvent)
+	{
+		mDragValues.clear();
+	}
+}
+
+/**
+ * Method called when a key is pressed.
+ */
+void AppMoblet::keyPressEvent(int keyCode, int nativeCode)
+{
+    // Close the application if the back key is pressed.
+    if(MAK_BACK == keyCode)
+    {
+        close();
+    }
+}
+
+/**
+ * Start working with PIM.
+ * Add, modify and remove a PIM contact.
+ */
+void AppMoblet::startPIM()
+{
+	// Open PIM contacts list.
+	this->openPIMContactsList();
+
+	// Create new contact and add data into fields.
+	PIMContact* newContact = this->createContact();
+	if (NULL == newContact)
+	{
+		return;
+	}
+	newContact->addDataToContact();
+
+	// Modify the new contact.
+	this->modifyContact(newContact);
+
+	// Remove the new contact from the list and delete the object.
+	this->removeContact(newContact);
+	delete newContact;
+
+	// Print options on the screen and wait for drag events.
+	this->printInfo();
+}
+
+/**
+ * Open PIM contacts list.
+ */
+void AppMoblet::openPIMContactsList()
+{
+	printf("\n==============Open contacts list===============");
+
+	// Get a handle to the list of contacts.
+	mContactsListHandle = maPimListOpen(MA_PIM_CONTACTS);
+	checkResultCode(mContactsListHandle);
+}
+
+/**
+ * Print the next contact from the PIM contacts list.
+ */
+void AppMoblet::printNextContact()
+{
+	// Ignore all drag events handled by this moblet.
+	mHandlePointerEvent = false;
+
+	printf("\n=============Printing next contact=============\n");
+
+	// Get a hold on a contact item.
+	MAHandle pimItemHandle = maPimListNext(mContactsListHandle);
+
+	// Check if the new contact handle is valid.
+	if (0 < pimItemHandle)
+	{
+		// Create new contact item and print it on the screen.
+		PIMContact* item = new PIMContact(pimItemHandle);
+		item->printContact();
+		delete item;
+	}
+	else if (pimItemHandle == 0)
+	{
+		// Reached at the end of the list.
+		printf("The contacts list does not contain more items.");
+	}
+	else
+	{
+		// Print the error on the screen.
+		printResultCode(pimItemHandle);
+	}
+
+	// Print options on the screen and wait for drag events.
+	this->printInfo();
+}
+
+/**
+ * Create a new contact.
+ * @return The new created contact, or NULL in case of error.
+ * The ownership of the result is passed to the caller.
+ */
+PIMContact* AppMoblet::createContact()
+{
+	// Get a handle to the new created contact.
+	printf("\n==============Create new contact==============\n");
+	MAHandle newContantHandle = maPimItemCreate(mContactsListHandle);
+
+	// Check for errors.
+	if (0 > newContantHandle)
+	{
+		printf("Cann't create new contact.");
+		printResultCode(newContantHandle);
+		return NULL;
+	}
+
+	// Create and return the new contact.
+	PIMContact* newContact = new PIMContact(newContantHandle);
+	return newContact;
+}
+
+/**
+ * Modify the address field of a specified contact.
+ * Remove the first value from the phone field.
+ * @param contact The given contact item.
+ */
+void AppMoblet::modifyContact(PIMContact* contact)
+{
+	contact->modifyAddressField();
+
+	printf("\n====Remove field value from the new contact====\n");
+	contact->removeFieldValue(MA_PIM_FIELD_CONTACT_TEL, 0);
+}
+
+/**
+ * Remove a specified contact from the list.
+ * It also closes the item.
+ * @param contact The given contact item.
+ */
+void AppMoblet::removeContact(PIMContact* contact)
+{
+	printf("\n===========Remove the new contact=============\n");
+	int resultCode = maPimItemRemove(mContactsListHandle, contact->getHandle());
+	printResultCode(resultCode);
+}
+
+/**
+ * Close the PIM contacts list.
+ */
+void AppMoblet::closePIMContactsList()
+{
+	printf("\n ==============Close the contacts list=========\n");
+	printResultCode(maPimListClose(mContactsListHandle));
+
+	// Start again working with PIM>
+	this->startPIM();
+}
+
+/**
+ * Print show next contact / close pim list options on the screen.
+ */
+void AppMoblet::printInfo()
+{
+	printf("\n==============================================");
+	printf("Drag from left to right to show the next \n contact");
+	printf("Drag from right to left to close the contacts \n list");
+	printf("==============================================\n\n");
+
+	// Allow this moblet to handle pointer events.
+	mHandlePointerEvent = true;
+}

code/train/C++/0002981_vcardmanager.cpp

@@ -0,0 +1,127 @@
+/*
+  Copyright (c) 2006-2009 by Jakob Schroeter <js@camaya.net>
+  This file is part of the gloox library. http://camaya.net/gloox
+
+  This software is distributed under a license. The full license
+  agreement can be found in the file LICENSE in this distribution.
+  This software may not be copied, modified, sold or distributed
+  other than expressed in the named license agreement.
+
+  This software is distributed without any warranty.
+*/
+
+
+#include "vcardmanager.h"
+#include "vcardhandler.h"
+#include "vcard.h"
+#include "clientbase.h"
+#include "disco.h"
+#include "error.h"
+
+namespace gloox
+{
+
+  VCardManager::VCardManager( ClientBase* parent )
+    : m_parent( parent )
+  {
+    if( m_parent )
+    {
+      m_parent->registerIqHandler( this, ExtVCard );
+      m_parent->disco()->addFeature( XMLNS_VCARD_TEMP );
+      m_parent->registerStanzaExtension( new VCard() );
+    }
+  }
+
+  VCardManager::~VCardManager()
+  {
+    if( m_parent )
+    {
+      m_parent->disco()->removeFeature( XMLNS_VCARD_TEMP );
+      m_parent->removeIqHandler( this, ExtVCard );
+      m_parent->removeIDHandler( this );
+    }
+  }
+
+  void VCardManager::fetchVCard( const JID& jid, VCardHandler* vch )
+  {
+    if( !m_parent || !vch )
+      return;
+
+    TrackMap::const_iterator it = m_trackMap.find( jid.bare() );
+    if( it != m_trackMap.end() )
+      return;
+
+    const std::string& id = m_parent->getID();
+    IQ iq ( IQ::Get, jid, id );
+    iq.addExtension( new VCard() );
+
+    m_trackMap[id] = vch;
+    m_parent->send( iq, this,VCardHandler::FetchVCard  );
+  }
+
+  void VCardManager::cancelVCardOperations( VCardHandler* vch )
+  {
+    TrackMap::iterator t;
+    TrackMap::iterator it = m_trackMap.begin();
+    while( it != m_trackMap.end() )
+    {
+      t = it;
+      ++it;
+      if( (*t).second == vch )
+        m_trackMap.erase( t );
+    }
+  }
+
+  void VCardManager::storeVCard( VCard* vcard, VCardHandler* vch )
+  {
+    if( !m_parent || !vch )
+      return;
+
+    const std::string& id = m_parent->getID();
+    IQ iq( IQ::Set, JID(), id );
+    iq.addExtension( vcard );
+
+    m_trackMap[id] = vch;
+    m_parent->send( iq, this, VCardHandler::StoreVCard );
+  }
+
+  void VCardManager::handleIqID( const IQ& iq, int context )
+  {
+    TrackMap::iterator it = m_trackMap.find( iq.id() );
+    if( it != m_trackMap.end() )
+    {
+      switch( iq.subtype() )
+      {
+        case IQ::Result:
+        {
+          switch( context )
+          {
+            case VCardHandler::FetchVCard:
+            {
+              const VCard* v = iq.findExtension<VCard>( ExtVCard );
+              (*it).second->handleVCard( iq.from(), v );
+              break;
+            }
+            case VCardHandler::StoreVCard:
+              (*it).second->handleVCardResult( VCardHandler::StoreVCard, iq.from() );
+              break;
+          }
+        }
+        break;
+        case IQ::Error:
+        {
+          (*it).second->handleVCardResult( (VCardHandler::VCardContext)context,
+                                           iq.from(),
+                                           iq.error() ? iq.error()->error()
+                                                       : StanzaErrorUndefined );
+          break;
+        }
+        default:
+          break;
+      }
+
+      m_trackMap.erase( it );
+    }
+  }
+
+}

code/train/C++/0003712_PEMer_Lite.cpp

@@ -0,0 +1,267 @@
+/*
+Name: saminput
+Author: Lars Zerbe <larszerbe@live.de>
+Author: Stephan Peter <s.peter@fu-berlin.de>
+Maintainer: Lars Zerbe <larszerbe@live.de>
+License: GPL v3
+Copyright: 2008-2012, FU Berlin
+Status: under development
+*/
+
+#include "PEMer_Lite.h"
+
+
+bool candidateSortFunction(candidate &x, candidate &y)
+{
+	try{return (x.pos < y.pos);}
+	catch(std::exception allgemeineException){return false;}
+}
+
+int samSort(candidates &save)
+{
+	std::cout << "samSort" << std::endl;
+	std::sort(save.begin(),save.end(),candidateSortFunction);
+
+	return 0;
+}
+
+seqan::ArgumentParser::ParseResult commands(modifier &options, int argc, char const ** argv)
+{
+	std::cout << "Parser" << std::endl;
+    seqan::ArgumentParser parser("PEMer_Lite");
+
+	// Optionen hinzufügen
+    addOption(parser, seqan::ArgParseOption("i","input-file","Input SAM-file.",seqan::ArgParseArgument::INPUTFILE));
+    setValidValues(parser, "input-file", "sam");
+    setRequired(parser, "input-file");
+
+    addOption(parser,seqan::ArgParseOption("x","SD-variable", "Variable to use for multiples of standard degression.",seqan::ArgParseArgument::INTEGER, "INT"));
+	setMinValue(parser, "SD-variable", "1");
+	setDefaultValue(parser,"SD-variable","1");
+		
+	addOption(parser,seqan::ArgParseOption("y","Del_SD-variable", "Variable to spezify multiples of standard degression for deletions.",seqan::ArgParseArgument::INTEGER, "INT"));
+	setMinValue(parser, "Del_SD-variable", "1");
+	setDefaultValue(parser,"Del_SD-variable","1");
+
+	addOption(parser,seqan::ArgParseOption("s","standard_degression", "Variable to use for standard degression for length of fragments.",seqan::ArgParseArgument::INTEGER, "INT"));
+	setMinValue(parser, "standard_degression", "1");
+	
+	addOption(parser,seqan::ArgParseOption("e","expected_value", "Variable to use for the expected value for length of fragments.",seqan::ArgParseArgument::INTEGER, "INT"));
+	setMinValue(parser, "expected_value", "1");
+		
+	addOption(parser, seqan::ArgParseOption("p","Print", "Select to print temporary solutions."));
+
+    // verarbeitet die Kommandozeile
+    seqan::ArgumentParser::ParseResult res = seqan::parse(parser, argc, argv);
+
+    // Überprüfung der richtigen Ausführung von commands()
+    if (res != seqan::ArgumentParser::PARSE_OK)
+        return res;
+
+    // extrahiert Werte aus der parser.
+	getOptionValue(options.x, parser, "SD-variable");
+	getOptionValue(options.y, parser, "Del_SD-variable");
+	getOptionValue(options.e, parser, "expected_value");
+	getOptionValue(options.sd, parser, "standard_degression");
+	options.p = isSet(parser, "Print");
+	getOptionValue(options.inputFile, parser, "input-file");
+    
+    return seqan::ArgumentParser::PARSE_OK;
+}
+
+unsigned generateStandardDegression(candidates &input,int e_value)	//erzeugt die Standartabweichung
+{
+	std::cout << "SD" << std::endl;
+	unsigned standardDegression=0;
+
+	unsigned n = input.size();
+	for (unsigned i=0;i<n;i++)
+	{
+		standardDegression += (input[i].len-e_value)*(input[i].len-e_value);
+	} 
+	standardDegression /= n;
+	standardDegression = (unsigned)sqrt((double)standardDegression);
+
+	return standardDegression;
+}
+
+int saminput(candidates &save, modifier &options, statisticals &stats)	// impotiert eine SAM-Datei und speichert sie im Format candidates
+{	
+	std::cout << "Saminput" << std::endl;
+	candidate tmp;
+	medianTree median;
+	
+    // BamStream öffnet Eingangsdatenstrom
+    seqan::BamStream SamInput(toCString(options.inputFile));
+    if (!isGood(SamInput))
+    {
+		std::cerr << "-ERROR- Could not open" << std::endl;
+		return 1;
+    }
+	/*
+	for (unsigned i = 0; i < length(SamInput.header.sequenceInfos); ++i)
+	{
+		header << SamInput.header.sequenceInfos[i].i1 << "\t" << SamInput.header.sequenceInfos[i].i2 << "\n";
+	}*/
+	// record enthält die inhalte aus einer SAM-Datei
+	seqan::BamAlignmentRecord record;
+
+	while (!atEnd(SamInput))
+	{
+		readRecord(record, SamInput);
+		if(record.tLen>0)
+		{
+			median.add(record.tLen);
+			std::cout << record.tLen << "\t" << median.getMedian() << std::endl;
+			tmp.addvalues(record.rID,record.beginPos,record.tLen,candidate::undefine);
+			save.push_back(tmp);
+		}
+	}
+	std::cout << options.e << std::endl;
+	if(options.e==0)
+	{
+		stats.e_value=median.getMedian();
+	}
+	else
+	{
+		stats.e_value=options.e;
+	}
+	if(options.sd==0)
+	{
+		stats.standardDegression=generateStandardDegression(save,stats.e_value);
+	}
+	else
+	{
+		stats.standardDegression=options.sd;
+	}
+	
+    return 0;
+}
+
+int devide(candidates &input, candidates &result, modifier &options, statisticals &stats)	// sucht nach insertions und deletions
+{
+	std::cout << "devide\t" << stats.e_value << "\t" << stats.standardDegression << std::endl;
+	for (unsigned i=0;i<input.size();i++)
+	{
+		std::cout << input[i].len << "	"<< (input[i].len>(stats.e_value+(options.y * stats.standardDegression))) << (input[i].len<(stats.e_value-(options.x * stats.standardDegression))) << std::endl;
+		bool second = (input[i].len>(stats.e_value+(options.y * stats.standardDegression)));
+		bool first = (input[i].len<(stats.e_value-(options.x * stats.standardDegression)));
+		if(first)
+		{
+			std::cout << "d" << std::endl;
+
+			//result.push_back(input[i]);
+			//result[i].type=candidate::deletion;
+		}
+		if(second)
+		{
+			std::cout << "i" << std::endl;
+			//result.push_back(input[i]);
+			//result[i].type=candidate::insertion;
+		}
+	}
+	std::cout << "devie_end" <<std::endl;
+	return 0;
+}
+
+int output(std::vector<std::vector<unsigned>> &input,candidates &ref, char *out)
+{	
+	std::cout << "out" << std::endl;
+	std::fstream outFile(out, std::ios::out);
+	
+	if (!outFile) 
+	{
+		std::cerr << "-ERROR- Could not open output file" << std::endl;
+		return 1;
+	}
+	else
+	{	
+		outFile << "ID\tPOS\tLEN\tBegin\tEND\tTYPE " << std::endl;
+		if(!input.empty())
+		{
+			for (unsigned i=0;i<input.size();i++)
+			{	
+				unsigned targetSize=0;
+				unsigned maxBegin=0;
+				unsigned minEnd=0;
+				unsigned n=input[i].size();
+				
+				if(!input[i].empty())
+				{
+					for(auto j=input[i].begin();j != input[i].end();j++)
+					{
+						targetSize += ref[*j].len;
+						
+						if(ref[*j].pos > maxBegin){maxBegin=ref[*j].pos;}
+						if((ref[*j].pos+ref[*j].len) < minEnd||minEnd==0){minEnd=(ref[*j].pos+ref[*j].len);}						
+					}
+				}
+				if(n!=0)
+				{
+					targetSize /= n;
+					
+					outFile << ref[0].ref << "\t" << (maxBegin+minEnd)/2<< "\t" << targetSize << "\t" << maxBegin << "\t" << minEnd << "\t" << (candidate::form)ref[0].type << std::endl;
+				}
+			}
+		}
+	}
+
+	outFile.close();
+
+	return 0;
+}
+ 
+int findCluster(candidates &input, std::vector<std::vector<unsigned> > &dest, candidate::form indel)
+{
+	std::cout << "findCluster" << std::endl;
+    std::vector<unsigned> currentCluster;
+    unsigned currentClusterEndPos;
+
+    // Iterieren über alle Funde
+	for(unsigned i = 0; i < input.size(); ++i)
+    {
+        // Insertionen bzw. Deletionen herausfiltern
+        if(input[i].type == indel)
+        {
+            if(currentCluster.empty())
+            {
+                // ersten Fund zu bisher leerem ersten Cluster hinzufügen
+                currentCluster.push_back(i);
+                currentClusterEndPos = input[i].pos + input[i].len - 1;
+            }
+
+            else
+            {
+                // Fall 1: Fund liegt innerhalb der Grenzen eines vorherigen Fundes
+                if(input[i].pos + input[i].len - 1 <= currentClusterEndPos){
+                    currentCluster.push_back(i);
+				}
+
+                else
+                {
+                    unsigned overlapLen = std::max((int)(currentClusterEndPos - input[i].pos + 1), 0);
+
+                    // Fall 2: Fund überlappt ausreichend mit dem Cluster
+                    if(overlapLen / std::min(currentClusterEndPos - input[currentCluster.back()].pos + 1, input[i].pos + input[i].len - 1) > 0.5){
+                        currentCluster.push_back(i);
+					}
+                    // Fall 3: Fund überlappt nicht ausreichend mit dem Cluster
+                    else
+                    {
+                        dest.push_back(currentCluster);
+                        currentCluster.clear();
+                        currentCluster.push_back(i);
+                    }
+
+                    currentClusterEndPos = input[i].pos + input[i].len - 1;
+                }
+
+            }
+        }
+    }
+
+    dest.push_back(currentCluster);
+
+	return 0;
+}
+ 

code/train/C++/0003837_poj1852.cc

@@ -0,0 +1,44 @@
+#include<iostream>
+#include<algorithm>
+#include<cstdio>
+#include<cstdlib>
+#include<vector>
+#include<map>
+#include<queue>
+#include<set>
+#include<stack>
+#include<cctype>
+#include<cstring>
+#include<utility>
+using namespace std;
+const int inf=0x7fffffff;
+int main()
+{
+
+#ifdef DEBUG
+//	freopen("in", "r", stdin);
+//	freopen("out", "w", stdout);
+#endif
+	int KT;
+	scanf("%d",&KT);
+	while(KT--)
+	{
+		int n,num;
+		scanf("%d%d",&n,&num);
+		int best=0;
+		int worst=0;
+		int x;
+		while(num--)
+		{
+			scanf("%d",&x);
+			best=max(best,min(n-x,x));
+			worst=max(worst,max(n-x,x));
+		}
+		printf("%d %d\n",best
+				,worst);
+	}
+
+	
+	//insert code
+	return 0;
+}

code/train/C++/0004781_heapSort.cpp

@@ -0,0 +1,136 @@
+/*
+  Algorithm : Heap Sort
+  Refer     : CLRS Chapter on heap sort
+  Author    : manojpandey
+*/
+
+#include <iostream>
+#include <cstdio>
+#include <string>
+#include <utility> // pair
+#include <vector>
+#include <algorithm>
+#include <cmath>
+#include <cstring> //memset
+using namespace std;
+  
+typedef vector<int> vi; 
+typedef vector<vi> vvi; 
+typedef pair<int,int> ii; 
+typedef long long ll;
+#define sz(a) int((a).size()) 
+#define pb push_back 
+#define all(c) (c).begin(),(c).end() 
+#define present(c,x) ((c).find(x) != (c).end()) 
+#define cpresent(c,x) (find(all(c),x) != (c).end()) 
+#define tr(container, it) for(typeof(container.begin()) it = container.begin(); it != container.end(); it++) 
+#define rep(i,n) for (i=0; i<n ; i++)
+#define rep1(i,n) for (i=1; i<=n ; i++)
+#define MAX 1111111
+
+#define parent(i) (i/2)
+#define left(i) (2*i)
+#define right(i) (2*i)+1
+
+int a[MAX];
+int N, heapSize;
+
+
+// Custom print function to
+// print in the form of tree
+void PRINT(int a[], int i) {
+
+    if(i<=N/2) {
+        for (int k = 1;k<=log2(2*i);k++)
+            cout << "  |";
+        cout << a[2*i] << "\n";
+        PRINT(a, 2*i);
+        for (int k = 1;k<=log2(2*i+1);k++)
+            cout << "  |";
+        cout << a[2*i+1] << "\n";
+        PRINT(a,2*i+1);
+    }
+}
+
+void maxHeapify(int a[], int i) {
+
+    int l, r, largest, j;
+
+    l = left(i);
+    r = right(i);
+    if(l <= heapSize && a[l] > a[i])
+        largest = l;
+    else largest = i;
+    if(r <= heapSize && a[r] > a[largest])
+        largest = r;
+    if(largest != i) {
+        swap(a[i], a[largest]);
+        maxHeapify(a, largest);
+    }
+}
+
+void buildMaxHeap(int a[]) {    
+    for (int i = N/2 ; i >0 ; i--)
+        maxHeapify(a, i);
+}
+
+void HeapSort(int a[]) {
+    buildMaxHeap(a);
+    for (int i = N ; i > 1 ; i--) {
+        swap(a[1], a[i]);
+        heapSize--;
+        maxHeapify(a, 1);
+    }
+}
+
+int main() {
+
+    freopen ("in.txt", "r", stdin);
+    int i;
+    cin >> N;
+    heapSize = N;
+    rep1(i, N) cin >> a[i];
+    cout << "INPUT:\n";
+    cout << a[1] << "\n";
+    PRINT(a,1);
+
+    HeapSort(a);
+    cout << "OUTPUT:\n";
+    cout << a[1] << "\n";
+    PRINT(a,1);
+    return 0;
+}
+
+/*
+
+10
+4 1 3 2 16 9 10 14 8 7
+
+
+INPUT:
+4
+  |1
+  |  |2
+  |  |  |14
+  |  |  |8
+  |  |16
+  |  |  |7
+  |  |  |0
+  |3
+  |  |9
+  |  |10
+OUTPUT:
+1
+  |2
+  |  |4
+  |  |  |10
+  |  |  |14
+  |  |7
+  |  |  |16
+  |  |  |0
+  |3
+  |  |8
+  |  |9
+
+
+*/

code/train/C++/0004813_276A.cpp

@@ -0,0 +1,46 @@
+#include <cstdio>
+#include <algorithm>
+#include <cstring>
+#include <string>
+#include <vector>
+#include <queue>
+#include <map>
+#include <iostream>
+#include <climits>
+#include <set>
+#include <cmath>
+#define ll long long
+
+using namespace std;
+
+struct aa {
+    int x, y;
+    bool operator < (const aa &b) {return x < b.x;}
+};
+
+bool cmp(int a, int b) {return a > b;}
+int bsearch(int *a, int n, int k);
+
+int main() {
+	ll n, k, m = LLONG_MIN;
+	cin >> n >> k;
+	for (int i=0;i<n;i++) {
+		ll f, t;
+		cin >> f >> t;
+		if (t > k) m = max(m, f - (t - k));
+		else m = max(m, f);
+	}
+	cout << m;
+	return 0;
+}
+
+int bsearch(int *a, int n, int k) {
+    int l = 0, h = n;
+    while (l < h) {
+        int m = (l + h) / 2;
+        if (a[m] == k) return m;
+        else if (a[m] > k) h = m;
+        else l = m + 1;
+    }
+    return l;
+}

code/train/C++/0005979_WorldRunnable.cpp

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
+ * Copyright (C) 2009-2010 MaNGOSZero <http://github.com/mangoszero/mangoszero/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+/** \file
+    \ingroup mangosd
+*/
+
+#include "WorldSocketMgr.h"
+#include "Common.h"
+#include "World.h"
+#include "WorldRunnable.h"
+#include "Timer.h"
+#include "ObjectAccessor.h"
+#include "MapManager.h"
+#include "BattleGroundMgr.h"
+
+#include "Database/DatabaseEnv.h"
+
+#ifdef WIN32
+#define WORLD_SLEEP_CONST 50
+#else
+#define WORLD_SLEEP_CONST 100                               //Is this still needed?? [On linux some time ago not working 50ms]
+#endif
+
+#ifdef WIN32
+#include "ServiceWin32.h"
+extern int m_ServiceStatus;
+#endif
+
+/// Heartbeat for the World
+void WorldRunnable::run()
+{
+    ///- Init new SQL thread for the world database
+    WorldDatabase.ThreadStart();                                // let thread do safe mySQL requests (one connection call enough)
+    sWorld.InitResultQueue();
+
+    uint32 realCurrTime = 0;
+    uint32 realPrevTime = getMSTime();
+
+    uint32 prevSleepTime = 0;                               // used for balanced full tick time length near WORLD_SLEEP_CONST
+
+    ///- While we have not World::m_stopEvent, update the world
+    while (!World::IsStopped())
+    {
+        ++World::m_worldLoopCounter;
+        realCurrTime = getMSTime();
+
+        uint32 diff = getMSTimeDiff(realPrevTime,realCurrTime);
+
+        sWorld.Update( diff );
+        realPrevTime = realCurrTime;
+
+        // diff (D0) include time of previous sleep (d0) + tick time (t0)
+        // we want that next d1 + t1 == WORLD_SLEEP_CONST
+        // we can't know next t1 and then can use (t0 + d1) == WORLD_SLEEP_CONST requirement
+        // d1 = WORLD_SLEEP_CONST - t0 = WORLD_SLEEP_CONST - (D0 - d0) = WORLD_SLEEP_CONST + d0 - D0
+        if (diff <= WORLD_SLEEP_CONST+prevSleepTime)
+        {
+            prevSleepTime = WORLD_SLEEP_CONST+prevSleepTime-diff;
+            ACE_Based::Thread::Sleep(prevSleepTime);
+        }
+        else
+            prevSleepTime = 0;
+
+        #ifdef WIN32
+            if (m_ServiceStatus == 0) World::StopNow(SHUTDOWN_EXIT_CODE);
+            while (m_ServiceStatus == 2) Sleep(1000);
+        #endif
+    }
+
+    sWorld.KickAll();                                       // save and kick all players
+    sWorld.UpdateSessions( 1 );                             // real players unload required UpdateSessions call
+
+    // unload battleground templates before different singletons destroyed
+    sBattleGroundMgr.DeleteAllBattleGrounds();
+
+    sWorldSocketMgr->StopNetwork();
+
+    sMapMgr.UnloadAll();                     // unload all grids (including locked in memory)
+
+    ///- End the database thread
+    WorldDatabase.ThreadEnd();                                  // free mySQL thread resources
+}

code/train/C++/0006023_SpecificPartialLoudnessGM.cpp

@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2014 Dominic Ward <contactdominicward@gmail.com>
+ *
+ * This file is part of Loudness
+ *
+ * Loudness is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Loudness is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Loudness.  If not, see <http://www.gnu.org/licenses/>. 
+ */
+
+#include "SpecificPartialLoudnessGM.h"
+#include "../Support/AuditoryTools.h"
+
+namespace loudness{
+
+    SpecificPartialLoudnessGM::SpecificPartialLoudnessGM(bool ansiS3407) :
+        Module("SpecificPartialLoudnessGM"),
+        ansiS3407_(ansiS3407)
+    {}
+
+    SpecificPartialLoudnessGM::~SpecificPartialLoudnessGM() {}
+
+    bool SpecificPartialLoudnessGM::initializeInternal(const TrackBank &input)
+    {
+        if (input.getNTracks() % 2 != 0)
+        {
+            LOUDNESS_ERROR(name_ << ": TrackBank must have an even number of tracks");
+        }
+        //c value from ANSI 2007
+        cParam_ = 0.046871;
+        c2Param_ = 0.0000459608; // C_2 = C / (1.04 x 10^6)^0.5
+
+        Real eThrqdB500Hz = IntExc(500);
+
+        //Number of filters below 500Hz
+        nFiltersLT500_ = 0;
+
+        //fill loudness parameter vectors
+        Real fcPrev = input.getCentreFreq(0);
+        for(int i=0; i<input.getNChannels(); i++)
+        {
+            Real fc = input.getCentreFreq(i);
+
+            if(fc<fcPrev)
+                LOUDNESS_ERROR("SpecificPartialLoudnessGM: Centre frequencies are not in ascending order!");
+            fcPrev = fc;
+
+            Real eThrqdB = IntExc(fc);
+            if (fc < 500)
+            {
+                eThrqParam_.push_back(pow(10,eThrqdB/10.0));
+                nFiltersLT500_++;
+            }
+            else
+            {
+                eThrqParam_.push_back(pow(10,eThrqdB500Hz/10));
+            }
+
+            Real gdB = eThrqdB500Hz-eThrqdB;
+            k_.push_back(pow(10, kdB(fc)/10));
+            gParam_.push_back(pow(10, gdB/10.0));
+            aParam_.push_back(GdBToA(gdB));
+            alphaParam_.push_back(GdBToAlpha(gdB));
+        }
+        LOUDNESS_DEBUG("SpecificPartialLoudnessGM: number of filters <500 Hz: " << nFiltersLT500_);
+
+        //output TrackBank
+        output_.initialize(input.getNTracks() / 2, input.getNChannels(), input.getNSamples(), input.getFs());
+        output_.setCentreFreqs(input.getCentreFreqs());
+
+        return 1;
+    }
+
+    void SpecificPartialLoudnessGM::processInternal(const TrackBank &input)
+    {
+        Real eSig, eNoise, eThrn, sl, slSum, plSum, pl=0.0;
+        int masker, nTracks;
+
+        nTracks = input.getNTracks() / 2;
+
+        for (int target = 0; target < nTracks; target++)
+        {
+            slSum = 0;
+            plSum = 0;
+            masker = target + nTracks;
+            for(int freq = 0; freq < input.getNChannels(); freq++)
+            {
+                eSig = input.getSample(target, freq, 0);
+                eNoise = input.getSample(masker, freq, 0);
+                eThrn = k_[freq] * eNoise + eThrqParam_[freq];
+
+                // partial loudness calculation (the target signal in noise)
+                if (eSig + eNoise > 1e10)
+                {
+                    if (eSig >= eThrqParam_[freq]) // equation 19 from Glasberg and Moore 1997
+                    {
+                        pl = c2Param_ * pow(eSig + eNoise, 0.5)
+                                - c2Param_ * (pow((1 + k_[freq]) * eNoise + eThrqParam_[freq], 0.5)
+                                                - pow(eThrqParam_[freq] * gParam_[freq] + aParam_[freq], alphaParam_[freq])
+                                                + pow(aParam_[freq], alphaParam_[freq]))
+                                            * pow(eThrqParam_[freq] / eSig, 0.3);
+                    }
+                    else // equation 20 from Glasberg and Moore 1997
+                    {
+                        pl = cParam_
+                            * pow(2 * eSig / (eSig + eThrqParam_[freq]), 1.5)
+                            * ((pow(eThrqParam_[freq] * gParam_[freq] + aParam_[freq], alphaParam_[freq])
+                                    - pow(aParam_[freq], alphaParam_[freq]))
+                                / (pow(eNoise * (1 + k_[freq]) + eThrqParam_[freq], 0.5) - pow(eNoise, 0.5)))
+                            * (pow(eSig + eNoise, 0.5) - pow(eNoise, 0.5));
+                    }
+                }
+                else // eSig + eNoise <= 1e10
+                {
+                    if (eSig >= eThrn) // // equation 17 from Glasberg and Moore 1997
+                    {
+                        pl = cParam_ * (pow((eSig + eNoise) * gParam_[freq] + aParam_[freq], alphaParam_[freq])
+                                        - pow(aParam_[freq], alphaParam_[freq]))
+                            - cParam_
+                                * (pow((eNoise * (1 + k_[freq]) + eThrqParam_[freq]) * gParam_[freq] + aParam_[freq], alphaParam_[freq])
+                                    - pow(eThrqParam_[freq] * gParam_[freq] + aParam_[freq], alphaParam_[freq]))
+                                * pow(eThrn / eSig, 0.3);
+                    }
+                    else // equation 18 from Glasberg and Moore 1997
+                    {
+                        pl = cParam_
+                            * pow(2 * eSig / (eSig + eThrqParam_[freq]), 1.5)
+                            * ((pow(eThrqParam_[freq] * gParam_[freq] + aParam_[freq], alphaParam_[freq])
+                                    - pow(aParam_[freq], alphaParam_[freq]))
+                                / (pow(eNoise * (1 + k_[freq]) + eThrqParam_[freq], 0.5) - pow(eNoise, 0.5)));
+                    }
+                }
+
+                // set partial loudness at output channel 1
+                output_.setSample(target, freq, 1, pl);
+                //plSum += pl;
+
+                // loudness calculation (the isolated target signal)
+                //high level
+                if (eSig > 1e10)
+                {
+                    if(ansiS3407_)
+                        sl = pow((eSig/1.0707),0.2);
+                    else
+                        sl = pow((eSig/1.04e6),0.5);
+                }
+                else if(freq<nFiltersLT500_) //low freqs
+                { 
+                    if(eSig>eThrqParam_[freq]) //medium level
+                    {
+                        sl = (pow(gParam_[freq]*eSig+aParam_[freq], alphaParam_[freq])-
+                                pow(aParam_[freq],alphaParam_[freq]));
+                    }
+                    else //low level
+                    {
+                        sl = pow((2*eSig)/(eSig+eThrqParam_[freq]), 1.5)*
+                            (pow(gParam_[freq]*eSig+aParam_[freq],alphaParam_[freq])
+                                -pow(aParam_[freq],alphaParam_[freq]));
+                    }
+                }
+                else //high freqs (variables are constant >= 500 Hz)
+                { 
+                    if(eSig>2.3604782331805771) //medium level
+                    {
+                        sl = pow(eSig+4.72096, 0.2)-1.3639739128330546;
+                    }
+                    else //low level
+                    {
+                        sl = pow((2*eSig)/(eSig+2.3604782331805771), 1.5)*
+                            (pow(eSig+4.72096, 0.2)-1.3639739128330546);
+                    }
+                }
+                
+                // set loudness at output channel 0
+                output_.setSample(target, freq, 0, cParam_*sl);
+                //slSum += sl;
+            }
+            //output_.setSample(0, 0, 0, cParam_*slSum);
+            //output_.setSample(0, 0, 1, plSum);
+        }
+    }
+
+    void SpecificPartialLoudnessGM::resetInternal(){};
+}
+
+
+

code/train/C++/0006349_XScaleBar.cpp

@@ -0,0 +1,165 @@
+/* FTSPlot - fast time series dataset plotter
+   Copyright (C) 2013  Michael Riss <Michael.Riss@gmail.com>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA */
+
+
+#include <math.h>
+#include "XScaleBar.h"
+
+#define MAX(a,b) a<b?b:a
+
+using namespace FTSPlot;
+
+XScaleBar::XScaleBar( QWidget* parent )
+        : QGLWidget( parent )
+{
+    qtminDeltaticks = 3;
+    Xcursor = 0;
+    Xscale = 1;
+    Xmax = 1;
+
+    fixedFont.setFamily( "fixed" );
+    fixedFont.setPointSize( 8 );
+    fixedFont.setStyleStrategy( QFont::OpenGLCompatible );
+    fixedFont.setStyleHint( QFont::TypeWriter );
+    fm = new QFontMetrics( fixedFont );
+}
+
+void XScaleBar::initializeGL()
+{
+    glClearColor(1.0, 1.0, 1.0, 0.0);
+    glShadeModel(GL_FLAT);
+    glEnable( GL_LINE_SMOOTH );
+    glEnable( GL_BLEND );
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
+    glLineWidth(1.0);
+    glDisable(GL_DEPTH_TEST);
+}
+
+void XScaleBar::resizeGL ( int width, int height )
+{
+    this->width = width;
+    this->height = height;
+    glViewport(0, 0, (GLint)width, (GLint)height);
+    glMatrixMode ( GL_PROJECTION );
+    glLoadIdentity ();
+    gluOrtho2D( 0.0, (double) width, (double) height, 0 );
+}
+
+void XScaleBar::paintGL()
+{
+    glClear ( GL_COLOR_BUFFER_BIT );
+
+    glColor3f ( 0.0, 0.0, 0.0 );
+    glLineWidth( 2.0 );
+    glBegin ( GL_LINES );
+    glVertex2d ( 0, 0 );
+    glVertex2d ( width, 0 );
+    glEnd();
+    glLineWidth( 1.0 );
+
+    // Draw tick marks
+    long double XDelta = Xscale * (double) width;
+    long double XMax = Xcursor + XDelta;
+    qtlabelbuffer = " " + QString::number( XMax, 'f', 0 );
+    int labelWidth = fm->width( qtlabelbuffer );
+    long double powerDueToLabel = ceill( log10l( XDelta / ( (long double) width / labelWidth ))) - 1;
+    long double power = MAX( 0, ceill( log10l( XDelta / ( (long double)width / (long double)qtminDeltaticks ) ) ) );
+    power = MAX( power, powerDueToLabel );
+    long double XStart =  powl( 10, power ) * ceill( Xcursor / powl(10, power) );
+    long double XEnd = powl( 10, power ) * floorl( screen2data(width) / powl(10, power) );
+
+    glBegin ( GL_LINES );
+    for ( long double idx = XStart; idx <= XEnd; idx += powl(10, power) )
+    {
+        glVertex2d( data2screen(idx), 0 );
+        glVertex2d( data2screen(idx), 5 );
+    }
+
+    XStart =  powl( 10, power+1 ) * ceill( Xcursor / powl(10, power+1) ) - powl(10, power+1)/2.0 ;
+    if ( XStart < Xcursor )
+    {
+        XStart += powl(10, power+1);
+    }
+    XEnd = powl( 10, power+1 ) * floorl( screen2data(width) / powl(10, power+1) );
+    glBegin ( GL_LINES );
+    for ( long double idx = XStart; idx <= XEnd; idx += powl(10, power+1) )
+    {
+        glVertex2d( data2screen(idx), 0 );
+        glVertex2d( data2screen(idx), 8 );
+    }
+
+    XStart =  powl( 10, power+1 ) * ceill( Xcursor / powl(10, power+1) );
+    XEnd = powl( 10, power+1 ) * floorl( screen2data(width) / powl(10, power+1) );
+    for ( long double idx = XStart; idx <= XEnd; idx += powl(10, power+1) )
+    {
+        glVertex2d( data2screen(idx), 0 );
+        glVertex2d( data2screen(idx), 10 );
+    }
+
+    glEnd();
+
+
+    for ( long double idx = XStart; idx <= XEnd; idx += powl(10, power+1) )
+    {
+        qtlabelbuffer = QString::number( idx, 'f', 0 );
+        renderText( data2screen(idx) - fm->width( qtlabelbuffer ) / 2, 20, qtlabelbuffer, fixedFont );
+    }
+
+    glFlush();
+}
+
+void XScaleBar::updateCoords( long double Xcursor, double Xscale )
+{
+    this->Xcursor = Xcursor;
+    this->Xscale = Xscale;
+    this->makeCurrent();
+    update();
+}
+
+long double XScaleBar::screen2data( int screenCoord)
+{
+    return Xcursor + (long double) screenCoord * (long double) Xscale;
+}
+
+int XScaleBar::data2screen( long double dataCoord )
+{
+    return (int) ( ( (long double) dataCoord - Xcursor) / (long double) Xscale );
+}
+
+void XScaleBar::setNewXmin(long double Xmin)
+{
+    this->Xmin = Xmin;
+}
+
+void XScaleBar::setNewXmax( long double Xmax )
+{
+    this->Xmax = Xmax;
+
+    // Cached Calculations
+    stringstream buffer;
+    buffer << Xmax;
+
+    QString label;
+    label = QString::number( Xmax, 'f', 0 );
+    int qtlabelwidth = fm->width(label);
+    qtminDeltaticks = MAX( 3, ceill( qtlabelwidth / 10.0 ) );
+
+    update();
+}
+
+// kate: indent-mode cstyle; space-indent on; indent-width 0; 

code/train/C++/0006416_TestStanfordCPPLib.cpp

@@ -0,0 +1,121 @@
+/*
+ * File: TestStanfordCPPLib.cpp
+ * ----------------------------
+ * This file tests the C++ library packages used at Stanford.
+ */
+
+/*************************************************************************/
+/* Stanford Portable Library                                             */
+/* Copyright (c) 2014 by Eric Roberts <eroberts@cs.stanford.edu>         */
+/*                                                                       */
+/* This program is free software: you can redistribute it and/or modify  */
+/* it under the terms of the GNU General Public License as published by  */
+/* the Free Software Foundation, either version 3 of the License, or     */
+/* (at your option) any later version.                                   */
+/*                                                                       */
+/* This program is distributed in the hope that it will be useful,       */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of        */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         */
+/* GNU General Public License for more details.                          */
+/*                                                                       */
+/* You should have received a copy of the GNU General Public License     */
+/* along with this program.  If not, see <http://www.gnu.org/licenses/>. */
+/*************************************************************************/
+
+#include <iostream>
+#include <string>
+#include "console.h" // JL
+#include "strlib.h"
+#include "unittest.h"
+
+using namespace std;
+
+void testFilelibLibrary();
+void testRandomLibrary();
+void testSimpioLibrary();
+void testStrlibLibrary();
+void testDirectionType();
+void testGraphClass();
+void testGridClass();
+void testHashMapClass();
+void testHashSetClass();
+void testLexiconClass();
+void testMapClass();
+void testPriorityQueueClass();
+void testQueueClass();
+void testSetClass();
+void testStackClass();
+void testTokenScannerClass();
+void testVectorClass();
+void testForeachStatement();
+
+/*
+ * Type: TestEntry
+ * ---------------
+ * This structure associates a key with a test function.
+ */
+
+struct TestEntry {
+   string name;
+   void (*fn)();
+};
+
+const TestEntry TESTS[] = {
+   { "fileliblibrary", testFilelibLibrary },
+   { "randomlibrary",  testRandomLibrary },
+   { "simpiolibrary",  testSimpioLibrary },
+   { "strliblibrary",  testStrlibLibrary },
+   { "directiontype",  testDirectionType },
+   { "graphclass",  testGraphClass },
+   { "gridclass",  testGridClass },
+   { "hashmapclass",  testHashMapClass },
+   { "hashsetclass",  testHashSetClass },
+   { "lexiconclass",  testLexiconClass },
+   { "mapclass",  testMapClass },
+   { "priorityqueueclass",  testPriorityQueueClass },
+   { "queueclass",  testQueueClass },
+   { "setclass",  testSetClass },
+   { "stackclass",  testStackClass },
+   { "tokenscannerclass",  testTokenScannerClass },
+   { "vectorclass",  testVectorClass },
+   { "foreachstatement",  testForeachStatement }
+};
+const int N_TESTS = sizeof TESTS / sizeof TESTS[0];
+
+int findTest(string key) {
+   int index = -1;
+   key = toLowerCase(key);
+   for (int i = 0; i < N_TESTS; i++) {
+      if (startsWith(TESTS[i].name, key)) {
+         if (index != -1) return -1;
+         index = i;
+      }
+   }
+   return index;
+}
+
+int main() {
+   setConsolePrintExceptions(true); // JL
+   int argc = getArgumentCount();
+   char **argv = getArguments();
+   int base = 1;
+   if (argc > 1 && startsWith("-verbose", argv[base])) {
+      setVerboseTestingFlag(true);
+      base++;
+   }
+   if (base == argc) {
+      for (int i = 0; i < N_TESTS; i++) {
+         TESTS[i].fn();
+      }
+   } else {
+      for (int i = base; i < argc; i++) {
+         int index = findTest(argv[i]);
+         if (index == -1) {
+            cout << "Unrecognized test: " << argv[i] << endl;
+         } else {
+            TESTS[index].fn();
+         }
+      }
+   }
+   return 0;
+}

code/train/C++/0006687_instprofile.cpp

@@ -0,0 +1,247 @@
+/**************************************************************************
+ *Copyright (C) 2003-2006 Intel Corporation
+ *
+ *This program is free software; you can redistribute it and/or
+ *modify it under the terms of the GNU General Public License
+ *as published by the Free Software Foundation; either version 2
+ *of the License, or (at your option) any later version.
+ *
+ *This program is distributed in the hope that it will be useful,
+ *but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *GNU General Public License for more details.
+ *
+ *You should have received a copy of the GNU General Public License
+ *along with this program; if not, write to the Free Software
+ *Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+//
+// Author:  Srilatha Manne
+//
+
+#include "asim/provides/inst_stats.h"
+
+//
+// PERINST_ENTRY
+//
+
+/**************************
+ * Constructor
+ **************************/
+
+
+PERINST_ENTRY_CLASS::PERINST_ENTRY_CLASS(const char* des_str, UINT64 a) :
+    addr(a), 
+    commHist(LAST_COUNTER),
+    noncommHist(LAST_COUNTER)
+{
+
+    strncpy (des, des_str, 99);
+    
+    //
+    // Initialize row names.  We will register the stats at the end because
+    // that's the only time we'll have a ASIM_REGISTRY object with which to
+    // register the stats. 
+    commHist.RowNames(PERINST_COUNTER_STRING);
+    noncommHist.RowNames(PERINST_COUNTER_STRING);
+}
+
+/**************************
+ * Stats Registration
+ **************************/
+
+void
+PERINST_ENTRY_CLASS::RegisterEntry(ASIM_REGISTRY reg)
+{
+    // Register stats
+    // Convert the address to a string. 
+    ostringstream os1, os2;
+    if (ENABLE_INST_PROFILE == 2)
+    {
+        os1 << "Committed_" << hex << addr;
+        os2 << "NonCommitted_" << hex << addr;
+    }
+    else if (ENABLE_INST_PROFILE == 1 || ENABLE_INST_PROFILE == 0)
+    {
+        os1 << "Committed_" << des;
+        os2 << "NonCommitted_" << des;
+    }
+    else 
+    {
+        ASSERTX("Unknown instruction profile type.");
+    }
+
+//    cout << "Address: " << os.str() << endl;
+
+    reg->RegisterState(&commHist, os1.str().c_str(), des);
+    reg->RegisterState(&noncommHist, os2.str().c_str(), des);
+
+    // Update the histogram with the correct data.  
+    for (UINT32 i = 0; i < LAST_COUNTER; i++)
+    {
+        commHist.AddEvent(i, 0, commInst.Get((PERINST_COUNTER)i));
+        noncommHist.AddEvent(i, 0, noncommInst.Get((PERINST_COUNTER)i));
+    }
+}
+
+//
+// PERINST_PAGE
+//
+
+/**************************
+ * Destructor
+ **************************/
+PERINST_PAGE_CLASS::~PERINST_PAGE_CLASS()
+{
+/*
+    for (UINT32 i = 0; i < ENTRIES_PER_PAGE; i++) 
+    {
+        if (page[i] != NULL)
+        {
+            delete page[i];
+        }
+    }
+*/
+}
+
+
+/**************************
+ * Update information for an instruction. 
+ **************************/
+
+void 
+PERINST_PAGE_CLASS::UpdateInst(const UINT64 addr, 
+                               const char *inst_name, 
+                               const PERINST_STATS_CLASS &ifs, 
+                               bool commit) 
+{
+    UINT64 offset = addr - pageAddr;
+
+//    cout << "Updating instruction, Addr: " << addr << ", offset: " << offset << endl;
+    
+    ASSERTX(offset < ENTRIES_PER_PAGE);
+    if (page[offset] == NULL) 
+    {
+        //
+        // Null pointer, which means first time inst is seen.
+        page[offset] = new PERINST_ENTRY_CLASS(inst_name, addr);
+        UINT32 n = numInst++;
+        if (n > MAX_NUM_INSTS) 
+        {
+            VERIFY(false, "Exceeding maximum number of static inst: 100000\n");
+        }
+    }
+    //
+    // Update 
+    ASSERTX(page[offset]->GetAddr() == addr);
+        
+    page[offset]->UpdateInst(ifs, commit);
+}
+
+/**************************
+ * Register stats for a page
+ **************************/
+//
+// Register a page of stats. 
+void
+PERINST_PAGE_CLASS::RegisterPage(ASIM_REGISTRY reg)
+{
+    for (UINT32 i = 0; i < ENTRIES_PER_PAGE; i++) 
+    {
+        if (page[i] != NULL)
+        {
+//            cout << "Registering page" << endl;
+            page[i]->RegisterEntry(reg);
+        }
+    }
+}
+
+
+
+//
+// PERINST_CACHE
+//
+
+/**************************
+ * Destructor
+ **************************/
+
+PERINST_CACHE_CLASS::~PERINST_CACHE_CLASS()
+{
+    STAT_CACHE::iterator i = statCache.begin();
+    STAT_CACHE::iterator prev;
+
+    while (i != statCache.end())
+    {
+        delete (*i).second;
+        prev = i;
+        ++i;
+        statCache.erase(prev);
+    }
+}
+
+/**************************
+ * Update stats 
+ **************************/
+
+void
+PERINST_CACHE_CLASS::UpdateStats(UINT64 addr,
+                                 const char* name, 
+                                 const PERINST_STATS_CLASS& ifs, 
+                                 bool commit)
+{
+
+    PERINST_PAGE page;
+    
+    //
+    // Update per-inst stats.
+    //
+    if (lastPage && 
+        (addr & (~((1 << LOG2_ENTRIES_PER_PAGE) - 1)))==lastPage->PageAddr()) 
+    {
+//            cout << "Using lastpage" << endl;
+        page = lastPage;
+    }
+    else 
+    {
+        STAT_CACHE::iterator i = statCache.find((addr >> LOG2_ENTRIES_PER_PAGE));
+        if (i != statCache.end()) {
+            page = (*i).second;
+            lastPage = page;
+//                cout << "Finding page in stat cache" << endl;
+        }
+        else 
+        {
+            //
+            // Page doesn't currently exist. 
+            //
+            UINT64 page_addr = addr & (~((1 << LOG2_ENTRIES_PER_PAGE) - 1));
+            page = new PERINST_PAGE_CLASS(page_addr);
+//                cout << "Creating new page" << endl;
+            //
+            // Place new page into cache
+            //
+            statCache[(addr >> LOG2_ENTRIES_PER_PAGE)] = page;
+            lastPage = page;
+        }
+        }
+    // Update stats per address
+    page->UpdateInst(addr, name, ifs, commit);
+}
+
+/**************************
+ * Register stats
+ **************************/
+void
+PERINST_CACHE_CLASS::RegisterPerinstStats(ASIM_REGISTRY reg)
+{
+    STAT_CACHE::iterator i = statCache.begin();
+    while (i != statCache.end())
+    {
+//            cout << "Registering page: " << i << endl;
+        (*i).second->RegisterPage(reg);
+        ++i;
+    }
+}
+    

code/train/C++/0006795_testscore.ex3.cpp

@@ -0,0 +1,137 @@
+// This program will read in a group of test scores (positive integers
+// from 1 to 100) from the keyboard and then calculates and outputs
+// the average score as well as the highest and lowest score.
+// There will be a maximum of 100 scores.
+//
+// ** This version is designed to take file input from 'gradfile.txt'
+//    instead of from stdin **
+//
+// Walter B. Vaughan
+
+#include <iostream>
+#include <fstream>
+#include <limits> // for limits
+using namespace std;
+
+typedef int GradeType[100];  // declares a new data type:
+                             // an integer array of 100 elements
+
+float findAverage( const GradeType, int );  // finds average of all grades
+int findHighest( const GradeType, int );    // finds highest of all grades
+int findLowest( const GradeType, int );     // finds lowest of all grades
+
+int main() {
+    GradeType grades;     // the array holding the grades.
+    int numberOfGrades;   // the number of grades read.
+    int pos;              // index to the array.
+
+    float avgOfGrades;    // contains the average of the grades.
+    int highestGrade;     // contains the highest grade.
+    int lowestGrade;      // contains the lowest grade.
+
+    ifstream f ("gradfile.txt");
+
+    // Read in the values into the array
+    pos = 0;
+    while ( pos < 100 and f.good() ) {
+        f >> grades[pos];
+        pos++;
+    }
+    pos--; // truncate the size to ignore end of array (-99 or bounds error)
+
+    if ( pos == -1 ) {
+        std::cerr << "**Error Opening 'gradfile.txt'**";
+        return 1; // error value returned
+    }
+
+    numberOfGrades = pos;  // Fill blank with appropriate identifier
+
+    // call to the function to find average
+    avgOfGrades = findAverage( grades, numberOfGrades );
+
+    cout << endl << "The average of all the grades is " << avgOfGrades << endl;
+
+    //  Fill in the call to the function that calculates highest grade
+    highestGrade = findHighest( grades, numberOfGrades );
+
+    cout << endl << "The highest grade is " << highestGrade << endl;
+
+    // Fill in the call to the function that calculates lowest grade
+    lowestGrade = findLowest( grades, numberOfGrades );
+
+    // Fill in code to write the lowest to the screen
+    cout << endl << "The lowest grade is " << lowestGrade << endl;
+
+    return 0;
+}
+
+
+//******************************************************************************
+//                                 findAverage
+//
+// task:          This function receives an array of integers and its size.
+//                It finds and returns the average of the numbers in the array
+// data in:       array of floating point numbers
+// data returned: avarage of the numbers in the array
+//
+//******************************************************************************
+float findAverage( const GradeType array, int size ) {
+    float sum = 0;  // holds the sum of all the numbers
+
+    for (int pos = 0; pos < size; pos++)
+        sum = sum + array[pos];
+
+    return (sum / size);  //returns the average
+}
+
+
+//******************************************************************************
+//                                 findHighest
+//
+// task:          This function receives an array of integers and its size.
+//                It finds and returns the highest value of the numbers in
+//                the array
+// data in:       array of floating point numbers
+// data returned: highest value of the numbers in the array
+//
+//******************************************************************************
+int findHighest( const GradeType array, int size ) {
+    // Fill in the code for this function
+    int max = std::numeric_limits<int>::min(); // start with lowest int
+
+    if ( size == 0 ) {
+        std::cerr << "Note: Empty grade list given, INT_MIN returned";
+    }
+
+    for ( int i = 0 ; i < size ; i++ )
+        if ( array[i] > max)
+            max = array[i];
+
+    return max;
+}
+
+
+//******************************************************************************
+//                                 findLowest
+//
+// task:          This function receives an array of integers and its size.
+//                It finds and returns the lowest value of the numbers in
+//                the array
+// data in:       array of floating point numbers
+// data returned: lowest value of the numbers in the array
+//
+//******************************************************************************
+int findLowest( const GradeType array, int size ) {
+    // Fill in the code for this function
+    int min = std::numeric_limits<int>::max(); // start with largest int
+
+    if ( size == 0 ) {
+        std::cerr << "Note: Empty grade list given, INT_MAX returned";
+    }
+
+    for ( int i = 0 ; i < size ; i++ )
+        if ( array[i] < min)
+            min = array[i];
+
+    return min;
+}

code/train/C++/0006861_sqldb.cpp

@@ -0,0 +1,338 @@
+////////////////////////////////////////////////////////////////////////////
+//		SQL Database MMF Extension
+//		(c) 2004-2005, Jim St. Jean
+//	
+//		SQL DB wrapper utilities source file
+//
+//		The file provides wrapper routines to the MMF extension so, for
+//		example, the underlying SQLite implementation can be swapped or changed
+//		to be encrypted etc.
+//
+////////////////////////////////////////////////////////////////////////////
+
+
+// Database engine wrapper
+#include	"sqldb.h"
+#include	"common.h"
+
+////////////////////////////////////////////////////////////////////////////////
+// Prototypes for SQLite functions not included in SQLite DLL, but copied below
+// from SQLite encode.c
+////////////////////////////////////////////////////////////////////////////////
+int sqlite3_encode_binary(const unsigned char *in, int n, unsigned char *out);
+int sqlite3_decode_binary(const unsigned char *in, unsigned char *out);
+
+
+/*
+** A function to open a new sqlite database.  
+**
+*/
+sqldb *sqldb_open(const char *filename, char **errmsg)
+{
+	sqldb *db;
+	if (SQLITE_OK != sqlite3_open(filename, &db)) {
+		// get error message
+		strcpy(*errmsg,sqlite3_errmsg(db));
+	}
+	return db;
+}
+
+/*
+** A function to close the database.
+**
+*/
+void sqldb_close(sqldb *db)
+{
+	sqlite3_close(db);
+}
+
+/*
+** The following routine
+** returns the integer key of the most recent insert in the database.
+*/
+int sqldb_last_insert_rowid(sqldb *db)
+{
+	return sqlite3_last_insert_rowid(db);
+}
+
+/*
+** This function returns the number of database rows that were changed
+** (or inserted or deleted) by the most recent called sqlite_exec().
+**
+*/
+int sqldb_changes(sqldb *db)
+{
+	return sqlite3_changes(db);
+}
+
+/*
+** This next routine is really just a wrapper around sqlite_exec().
+** Instead of invoking a user-supplied callback for each row of the
+** result, this routine remembers each row of the result in memory
+** obtained from malloc(), then returns all of the result after the
+** query has finished. 
+**
+*/
+int sqldb_get_table(
+  sqldb* db,               /* An open database */
+  const char *sql,       /* SQL to be executed */
+  char ***resultp,       /* Result written to a char *[]  that this points to */
+  int *nrow,             /* Number of result rows written here */
+  int *ncolumn,          /* Number of result columns written here */
+  char **errmsg          /* Error msg written here */
+)
+{
+	return sqlite3_get_table(
+	  db,               /* An open database */
+	  sql,       /* SQL to be executed */
+	  resultp,       /* Result written to a char *[]  that this points to */
+	  nrow,             /* Number of result rows written here */
+	  ncolumn,          /* Number of result columns written here */
+	  errmsg          /* Error msg written here */
+	);
+}
+
+/*
+** Call this routine to free the memory that sqlite_get_table() allocated.
+*/
+void sqldb_free_table(char **result)
+{
+	sqlite3_free_table(result);
+}
+
+
+/*
+** Windows systems should call this routine to free memory that
+** is returned in the in the errmsg parameter of sqlite_open() when
+** SQLite is a DLL.  For some reason, it does not work to call free()
+** directly.
+**
+** As of sqlite3, this is no longer needed! Still provided for backwards compatibility...
+*/
+void sqldb_freemem(void *p)
+{
+	//sqlite_freemem(p);
+}
+
+
+/*
+** Encode a binary buffer "in" of size n bytes so that it contains
+** no instances of characters '\'' or '\000'.  The output is 
+** null-terminated and can be used as a string value in an INSERT
+** or UPDATE statement.  Use sqlite_decode_binary() to convert the
+** string back into its original binary.
+**
+*/
+int sqldb_encode_binary(const unsigned char *in, int n, unsigned char *out)
+{
+	return sqlite3_encode_binary(in, n, out);
+}
+
+/*
+** Decode the string "in" into binary data and write it into "out".
+** This routine reverses the encoding created by sqlite_encode_binary().
+** The output will always be a few bytes less than the input.  The number
+** of bytes of output is returned.  If the input is not a well-formed
+** encoding, -1 is returned.
+**
+*/
+int sqldb_decode_binary(const unsigned char *in, unsigned char *out)
+{
+	return sqlite3_decode_binary(in, out);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// SQLite encode.c reproduced here, containing implementation notes and source
+// for sqlite3_encode_binary() and sqlite3_decode_binary() 
+////////////////////////////////////////////////////////////////////////////////
+
+/*
+** 2002 April 25
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+*************************************************************************
+** This file contains helper routines used to translate binary data into
+** a null-terminated string (suitable for use in SQLite) and back again.
+** These are convenience routines for use by people who want to store binary
+** data in an SQLite database.  The code in this file is not used by any other
+** part of the SQLite library.
+**
+** $Id: encode.c,v 1.10 2004/01/14 21:59:23 drh Exp $
+*/
+
+/*
+** How This Encoder Works
+**
+** The output is allowed to contain any character except 0x27 (') and
+** 0x00.  This is accomplished by using an escape character to encode
+** 0x27 and 0x00 as a two-byte sequence.  The escape character is always
+** 0x01.  An 0x00 is encoded as the two byte sequence 0x01 0x01.  The
+** 0x27 character is encoded as the two byte sequence 0x01 0x03.  Finally,
+** the escape character itself is encoded as the two-character sequence
+** 0x01 0x02.
+**
+** To summarize, the encoder works by using an escape sequences as follows:
+**
+**       0x00  ->  0x01 0x01
+**       0x01  ->  0x01 0x02
+**       0x27  ->  0x01 0x03
+**
+** If that were all the encoder did, it would work, but in certain cases
+** it could double the size of the encoded string.  For example, to
+** encode a string of 100 0x27 characters would require 100 instances of
+** the 0x01 0x03 escape sequence resulting in a 200-character output.
+** We would prefer to keep the size of the encoded string smaller than
+** this.
+**
+** To minimize the encoding size, we first add a fixed offset value to each 
+** byte in the sequence.  The addition is modulo 256.  (That is to say, if
+** the sum of the original character value and the offset exceeds 256, then
+** the higher order bits are truncated.)  The offset is chosen to minimize
+** the number of characters in the string that need to be escaped.  For
+** example, in the case above where the string was composed of 100 0x27
+** characters, the offset might be 0x01.  Each of the 0x27 characters would
+** then be converted into an 0x28 character which would not need to be
+** escaped at all and so the 100 character input string would be converted
+** into just 100 characters of output.  Actually 101 characters of output - 
+** we have to record the offset used as the first byte in the sequence so
+** that the string can be decoded.  Since the offset value is stored as
+** part of the output string and the output string is not allowed to contain
+** characters 0x00 or 0x27, the offset cannot be 0x00 or 0x27.
+**
+** Here, then, are the encoding steps:
+**
+**     (1)   Choose an offset value and make it the first character of
+**           output.
+**
+**     (2)   Copy each input character into the output buffer, one by
+**           one, adding the offset value as you copy.
+**
+**     (3)   If the value of an input character plus offset is 0x00, replace
+**           that one character by the two-character sequence 0x01 0x01.
+**           If the sum is 0x01, replace it with 0x01 0x02.  If the sum
+**           is 0x27, replace it with 0x01 0x03.
+**
+**     (4)   Put a 0x00 terminator at the end of the output.
+**
+** Decoding is obvious:
+**
+**     (5)   Copy encoded characters except the first into the decode 
+**           buffer.  Set the first encoded character aside for use as
+**           the offset in step 7 below.
+**
+**     (6)   Convert each 0x01 0x01 sequence into a single character 0x00.
+**           Convert 0x01 0x02 into 0x01.  Convert 0x01 0x03 into 0x27.
+**
+**     (7)   Subtract the offset value that was the first character of
+**           the encoded buffer from all characters in the output buffer.
+**
+** The only tricky part is step (1) - how to compute an offset value to
+** minimize the size of the output buffer.  This is accomplished by testing
+** all offset values and picking the one that results in the fewest number
+** of escapes.  To do that, we first scan the entire input and count the
+** number of occurances of each character value in the input.  Suppose
+** the number of 0x00 characters is N(0), the number of occurances of 0x01
+** is N(1), and so forth up to the number of occurances of 0xff is N(255).
+** An offset of 0 is not allowed so we don't have to test it.  The number
+** of escapes required for an offset of 1 is N(1)+N(2)+N(40).  The number
+** of escapes required for an offset of 2 is N(2)+N(3)+N(41).  And so forth.
+** In this way we find the offset that gives the minimum number of escapes,
+** and thus minimizes the length of the output string.
+*/
+
+/*
+** Encode a binary buffer "in" of size n bytes so that it contains
+** no instances of characters '\'' or '\000'.  The output is 
+** null-terminated and can be used as a string value in an INSERT
+** or UPDATE statement.  Use sqlite3_decode_binary() to convert the
+** string back into its original binary.
+**
+** The result is written into a preallocated output buffer "out".
+** "out" must be able to hold at least 2 +(257*n)/254 bytes.
+** In other words, the output will be expanded by as much as 3
+** bytes for every 254 bytes of input plus 2 bytes of fixed overhead.
+** (This is approximately 2 + 1.0118*n or about a 1.2% size increase.)
+**
+** The return value is the number of characters in the encoded
+** string, excluding the "\000" terminator.
+*/
+int sqlite3_encode_binary(const unsigned char *in, int n, unsigned char *out){
+  int i, j, e, m;
+  int cnt[256];
+  if( n<=0 ){
+    out[0] = 'x';
+    out[1] = 0;
+    return 1;
+  }
+  memset(cnt, 0, sizeof(cnt));
+  for(i=n-1; i>=0; i--){ cnt[in[i]]++; }
+  m = n;
+  for(i=1; i<256; i++){
+    int sum;
+    if( i=='\'' ) continue;
+    sum = cnt[i] + cnt[(i+1)&0xff] + cnt[(i+'\'')&0xff];
+    if( sum<m ){
+      m = sum;
+      e = i;
+      if( m==0 ) break;
+    }
+  }
+  out[0] = e;
+  j = 1;
+  for(i=0; i<n; i++){
+    int c = (in[i] - e)&0xff;
+    if( c==0 ){
+      out[j++] = 1;
+      out[j++] = 1;
+    }else if( c==1 ){
+      out[j++] = 1;
+      out[j++] = 2;
+    }else if( c=='\'' ){
+      out[j++] = 1;
+      out[j++] = 3;
+    }else{
+      out[j++] = c;
+    }
+  }
+  out[j] = 0;
+  return j;
+}
+
+/*
+** Decode the string "in" into binary data and write it into "out".
+** This routine reverses the encoding created by sqlite3_encode_binary().
+** The output will always be a few bytes less than the input.  The number
+** of bytes of output is returned.  If the input is not a well-formed
+** encoding, -1 is returned.
+**
+** The "in" and "out" parameters may point to the same buffer in order
+** to decode a string in place.
+*/
+int sqlite3_decode_binary(const unsigned char *in, unsigned char *out){
+  int i, c, e;
+  e = *(in++);
+  i = 0;
+  while( (c = *(in++))!=0 ){
+    if( c==1 ){
+      c = *(in++);
+      if( c==1 ){
+        c = 0;
+      }else if( c==2 ){
+        c = 1;
+      }else if( c==3 ){
+        c = '\'';
+      }else{
+        return -1;
+      }
+    }
+    out[i++] = (c + e)&0xff;
+  }
+  return i;
+}
+

code/train/C++/0007941_solution.cpp

@@ -0,0 +1,22 @@
+#include "../common.h"
+
+class Solution
+{
+  public:
+    int maxProfit(const vector<int> &prices)
+    {
+        if (prices.size() <= 1)
+        {
+            return 0;
+        }
+        int result = prices[1] - prices[0];
+        int last = result;
+        for (int i = 2; i < prices.size(); i++)
+        {
+            int diff = prices[i] - prices[i - 1];
+            last = last > 0 ? last + diff : diff;
+            result = max(result, last);
+        }
+        return result > 0 ? result : 0;
+    }
+};

code/train/C++/0008009_FoxAndDoraemon.cpp

@@ -0,0 +1,57 @@
+#include <algorithm>
+#include <cassert>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <functional>
+
+using namespace std;
+
+vector<int> W;
+int C;
+bool can(int T) {
+    long long foxes = 1;
+    int cur = 0;
+    for (int i=0; i<(int)W.size(); ++i) {
+        if (foxes==0 || cur+W[i]>T) {
+            return false;
+        }
+        int nsplits = (T-cur-W[i])/C;
+        while (i+foxes<(int)W.size() && nsplits--) {
+            foxes <<= 1;
+            cur += C;
+        }
+        assert(cur + W[i] <= T);
+        --foxes;
+    }
+    return true;
+}
+class FoxAndDoraemon {
+public:
+    int minTime(vector <int> workCost, int splitCost) {
+        W = workCost;
+        sort(W.begin(), W.end(), greater<int>());
+        C = splitCost;
+        int lo = 1;
+        int hi = 2;
+        while (!can(hi)) {
+            lo = hi + 1;
+            hi <<= 1;
+        }
+        
+        while (lo < hi) {
+            int mid = lo + (hi-lo)/2;
+            if (can(mid)) {
+                hi = mid;
+            } else {
+                lo = mid + 1;
+            }
+        }
+        return lo;
+    }
+};

code/train/C++/0008879_IPCWorkerThread.cpp

@@ -0,0 +1,119 @@
+/*
+ * Free RIL implementation for Samsung Android-based smartphones.
+ * Copyright (C) 2012  Sergey Gridasov <grindars@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+
+#include "IPCWorkerThread.h"
+#include "IIPCTransport.h"
+#include "IIPCSocket.h"
+#include "SocketHandler.h"
+#include "Log.h"
+#include "IPCSocketHandler.h"
+
+using namespace SamsungIPC;
+
+IPCWorkerThread::IPCWorkerThread() {
+    if(pipe(m_controlPipe) == -1)
+        Log::panicErrno("pipe");
+}
+
+IPCWorkerThread::~IPCWorkerThread() {
+    close(m_controlPipe[0]);
+    close(m_controlPipe[1]);
+}
+
+int IPCWorkerThread::run() {
+    dispatchEvents();
+
+    for(std::list<SocketHandler *>::iterator it = m_handlers.begin(), end = m_handlers.end(); it != end; it++) {
+        delete *it;
+    }
+
+    return 0;
+}
+
+void IPCWorkerThread::addHandler(SocketHandler *handler) {
+    m_handlers.push_back(handler);
+}
+
+void IPCWorkerThread::removeHandler(SocketHandler *handler) {
+    m_handlers.remove(handler);
+}
+
+void IPCWorkerThread::dispatchEvents() {
+    while(1) {
+        int maxfd = 0;
+        fd_set read_set, write_set;
+
+        for(std::list<SocketHandler *>::iterator it = m_handlers.begin(), end = m_handlers.end(); it != end; it++) {
+            SocketHandler *handler = *it;
+            int fd = handler->fd();
+
+            maxfd = std::max<int>(maxfd, fd);
+
+            if(handler->wantRead())
+                FD_SET(fd, &read_set);
+
+            if(handler->wantWrite())
+                FD_SET(fd, &write_set);
+        }
+
+        FD_SET(m_controlPipe[0], &read_set);
+
+        int ret = select(maxfd + 1, &read_set, &write_set, NULL, NULL);
+
+        if(ret == -1)
+            Log::panicErrno("select");
+
+        for(std::list<SocketHandler *>::iterator it = m_handlers.begin(), end = m_handlers.end(); it != end; it++) {
+            SocketHandler *handler = *it;
+            int fd = handler->fd();
+
+            if(FD_ISSET(fd, &read_set))
+                handler->readable();
+
+            if(FD_ISSET(fd, &write_set))
+                handler->writable();
+        }
+
+        if(FD_ISSET(m_controlPipe[0], &read_set)) {
+            Message *msg;
+
+            int bytes = read(m_controlPipe[0], &msg, sizeof(msg));
+            if(bytes == -1)
+                Log::panicErrno("read(controlPipe)");
+
+            if(msg == NULL) {
+                Log::info("Shutdown requested");
+
+                break;
+            } else {
+                static_cast<IPCSocketHandler *>(m_handlers.front())->submit(msg);
+            }
+        }
+    }
+}
+
+void IPCWorkerThread::submit(Message *message) {
+    int bytes = write(m_controlPipe[1], &message, sizeof(message));
+
+    if(bytes != sizeof(message))
+        Log::panicErrno("write(controlPipe)");
+}
+

code/train/C++/0009074_cafToggleItemsOnOthersOffFeature.cpp

@@ -0,0 +1,162 @@
+//##################################################################################################
+//
+//   Custom Visualization Core library
+//   Copyright (C) 2019- Ceetron Solutions AS
+//
+//   This library may be used under the terms of either the GNU General Public License or
+//   the GNU Lesser General Public License as follows:
+//
+//   GNU General Public License Usage
+//   This library is free software: you can redistribute it and/or modify
+//   it under the terms of the GNU General Public License as published by
+//   the Free Software Foundation, either version 3 of the License, or
+//   (at your option) any later version.
+//
+//   This library is distributed in the hope that it will be useful, but WITHOUT ANY
+//   WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//   FITNESS FOR A PARTICULAR PURPOSE.
+//
+//   See the GNU General Public License at <<http://www.gnu.org/licenses/gpl.html>>
+//   for more details.
+//
+//   GNU Lesser General Public License Usage
+//   This library is free software; you can redistribute it and/or modify
+//   it under the terms of the GNU Lesser General Public License as published by
+//   the Free Software Foundation; either version 2.1 of the License, or
+//   (at your option) any later version.
+//
+//   This library is distributed in the hope that it will be useful, but WITHOUT ANY
+//   WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//   FITNESS FOR A PARTICULAR PURPOSE.
+//
+//   See the GNU Lesser General Public License at <<http://www.gnu.org/licenses/lgpl-2.1.html>>
+//   for more details.
+//
+//##################################################################################################
+
+#include "cafToggleItemsOnOthersOffFeature.h"
+
+#include "cafToggleItemsFeatureImpl.h"
+
+#include "cafSelectionManager.h"
+
+#include "cafPdmObject.h"
+#include "cafPdmObjectHandle.h"
+#include "cafPdmUiItem.h"
+#include <QAction>
+
+namespace caf
+{
+CAF_CMD_SOURCE_INIT( ToggleItemsOnOthersOffFeature, "cafToggleItemsOnOthersOffFeature" );
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool ToggleItemsOnOthersOffFeature::isCommandEnabled()
+{
+    std::vector<caf::PdmObject*> selectedObjects;
+    caf::SelectionManager::instance()->objectsByType( &selectedObjects );
+
+    caf::PdmFieldHandle*               commonParent = verifySameParentForSelection( selectedObjects );
+    std::vector<caf::PdmObjectHandle*> children     = childObjects( commonParent );
+
+    return commonParent != nullptr && children.size() > 0 && objectToggleField( children.front() ) &&
+           children.size() > selectedObjects.size();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void ToggleItemsOnOthersOffFeature::onActionTriggered( bool isChecked )
+{
+    std::vector<caf::PdmObject*> selectedObjects;
+    caf::SelectionManager::instance()->objectsByType( &selectedObjects );
+
+    // First toggle off all siblings
+
+    caf::PdmFieldHandle* commonParent = verifySameParentForSelection( selectedObjects );
+
+    for ( caf::PdmObjectHandle* child : childObjects( commonParent ) )
+    {
+        caf::PdmField<bool>* field = objectToggleField( child );
+
+        if ( field )
+        {
+            field->setValueWithFieldChanged( false );
+        }
+    }
+
+    // Then toggle on the selected item(s)
+    for ( caf::PdmObject* selectedObject : selectedObjects )
+    {
+        caf::PdmField<bool>* field = dynamic_cast<caf::PdmField<bool>*>( selectedObject->objectToggleField() );
+
+        field->setValueWithFieldChanged( true );
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void ToggleItemsOnOthersOffFeature::setupActionLook( QAction* actionToSetup )
+{
+    actionToSetup->setText( "On - Others Off" );
+
+    actionToSetup->setIcon( QIcon( ":/cafCommandFeatures/ToggleOnOthersOffL16x16.png" ) );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+caf::PdmFieldHandle*
+    ToggleItemsOnOthersOffFeature::verifySameParentForSelection( const std::vector<caf::PdmObject*>& selection )
+{
+    caf::PdmFieldHandle* sameParent = nullptr;
+
+    for ( caf::PdmObject* obj : selection )
+    {
+        caf::PdmFieldHandle* parent = obj->parentField();
+        if ( parent )
+        {
+            if ( !sameParent )
+            {
+                sameParent = parent;
+            }
+            else if ( parent != sameParent )
+            {
+                // Different parents detected
+
+                return nullptr;
+            }
+        }
+    }
+    return sameParent;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::vector<caf::PdmObjectHandle*> ToggleItemsOnOthersOffFeature::childObjects( caf::PdmFieldHandle* parent )
+{
+    std::vector<caf::PdmObjectHandle*> children;
+    if ( parent )
+    {
+        parent->childObjects( &children );
+    }
+    return children;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+caf::PdmField<bool>* ToggleItemsOnOthersOffFeature::objectToggleField( caf::PdmObjectHandle* objectHandle )
+{
+    caf::PdmUiObjectHandle* childUiObject = uiObj( objectHandle );
+    if ( childUiObject && childUiObject->objectToggleField() )
+    {
+        return dynamic_cast<caf::PdmField<bool>*>( childUiObject->objectToggleField() );
+    }
+    return nullptr;
+}
+
+} // namespace caf

code/train/C++/0009203_PathTransform.cpp

@@ -0,0 +1,178 @@
+/*
+	Copyright (C) 2011 Róbert Vašek <gman@codefreax.org>
+
+    This file is part of fsync.
+
+    fsync is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    fsync is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with fsync.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <cstring>
+#include <iostream>
+#include <boost/lexical_cast.hpp>
+#include "PathTransform.h"
+#include "LogManager.h"
+#include "defs.h"
+
+using namespace std;
+using namespace boost::filesystem;
+
+path PathTransform::getPath(PathId id)
+{
+	for (ID_Path_pairList::const_iterator i = m_id_path_pairList.begin(); i != m_id_path_pairList.end(); i++)
+	{
+		if (i->first == id)
+		{
+			if (id >= 0)
+				return i->second;
+			else
+			{
+				path parentPath = getPath(id * -1);
+				parentPath /= i->second;
+
+				return parentPath;
+			}
+		}
+	}
+
+	return path();
+}
+
+PathId PathTransform::getPathId(const path & p)
+{
+	for (ID_Path_pairList::const_iterator i = m_id_path_pairList.begin(); i != m_id_path_pairList.end(); i++)
+	{
+		if (i->second == p)
+			return i->first;
+	}
+
+	return 0;
+}
+
+bool PathTransform::checkPathAndLog(const path & p, PathId pathId)
+{
+	if (strlen(p.c_str()) == 0)
+	{
+		string errMsg = "Path with id ";
+		errMsg += boost::lexical_cast<string>(pathId);
+		errMsg += " is not defined, skipping";
+		LogManager::getInstancePtr()->log(errMsg, LogManager::L_WARNING);
+
+		return false;
+	}
+
+	return true;
+}
+
+void PathTransform::cutPath(PathId pathId, const char * pth, char * outPath)
+{
+	path p = getPath(pathId);
+	strcpy(outPath, (pth + strlen(p.c_str()) + 1)); // +1 because of the directory separator
+}
+
+path PathTransform::glueCutPath(PathId pathId, const char * p)
+{
+	return getPath(pathId) / p;
+}
+
+PathList PathTransform::getIncludingPaths()
+{
+	PathList pl;
+
+	for (ID_Path_pairList::const_iterator i = m_id_path_pairList.begin(); i != m_id_path_pairList.end(); i++)
+	{
+		if (i->first >= 0)
+			pl.push_back(i->second);
+	}
+
+	return pl;
+}
+
+PathList PathTransform::getExcludingPaths()
+{
+	PathList pl;
+
+	for (ID_Path_pairList::const_iterator i = m_id_path_pairList.begin(); i != m_id_path_pairList.end(); i++)
+	{
+		PathId id = i->first;
+
+		if (id < 0)
+		{
+			path parentPath = getPath(id * -1);
+			parentPath /= i->second;
+
+			pl.push_back(parentPath);
+		}
+	}
+
+	return pl;
+}
+
+bool PathTransform::isExcluded(const path & currentPath, PathId pathId)
+{
+	vector<path> absoluteExcldPaths;
+	path parentPath = getPath(pathId);
+	PathId excldPathId = pathId * -1;
+
+	for (ID_Path_pairList::const_iterator i = m_id_path_pairList.begin(); i != m_id_path_pairList.end(); i++)
+	{
+		if (i->first == excldPathId)
+			absoluteExcldPaths.push_back(parentPath / i->second);
+	}
+
+	if (absoluteExcldPaths.empty())
+		return false;
+
+	vector<string> currentPathParts = makeParts(currentPath);
+	int currentPartsSize = currentPathParts.size();
+
+	for (vector<path>::const_iterator i = absoluteExcldPaths.begin(); i != absoluteExcldPaths.end(); i++)
+	{
+		vector<string> absoluteExcldParts = makeParts(*i);
+		int excldPartsSize = absoluteExcldParts.size();
+
+		if (currentPartsSize < excldPartsSize)
+			continue;
+		
+		bool isExcluded = true;
+
+		for (int j = 0; j < excldPartsSize; j++)
+		{
+			if (currentPathParts[j] != absoluteExcldParts[j])
+			{
+				isExcluded = false;
+				break;
+			}
+		}
+
+		if (isExcluded)
+			return true;
+	}
+	
+	return false;
+}
+
+vector<string> PathTransform::makeParts(const path & p) const
+{
+	vector<string> parts;
+
+	for (path::const_iterator i = p.begin(); i != p.end(); i++)
+		parts.push_back(i->string());
+	
+	return parts;
+}
+
+path PathTransform::operator[](PathId id)
+{
+	return getPath(id);
+}

code/train/C++/0009912_zonedessin.cpp

@@ -0,0 +1,125 @@
+#include "zonedessin.h"
+
+zoneDessin::zoneDessin(QRect geometry, QWidget *parent):QWidget(parent)
+{
+    setGeometry(geometry);
+    setStyleSheet("background-color: white;");
+}
+
+void zoneDessin::spectre()
+{
+    donnees.clear();
+    valMax=0;
+    //int hz=info.retourFrequenceI();
+    QFile file(info.retourChemin());
+    tailleFichier=file.size()-44;
+    if(file.open(QFile::ReadOnly)){
+        QByteArray data=file.readAll();
+        QDataStream analyse(&data,QIODevice::ReadOnly);
+
+        //Passer les metadonnées
+        if(info.retourExtension()=="wav"){
+            analyse.setByteOrder(QDataStream::LittleEndian);
+            char meta[44];
+            analyse.readRawData(meta,44);
+        }
+
+        if(info.retourExtension()=="aif" || info.retourExtension()=="aiff"){
+            analyse.setByteOrder(QDataStream::BigEndian);
+            char meta[28];
+            analyse.readRawData(meta,28);
+        }
+
+        //int saut=(tailleFichier/width())+info.retourEchantillonageI();
+        int saut=info.retourEchantillonageI();
+        //char SData[16];
+        char sautDonnees[saut];
+        qint16 don;
+        int x=0;
+        while(!analyse.atEnd()){
+            //analyse.readRawData(SData,16);
+            //donnees[x]=QString::fromLatin1(SData).toInt();
+            analyse>>don;
+            donnees<<don;
+            if(donnees[x]>valMax)
+                valMax=donnees[x];
+            analyse.readRawData(sautDonnees,saut);
+            x++;
+        }
+        /*for(int x=0;x<10000;x++)
+            donnees.removeLast();*/
+
+        //Mise à l'échelle
+        valMax-=10;
+        for(int x=0;x<donnees.length();x++){
+            donnees[x]=(donnees[x]*height()/2)/valMax;
+            if(donnees[x]<0)
+                donnees[x]*=(-1);
+            if(donnees[x]==0)
+                donnees[x]=height()/2;
+            else donnees[x]+=height()/2;
+        }
+    }
+    update();
+}
+
+void zoneDessin::paintEvent(QPaintEvent *event)
+{
+    //Permettre l'utilisation de StyleSheet
+    QStyleOption opt;
+    opt.init(this);
+    QPainter p(this);
+    style()->drawPrimitive(QStyle::PE_Widget, &opt, &p, this);
+
+    //Créer le painter
+    QPainter painter(this);
+    painter.setRenderHint(QPainter::Antialiasing);
+    painter.setPen(pen);
+    pen.setWidth(2);
+    painter.drawLine(0,height()/2,width(),height()/2);
+    pen.setWidth(1);
+    pen.setColor(Qt::black);
+    //Vidage de la liste
+    for(int x=0;x<width();x++){
+        courbe<<height()/2;
+    }
+    //Création de la courbe
+    int posX=0;
+    int moy=donnees.length()/width();
+    for(int x=0;posX<width();x+=moy){
+        int temp=0;
+        for(int y=0;y<moy;y++)
+        if(x+y<donnees.length())
+            temp+=donnees[x+y];
+        temp/=moy;
+        courbe[posX++]=temp;
+    }
+    //Définition de l'échelle
+    int high=0;
+    int low=height();
+    for(int x=0;x<courbe.length();x++){
+        if(courbe[x]>high)
+            high=courbe[x];
+        if(courbe[x]<low)
+            low=courbe[x];
+    }
+    //int pour=(height()-5)-(height()/2);
+    float coeff=(float)(height()-5)/(float)high;
+    /*for(int x=0;x<courbe.length();x++){
+        courbe[x]*=(courbe[x]*coeff)/high;
+    }*/
+    //Dessin sur le widget
+    int y=0;
+    /*for(int x=1;x<width();x++){
+        painter.drawLine(y,courbe[x-1],y+1,courbe[x]);
+        painter.drawLine(y,height()/2-(courbe[x-1]-(height()/2)),y+1,(height()/2)-(courbe[x]-(height()/2)));
+        y++;
+    }*/
+    for(int x=1;x<width();x++){
+        painter.drawLine(y,courbe[x-1]*((courbe[x-1]*coeff)/high),y+1,courbe[x]*((courbe[x]*coeff)/high));
+        painter.drawLine(y,height()/2-(courbe[x-1]*((courbe[x-1]*coeff)/high)-(height()/2)),y+1,(height()/2)-(courbe[x]*((courbe[x]*coeff)/high)-(height()/2)));
+        y++;
+    }
+    painter.end();
+    event->accept();
+}

code/train/C++/0009915_sp-switch.cpp

@@ -0,0 +1,159 @@
+/*
+ * SVG <switch> implementation
+ *
+ * Authors:
+ *   Andrius R. <knutux@gmail.com>
+ *   MenTaLguY  <mental@rydia.net>
+ *   Jon A. Cruz <jon@joncruz.org>
+ *   Abhishek Sharma
+ *
+ * Copyright (C) 2006 authors
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include <glibmm/i18n.h>
+
+#include "sp-switch.h"
+#include "display/drawing-group.h"
+#include "conditions.h"
+
+#include <sigc++/functors/ptr_fun.h>
+#include <sigc++/adaptors/bind.h>
+
+SPSwitch::SPSwitch() : SPGroup() {
+    this->_cached_item = 0;
+}
+
+SPSwitch::~SPSwitch() {
+    _releaseLastItem(_cached_item);
+}
+
+SPObject *SPSwitch::_evaluateFirst() {
+    SPObject *first = 0;
+
+    for (SPObject *child = this->firstChild() ; child && !first ; child = child->getNext() ) {
+        if (SP_IS_ITEM(child) && sp_item_evaluate(SP_ITEM(child))) {
+        	first = child;
+        }
+    }
+
+    return first;
+}
+
+std::vector<SPObject*> SPSwitch::_childList(bool add_ref, SPObject::Action action) {
+    if ( action != SPObject::ActionGeneral ) {
+        return this->childList(add_ref, action);
+    }
+
+    SPObject *child = _evaluateFirst();
+    std::vector<SPObject*> x;
+    if (NULL == child)
+        return x;
+
+    if (add_ref) {
+        //g_object_ref (G_OBJECT (child));
+    	sp_object_ref(child);
+    }
+    x.push_back(child);
+    return x;
+}
+
+const char *SPSwitch::displayName() const {
+    return _("Conditional Group");
+}
+
+gchar *SPSwitch::description() const {
+    gint len = this->getItemCount();
+    return g_strdup_printf(
+        ngettext(_("of <b>%d</b> object"), _("of <b>%d</b> objects"), len), len);
+}
+
+void SPSwitch::child_added(Inkscape::XML::Node* child, Inkscape::XML::Node* ref) {
+    SPGroup::child_added(child, ref);
+
+    this->_reevaluate(true);
+}
+
+void SPSwitch::remove_child(Inkscape::XML::Node *child) {
+    SPGroup::remove_child(child);
+
+    this->_reevaluate();
+}
+
+void SPSwitch::order_changed (Inkscape::XML::Node *child, Inkscape::XML::Node *old_ref, Inkscape::XML::Node *new_ref)
+{
+    SPGroup::order_changed(child, old_ref, new_ref);
+
+	this->_reevaluate();
+}
+
+void SPSwitch::_reevaluate(bool /*add_to_drawing*/) {
+    SPObject *evaluated_child = _evaluateFirst();
+    if (!evaluated_child || _cached_item == evaluated_child) {
+        return;
+    }
+
+    _releaseLastItem(_cached_item);
+
+    std::vector<SPObject*> item_list = _childList(false, SPObject::ActionShow);
+    for ( std::vector<SPObject*>::const_reverse_iterator iter=item_list.rbegin();iter!=item_list.rend();++iter) {
+        SPObject *o = *iter;
+        if ( !SP_IS_ITEM (o) ) {
+            continue;
+        }
+
+        SPItem * child = SP_ITEM(o);
+        child->setEvaluated(o == evaluated_child);
+    }
+
+    _cached_item = evaluated_child;
+    _release_connection = evaluated_child->connectRelease(sigc::bind(sigc::ptr_fun(&SPSwitch::_releaseItem), this));
+
+    this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
+}
+
+void SPSwitch::_releaseItem(SPObject *obj, SPSwitch *selection)
+{
+    selection->_releaseLastItem(obj);
+}
+
+void SPSwitch::_releaseLastItem(SPObject *obj)
+{
+    if (NULL == this->_cached_item || this->_cached_item != obj)
+        return;
+
+    this->_release_connection.disconnect();
+    this->_cached_item = NULL;
+}
+
+void SPSwitch::_showChildren (Inkscape::Drawing &drawing, Inkscape::DrawingItem *ai, unsigned int key, unsigned int flags) {
+    SPObject *evaluated_child = this->_evaluateFirst();
+
+    std::vector<SPObject*> l = this->_childList(false, SPObject::ActionShow);
+
+    for ( std::vector<SPObject*>::const_reverse_iterator iter=l.rbegin();iter!=l.rend();++iter) {
+        SPObject *o = *iter;
+
+        if (SP_IS_ITEM (o)) {
+            SPItem * child = SP_ITEM(o);
+            child->setEvaluated(o == evaluated_child);
+            Inkscape::DrawingItem *ac = child->invoke_show (drawing, key, flags);
+
+            if (ac) {
+                ai->appendChild(ac);
+            }
+        }
+    }
+}
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :

code/train/C++/0010000_track.cpp

@@ -0,0 +1,93 @@
+#include "map/track.hpp"
+
+#include "map/bookmark_helpers.hpp"
+#include "map/user_mark_id_storage.hpp"
+
+#include "geometry/distance_on_sphere.hpp"
+#include "geometry/mercator.hpp"
+
+#include <utility>
+
+Track::Track(kml::TrackData && data)
+  : Base(data.m_id == kml::kInvalidTrackId ? UserMarkIdStorage::Instance().GetNextTrackId() : data.m_id)
+  , m_data(std::move(data))
+  , m_groupID(0)
+{
+  m_data.m_id = GetId();
+  ASSERT_GREATER(m_data.m_points.size(), 1, ());
+}
+
+std::string Track::GetName() const
+{
+  return GetPreferredBookmarkStr(m_data.m_name);
+}
+
+m2::RectD Track::GetLimitRect() const
+{
+  m2::RectD rect;
+  for (auto const & point : m_data.m_points)
+    rect.Add(point);
+  return rect;
+}
+
+double Track::GetLengthMeters() const
+{
+  double res = 0.0;
+
+  auto it = m_data.m_points.begin();
+  double lat1 = MercatorBounds::YToLat(it->y);
+  double lon1 = MercatorBounds::XToLon(it->x);
+  for (++it; it != m_data.m_points.end(); ++it)
+  {
+    double const lat2 = MercatorBounds::YToLat(it->y);
+    double const lon2 = MercatorBounds::XToLon(it->x);
+    res += ms::DistanceOnEarth(lat1, lon1, lat2, lon2);
+    lat1 = lat2;
+    lon1 = lon2;
+  }
+
+  return res;
+}
+
+df::DepthLayer Track::GetDepthLayer() const
+{
+  return df::DepthLayer::UserLineLayer;
+}
+
+size_t Track::GetLayerCount() const
+{
+  return m_data.m_layers.size();
+}
+
+dp::Color Track::GetColor(size_t layerIndex) const
+{
+  CHECK_LESS(layerIndex, m_data.m_layers.size(), ());
+  return dp::Color(m_data.m_layers[layerIndex].m_color.m_rgba);
+}
+
+float Track::GetWidth(size_t layerIndex) const
+{
+  CHECK_LESS(layerIndex, m_data.m_layers.size(), ());
+  return static_cast<float>(m_data.m_layers[layerIndex].m_lineWidth);
+}
+
+float Track::GetDepth(size_t layerIndex) const
+{
+  return layerIndex * 10;
+}
+
+std::vector<m2::PointD> const & Track::GetPoints() const
+{
+  return m_data.m_points;
+}
+
+void Track::Attach(kml::MarkGroupId groupId)
+{
+  ASSERT(!m_groupID, ());
+  m_groupID = groupId;
+}
+
+void Track::Detach()
+{
+  m_groupID = 0;
+}

code/train/C++/0010267_sgmm-acc-fmllrbasis-ali.cc

@@ -0,0 +1,216 @@
+// sgmmbin/sgmm-acc-fmllrbasis-ali.cc
+
+// Copyright 2009-2011  Saarland University
+// Author:  Arnab Ghoshal
+
+// See ../../COPYING for clarification regarding multiple authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+// MERCHANTABLITY OR NON-INFRINGEMENT.
+// See the Apache 2 License for the specific language governing permissions and
+// limitations under the License.
+
+#include <vector>
+
+#include "util/common-utils.h"
+#include "hmm/transition-model.h"
+#include "sgmm/am-sgmm.h"
+#include "sgmm/fmllr-sgmm.h"
+
+int main(int argc, char *argv[]) {
+  try {
+    using namespace kaldi;
+    const char *usage =
+        "Accumulate stats for FMLLR bases training.\n"
+        "Usage: sgmm-acc-fmllrbasis-ali [options] <model-in> <feature-rspecifier> "
+        "<alignments-rspecifier> <spk2utt-rspecifier> <stats-out>\n"
+        "e.g.: sgmm-acc-fmllrbasis-ali 1.mdl scp:train.scp ark:1.ali 1.acc\n";
+
+    ParseOptions po(usage);
+    bool binary_write = true;
+    std::string gselect_rspecifier, spkvecs_rspecifier, silphones_str;
+    BaseFloat sil_weight = 0.0;
+    kaldi::SgmmGselectConfig sgmm_opts;
+    po.Register("binary", &binary_write, "Write output in binary mode");
+    po.Register("gselect", &gselect_rspecifier,
+                "Precomputed Gaussian indices (rspecifier)");
+    po.Register("spk-vecs", &spkvecs_rspecifier,
+                "Speaker vectors to use during aligment (rspecifier)");
+    po.Register("sil-phone-list", &silphones_str,
+                "Colon-separated list of phones (to weigh differently)");
+    po.Register("sil-weight", &sil_weight, "Weight for \"silence\" phones.");
+    sgmm_opts.Register(&po);
+    po.Read(argc, argv);
+
+    if (po.NumArgs() != 5) {
+      po.PrintUsage();
+      exit(1);
+    }
+
+    std::string model_filename = po.GetArg(1),
+        feature_rspecifier = po.GetArg(2),
+        alignments_rspecifier = po.GetArg(3),
+        spk2utt_rspecifier = po.GetArg(4),
+        accs_wxfilename = po.GetArg(5);
+
+    typedef kaldi::int32 int32;
+
+    AmSgmm am_sgmm;
+    TransitionModel trans_model;
+    SgmmFmllrGlobalParams fmllr_globals;
+    {
+      bool binary;
+      Input ki(model_filename, &binary);
+      trans_model.Read(ki.Stream(), binary);
+      am_sgmm.Read(ki.Stream(), binary);
+      fmllr_globals.Read(ki.Stream(), binary);
+    }
+
+    SequentialTokenVectorReader spk2utt_reader(spk2utt_rspecifier);
+    RandomAccessBaseFloatMatrixReader feature_reader(feature_rspecifier);
+    RandomAccessInt32VectorReader alignments_reader(alignments_rspecifier);
+
+    RandomAccessInt32VectorVectorReader gselect_reader(gselect_rspecifier);
+
+    RandomAccessBaseFloatVectorReader spkvecs_reader(spkvecs_rspecifier);
+
+    std::vector<int32> silence_phones;
+    if (!SplitStringToIntegers(silphones_str, ":", false, &silence_phones)) {
+      KALDI_ERR << "Silence-phones string has wrong format "
+                << silphones_str;
+    }
+    ConstIntegerSet<int32> silence_set(silence_phones);  // faster lookup.
+
+
+    kaldi::SgmmPerFrameDerivedVars per_frame_vars;
+    SpMatrix<double> fmllr_grad_scatter;
+    int32 dim = am_sgmm.FeatureDim();
+    fmllr_grad_scatter.Resize(dim * (dim + 1), kSetZero);
+    FmllrSgmmAccs spk_stats;
+    spk_stats.Init(dim, am_sgmm.NumGauss());
+
+    double tot_like = 0.0, tot_t = 0.0;
+    int32 num_done = 0, num_no_alignment = 0, num_other_error = 0;
+
+    for (; !spk2utt_reader.Done(); spk2utt_reader.Next()) {
+      spk_stats.SetZero();
+      string spk = spk2utt_reader.Key();
+      const std::vector<string> &uttlist = spk2utt_reader.Value();
+
+      SgmmPerSpkDerivedVars spk_vars;
+      if (spkvecs_reader.IsOpen()) {
+        if (spkvecs_reader.HasKey(spk)) {
+          spk_vars.v_s = spkvecs_reader.Value(spk);
+          am_sgmm.ComputePerSpkDerivedVars(&spk_vars);
+        } else {
+          KALDI_WARN << "Cannot find speaker vector for " << spk;
+          num_other_error++;
+          continue;
+        }
+      }  // else spk_vars is "empty"
+
+      for (size_t i = 0; i < uttlist.size(); i++) {
+        std::string utt = uttlist[i];
+        if (!alignments_reader.HasKey(utt)) {
+          num_no_alignment++;
+          continue;
+        }
+        const std::vector<int32> &alignment = alignments_reader.Value(utt);
+
+        if (!feature_reader.HasKey(utt)) {
+          KALDI_WARN << "Did not find features for utterance " << utt;
+          num_other_error++;
+          continue;
+        }
+        const Matrix<BaseFloat> &feats = feature_reader.Value(utt);
+
+        if (alignment.size() != feats.NumRows()) {
+          KALDI_WARN << "Alignments has wrong size "<< (alignment.size()) <<
+              " vs. "<< (feats.NumRows());
+          num_other_error++;
+          continue;
+        }
+
+        bool have_gselect = false;
+        if (gselect_reader.IsOpen()) {
+          if (gselect_reader.HasKey(utt)) {
+            have_gselect = (gselect_reader.Value(utt).size() == feats.NumRows());
+            if (!have_gselect)
+              KALDI_WARN << "Gaussian-selection info available for utterance "
+                         << utt << " has wrong size.";
+          } else {
+            KALDI_WARN << "No Gaussian-selection info available for utterance "
+                       << utt;
+          }
+        }
+
+        const std::vector<std::vector<int32> > *gselect =
+            (have_gselect ? &gselect_reader.Value(utt) : NULL);
+        double file_like = 0.0, file_t = 0.0;
+
+
+        for (size_t i = 0; i < alignment.size(); i++) {
+          int32 tid = alignment[i];  // transition identifier.
+          int32 pdf_id = trans_model.TransitionIdToPdf(tid),
+              phone = trans_model.TransitionIdToPhone(tid);
+          BaseFloat weight = 1.0;
+          if (silence_set.count(phone) != 0) {  // is a silence.
+            if (sil_weight > 0.0)
+              weight = sil_weight;
+            else
+              continue;
+          }
+
+          std::vector<int32> this_gselect;
+          if (gselect != NULL)
+            this_gselect = (*gselect)[i];
+          else
+            am_sgmm.GaussianSelection(sgmm_opts, feats.Row(i), &this_gselect);
+          am_sgmm.ComputePerFrameVars(feats.Row(i), this_gselect, spk_vars, 0.0,
+                                      &per_frame_vars);
+          file_like +=
+              spk_stats.Accumulate(am_sgmm, spk_vars, feats.Row(i),
+                                   per_frame_vars, pdf_id, weight);
+          file_t += weight;
+        }  // end looping over all the frames in the utterance
+        KALDI_VLOG(1) << "Average likelihood for utterance " << utt << " is "
+                      << (file_like/file_t) << " over " << file_t << " frames";
+        tot_like += file_like;
+        tot_t += file_t;
+        num_done++;
+        if (num_done % 20 == 0)
+          KALDI_VLOG(1) << "After " << num_done << " utterances: Average "
+                        << "likelihood per frame = " << (tot_like/tot_t)
+                        << ", over " << tot_t << " frames";
+      }  // end looping over all utterance for a given speaker
+      spk_stats.AccumulateForFmllrSubspace(am_sgmm, fmllr_globals, &fmllr_grad_scatter);
+    }  // end looping over all speakers
+
+    KALDI_LOG << "Done " << num_done << " files, " << num_no_alignment
+              << " with no alignments, " << num_other_error
+              << " with other errors.";
+
+    KALDI_LOG << "Overall likelihood per frame frame = " << (tot_like/tot_t)
+              << " over " << tot_t << " frames.";
+
+    {
+      Output ko(accs_wxfilename, binary_write);
+      fmllr_grad_scatter.Write(ko.Stream(), binary_write);
+      KALDI_LOG << "Written accs to: " << accs_wxfilename;
+    }
+    return (num_done != 0 ? 0 : 1);
+  } catch(const std::exception &e) {
+    std::cerr << e.what();
+    return -1;
+  }
+}
+
+

code/train/C++/0010531_CCSequence3D.cpp

@@ -0,0 +1,232 @@
+/****************************************************************************
+ Copyright (c) 2014 Chukong Technologies Inc.
+
+ http://www.cocos2d-x.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+
+#include "CCSequence3D.h"
+
+NS_CC_BEGIN
+
+#if (CC_TARGET_PLATFORM == CC_PLATFORM_WP8) || (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
+Sequence3D* Sequence3D::variadicCreate(Animate3D *action1, ...)
+{
+    va_list params;
+    va_start(params, action1);
+
+    Sequence3D *ret = Sequence3D::createWithVariableList(action1, params);
+
+    va_end(params);
+    
+    return ret;
+}
+#else
+Sequence3D* Sequence3D::create(Animate3D *action1, ...)
+{
+    va_list params;
+    va_start(params, action1);
+
+    Sequence3D *ret = Sequence3D::createWithVariableList(action1, params);
+
+    va_end(params);
+    
+    return ret;
+}
+#endif
+
+Sequence3D* Sequence3D::createWithVariableList(Animate3D *action1, va_list args)
+{
+    Animate3D *now;
+
+    Vector<Animate3D*> actions;
+    if (action1)
+        actions.pushBack(action1);
+
+    while (action1)
+    {
+        now = va_arg(args, Animate3D*);
+        if (now)
+        {
+            actions.pushBack(now);
+        }
+        else
+            break;
+    }
+    
+    return create(actions);
+}
+
+Sequence3D* Sequence3D::create(const Vector<Animate3D*>& arrayOfActions)
+{
+    Sequence3D* ret = nullptr;
+    
+    ret = new (std::nothrow) Sequence3D();
+    if (ret->initWithActions(arrayOfActions))
+    {
+        ret->autorelease();
+        return ret;
+    }
+    
+    CC_SAFE_RELEASE(ret);
+    return ret;
+}
+
+bool Sequence3D::initWithActions(const Vector<Animate3D*>& arrayOfActions)
+{
+    if (arrayOfActions.size() == 0)
+        return false;
+    
+    _actions.clear();
+    _startTime.clear();
+    _endTime.clear();
+    
+    Animate3D* preAction = nullptr;
+    float duration = 0.f, dur = 0.f;
+    _startTime.push_back(duration);
+    for (auto& it : arrayOfActions) {
+        float d1 = 0.f;
+        if (preAction)
+            d1 = preAction->getDuration();
+        
+        float d2 = it->getDuration();
+        if (d1 < Animate3D::getTransitionTime() || d2 < Animate3D::getTransitionTime())
+            dur = d1 > d2 ? d1 : d2;
+        else
+            dur = d1 + d2 - Animate3D::getTransitionTime();
+        
+        preAction = it;
+        _actions.pushBack(it);
+        _startTime.push_back(dur);
+        _endTime.push_back(dur);
+        duration += dur;
+    }
+    _startTime.erase(_startTime.end() - 1);
+    for (ssize_t i = 0; i < _startTime.size(); i++) {
+        _startTime[i] /= duration;
+        _endTime[i] /= duration;
+    }
+    setDuration(duration);
+    _curActionIdx = -1;
+    return true;
+}
+
+Sequence3D* Sequence3D::clone() const
+{
+	// no copy constructor
+	auto seq3d = new (std::nothrow) Sequence3D();
+    seq3d->initWithActions(_actions);
+	seq3d->autorelease();
+	return seq3d;
+}
+
+Sequence3D::Sequence3D()
+: _curActionIdx(-1)
+{
+    
+}
+
+Sequence3D::~Sequence3D(void)
+{
+    _actions.clear();
+}
+
+void Sequence3D::startWithTarget(Node *target)
+{
+    ActionInterval::startWithTarget(target);
+    _curActionIdx = -1;
+}
+
+void Sequence3D::stop(void)
+{
+    for (auto& action : _actions) {
+        action->stop();
+    }
+
+    ActionInterval::stop();
+}
+
+Sequence3D* Sequence3D::reverse() const
+{
+    Vector<Animate3D*> actions;
+    for (auto it = _actions.rbegin(); it != _actions.rend(); ++it) {
+        actions.pushBack(*it);
+    }
+    
+    return create(actions);
+}
+
+void Sequence3D::update(float t)
+{
+      if (_target)
+    {
+        int nextIdx = _curActionIdx + 1;
+        if (nextIdx < _actions.size())
+        {
+            if (t >= _startTime[nextIdx])
+            {
+                _actions.at(nextIdx)->startWithTarget(_target);
+            }
+        }
+        //update action
+        int preActionIdx = _curActionIdx - 1;
+        if (preActionIdx >= 0 && _endTime[preActionIdx] > t)
+        {
+            float newt = (t - _startTime[preActionIdx]) / (_endTime[preActionIdx] - _startTime[preActionIdx]);
+            _actions.at(preActionIdx)->update(newt);
+        }
+        if (_curActionIdx >= 0 && _curActionIdx < _actions.size())
+        {
+            float newt = (t - _startTime[_curActionIdx]) / (_endTime[_curActionIdx] - _startTime[_curActionIdx]);
+            _actions.at(_curActionIdx)->update(newt);
+        }
+    }
+}
+ void Sequence3D::step(float t)
+ {
+     ActionInterval::step(t) ;
+      if (_target)
+      {
+          float newt=MAX(0, MIN(1, _elapsed /MAX(_duration, FLT_EPSILON)));
+          int nextIdx = _curActionIdx + 1;
+          if (nextIdx < _actions.size())
+          {
+              if (newt >= _startTime[nextIdx])
+              {
+                  _curActionIdx = nextIdx;  
+              }
+          }
+          //update action
+          int preActionIdx = _curActionIdx - 1;
+          if (preActionIdx >= 0 && _endTime[preActionIdx] >newt)
+          {
+
+              _actions.at(preActionIdx)->step(t);
+            
+          }
+          if (_curActionIdx >= 0 && _curActionIdx < _actions.size())
+          {
+              _actions.at(_curActionIdx)->step(t);
+             
+          }
+      }
+ }
+
+NS_CC_END

code/train/C++/0010760_laser.cpp

@@ -0,0 +1,103 @@
+#include <cstdio>
+#include <cstring>
+#include <vector>
+using namespace std;
+
+
+#define MAXN 700
+
+
+typedef  unsigned char  uch;
+typedef  unsigned int   u32;
+
+
+//
+// Hash Map
+//
+#define HASHB 4096
+const size_t KeySz = sizeof(int) * 2;
+struct HM {
+    struct Key {
+        int d[2];
+        Key(int *D) { memcpy(d, D, KeySz); }
+        bool operator==(const Key &x) const {
+            return memcmp(d, x.d, KeySz) == 0; }
+    };
+    struct KV {
+        Key k; int v;
+        KV(const Key &K, int V) : k(K), v(V) {}
+    };
+    typedef vector<KV> KVV; KVV b[HASHB];
+    u32 fnv_hash(const Key &k, int len) const {
+        uch *p = reinterpret_cast<uch*>(const_cast<int*>(k.d));
+        u32 h = 2166136261U;
+        for (int i = 0; i < len; ++i) h = (h * 16777619U) ^ p[i];
+        return h;
+    }
+    int add(const Key &k) {
+        int i = fnv_hash(k, KeySz) % HASHB;
+        for (int j = 0, J = b[i].size(); j < J; ++j)
+            if (b[i][j].k == k)
+                return ++b[i][j].v;
+        b[i].push_back(KV(k, 2));
+        return 2;
+        return true;
+    }
+};
+
+
+template<typename T>
+T gcd(T a, T b) { for (T c = a%b; c != 0; a=b,b=c,c=a%b); return b; }
+
+
+int  n;
+int  pts[MAXN][2];
+
+
+int solve()
+{
+    if (n <= 2) return n;
+    int ans = 0;
+
+    int m[2];  // slope, as a rational number
+
+    for (int i = 0; i < n; ++i) {
+        HM hm;
+
+        for (int j = i + 1; j < n; ++j) {
+            if (pts[i][0] == pts[j][0])
+                m[0] = m[1] = 0;
+            else {
+                m[0] = pts[j][1] - pts[i][1];
+                m[1] = pts[j][0] - pts[i][0];
+
+                int g = gcd(m[0], m[1]);
+                m[0] /= g;
+                m[1] /= g;
+            }
+
+            int coll = hm.add(HM::Key(m));
+            if (coll > ans) ans = coll;
+        }
+    }
+
+    return ans;
+}
+
+int main()
+{
+    int T;
+    scanf("%d", &T);
+
+    int ncase = 0;
+    while (T--) {
+        scanf("%d", &n);
+
+        for (int i = 0; i < n; ++i)
+            scanf("%d%d", &pts[i][0], &pts[i][1]);
+
+        printf("Case %d: %d\n", ++ncase, solve());
+    }
+
+    return 0;
+}

code/train/C++/0011798_chapter04_ex16.cpp

@@ -0,0 +1,60 @@
+// Chapter 04, exercise 16: find the mode in a vector of integers entered by
+// user (only the first, not all of them)
+
+#include "../lib_files/std_lib_facilities.h"
+
+int get_mode(vector<int> v)
+{
+    sort(v.begin(),v.end());
+    int mode_cdt = v[0];
+    int mode_cdt_ctr = 1;
+    int mode = 0;
+    int mode_ctr = 1;
+    for (int i = 1; i<v.size(); ++i) {
+        if (v[i]==mode_cdt) {
+            ++mode_cdt_ctr;
+            if (mode_cdt_ctr>mode_ctr) {
+                mode = mode_cdt;
+                mode_ctr = mode_cdt_ctr;
+            }
+        }
+        else {
+            mode_cdt = v[i];
+            mode_cdt_ctr = 1;
+        }
+    }
+    cout << "Top value appears " << mode_ctr << " times.\n";
+    return mode;
+}
+
+int main()
+{
+    int n = 0;
+    int smallest = 0;
+    int largest = 0;
+    int mode = 0;
+    vector<int> vals;
+    bool is_first = true;
+
+    cout << "Enter sequence of integers:\n";
+
+    while (cin >> n) {
+        if (n < smallest || is_first)
+            smallest = n;
+        if (n > largest || is_first)
+            largest = n;
+        vals.push_back(n);
+        is_first = false;
+    }
+
+    mode = get_mode(vals);
+    cout << "smallest value: " << smallest << endl;
+    cout << "largest value: " << largest << endl;
+    cout << "mode: " << mode << endl;
+
+    sort(vals.begin(),vals.end());
+    cout << "values:" << endl;
+    for (int i = 0; i<vals.size(); ++i)
+        cout << vals[i] << endl;
+    return 0;
+}

code/train/C++/0012078_edit_distance.cc

@@ -0,0 +1,67 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "edit_distance.h"
+
+#include <algorithm>
+#include <vector>
+
+int EditDistance(const StringPiece& s1,
+                 const StringPiece& s2,
+                 bool allow_replacements,
+                 int max_edit_distance) {
+  // The algorithm implemented below is the "classic"
+  // dynamic-programming algorithm for computing the Levenshtein
+  // distance, which is described here:
+  //
+  //   http://en.wikipedia.org/wiki/Levenshtein_distance
+  //
+  // Although the algorithm is typically described using an m x n
+  // array, only two rows are used at a time, so this implementation
+  // just keeps two separate vectors for those two rows.
+  int m = s1.len_;
+  int n = s2.len_;
+
+  vector<int> previous(n + 1);
+  vector<int> current(n + 1);
+
+  for (int i = 0; i <= n; ++i)
+    previous[i] = i;
+
+  for (int y = 1; y <= m; ++y) {
+    current[0] = y;
+    int best_this_row = current[0];
+
+    for (int x = 1; x <= n; ++x) {
+      if (allow_replacements) {
+        current[x] = min(previous[x-1] + (s1.str_[y-1] == s2.str_[x-1] ? 0 : 1),
+                         min(current[x-1], previous[x])+1);
+      }
+      else {
+        if (s1.str_[y-1] == s2.str_[x-1])
+          current[x] = previous[x-1];
+        else
+          current[x] = min(current[x-1], previous[x]) + 1;
+      }
+      best_this_row = min(best_this_row, current[x]);
+    }
+
+    if (max_edit_distance && best_this_row > max_edit_distance)
+      return max_edit_distance + 1;
+
+    current.swap(previous);
+  }
+
+  return previous[n];
+}

code/train/C++/0024658_MaxPID.cpp

@@ -0,0 +1,61 @@
+/*
+  Copyright (C) 2012,2013
+      Max Planck Institute for Polymer Research
+  Copyright (C) 2008,2009,2010,2011
+      Max-Planck-Institute for Polymer Research & Fraunhofer SCAI
+  
+  This file is part of ESPResSo++.
+  
+  ESPResSo++ is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+  
+  ESPResSo++ is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+  
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>. 
+*/
+
+#include "python.hpp"
+#include "MaxPID.hpp"
+#include "storage/DomainDecomposition.hpp"
+#include "iterator/CellListIterator.hpp"
+
+using namespace espressopp;
+using namespace iterator;
+
+namespace espressopp {
+  namespace analysis {
+    real MaxPID::compute() const {
+
+      long myMaxPID, systemMaxPID;
+      System& system = getSystemRef();
+      CellList realCells = system.storage->getRealCells();
+
+      myMaxPID = 0;
+      for (CellListIterator cit(realCells); !cit.isDone(); ++cit) {
+        long pid = cit->id();
+        if (pid > myMaxPID) {
+          myMaxPID = pid;
+        }
+      }
+
+      // it was reduce
+      boost::mpi::all_reduce(*getSystem()->comm, myMaxPID, systemMaxPID, mpi::maximum<long>());
+
+      return 1.0*systemMaxPID;
+
+    }
+
+    void MaxPID::registerPython() {
+      using namespace espressopp::python;
+      class_<MaxPID, bases< Observable > >
+        ("analysis_MaxPID", init< shared_ptr< System > >())
+      ;
+    }
+  }
+}

code/train/C++/0024892_ft_send.cpp

@@ -0,0 +1,259 @@
+/*
+ *  Copyright (c) 2004-2016 by Jakob Schröter <js@camaya.net>
+ *  This file is part of the gloox library. http://camaya.net/gloox
+ *
+ *  This software is distributed under a license. The full license
+ *  agreement can be found in the file LICENSE in this distribution.
+ *  This software may not be copied, modified, sold or distributed
+ *  other than expressed in the named license agreement.
+ *
+ *  This software is distributed without any warranty.
+ */
+
+#include "../client.h"
+#include "../connectionlistener.h"
+#include "../stanza.h"
+#include "../gloox.h"
+#include "../disco.h"
+#include "../loghandler.h"
+#include "../logsink.h"
+#include "../siprofileft.h"
+#include "../siprofilefthandler.h"
+#include "../bytestreamdatahandler.h"
+#include "../socks5bytestreamserver.h"
+using namespace gloox;
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string>
+#include <fstream>
+#include <ios>
+
+#include <cstdio> // [s]print[f]
+
+#if defined( WIN32 ) || defined( _WIN32 )
+# include <windows.h>
+#endif
+
+/**
+ * Usage:
+ *   ft_send jid@server/full /path/to/file
+ *
+ * Sends the given file to the given full JID.
+ */
+class FTTest : public LogHandler, ConnectionListener, SIProfileFTHandler, BytestreamDataHandler
+{
+  public:
+    FTTest( const JID& to, const std::string& file ) : m_bs( 0 ), m_to( to ), m_file( file ), m_quit( false ) {}
+
+    virtual ~FTTest() {}
+
+    void start()
+    {
+
+      struct stat f_stat;
+      if( stat( m_file.c_str(), &f_stat ) )
+        return;
+
+      m_size = f_stat.st_size;
+      std::ifstream ifile( m_file.c_str(), std::ios_base::in | std::ios_base::binary );
+      if( !ifile )
+        return;
+
+      JID jid( "hurkhurk@example.net/glooxsendfile" );
+      j = new Client( jid, "hurkhurks" );
+      j->registerConnectionListener( this );
+      j->disco()->setVersion( "ftsend", GLOOX_VERSION, "Linux" );
+      j->disco()->setIdentity( "client", "bot" );
+      StringList ca;
+      ca.push_back( "/path/to/cacert.crt" );
+      j->setCACerts( ca );
+
+      j->logInstance().registerLogHandler( LogLevelDebug, LogAreaAll, this );
+
+
+      m_server = new SOCKS5BytestreamServer( j->logInstance(), 6666 );
+      printf( "about to listen\n" );
+      ConnectionError le = ConnNoError;
+      if( ( le = m_server->listen() ) != ConnNoError )
+        printf( "listen returned: %d\n", le );
+      printf( "listening\n" );
+
+      f = new SIProfileFT( j, this );
+      f->registerSOCKS5BytestreamServer( m_server );
+      f->addStreamHost( j->jid(), "192.168.100.20", 6666 );
+      // you should obtain this using disco, really:
+//       f->addStreamHost( JID( "reflector.amessage.eu" ), "reflector.amessage.eu", 6565 );
+//       f->addStreamHost( JID( "proxy.jabber.org" ), "208.245.212.98", 7777 );
+
+      if( j->connect( false ) )
+      {
+        char input[200024];
+        ConnectionError ce = ConnNoError;
+        ConnectionError se = ConnNoError;
+        while( ce == ConnNoError )
+        {
+          if( m_quit )
+            j->disconnect();
+
+          ce = j->recv( 1 );
+          if( m_server )
+          {
+            se = m_server->recv( 1 );
+            if( se != ConnNoError )
+            {
+              printf( "SOCKS5BytestreamServer returned: %d\n", se );
+              delete m_server;
+              m_server = 0;
+              m_quit = true;
+            }
+          }
+          if( m_bs && !ifile.eof() )
+          {
+            if( m_bs->isOpen() )
+            {
+              ifile.read( input, 200024 );
+              std::string t( input, ifile.gcount() );
+              if( !m_bs->send( t ) )
+                m_quit = true;
+            }
+            m_bs->recv( 1 );
+          }
+          else if( m_bs )
+            m_bs->close();
+        }
+        printf( "ce: %d\n", ce );
+      }
+
+      f->dispose( m_bs );
+      delete f;
+      delete m_server;
+      delete j;
+    }
+
+    virtual void onConnect()
+    {
+      printf( "connected!!!\n" );
+      f->requestFT( m_to, m_file, m_size );
+    }
+
+    virtual void onDisconnect( ConnectionError e )
+    {
+      printf( "ft_send: disconnected: %d\n", e );
+      if( e == ConnAuthenticationFailed )
+        printf( "auth failed. reason: %d\n", j->authError() );
+    }
+
+    virtual bool onTLSConnect( const CertInfo& info )
+    {
+      time_t from( info.date_from );
+      time_t to( info.date_to );
+
+      printf( "status: %d\nissuer: %s\npeer: %s\nprotocol: %s\nmac: %s\ncipher: %s\ncompression: %s\n"
+              "from: %s\nto: %s\n",
+              info.status, info.issuer.c_str(), info.server.c_str(),
+              info.protocol.c_str(), info.mac.c_str(), info.cipher.c_str(),
+              info.compression.c_str(), ctime( &from ), ctime( &to ) );
+      return true;
+    }
+
+    virtual void handleLog( LogLevel level, LogArea area, const std::string& message )
+    {
+      printf("log: level: %d, area: %d, %s\n", level, area, message.c_str() );
+    }
+
+    virtual void handleFTRequest( const JID& from, const JID& /*to*/, const std::string& sid,
+                                  const std::string& name, long size, const std::string& hash,
+                                  const std::string& date, const std::string& mimetype,
+                                  const std::string& desc, int /*stypes*/ )
+    {
+      printf( "received ft request from %s: %s (%ld bytes, sid: %s). hash: %s, date: %s, mime-type: %s\n"
+              "desc: %s\n",
+              from.full().c_str(), name.c_str(), size, sid.c_str(), hash.c_str(), date.c_str(),
+              mimetype.c_str(), desc.c_str() );
+      f->acceptFT( from, sid, SIProfileFT::FTTypeS5B );
+    }
+
+//     virtual void handleFTRequestResult( const JID& /*from*/, const std::string& /*sid*/ )
+//     {
+//     }
+
+    virtual void handleFTRequestError( const IQ& /*iq*/, const std::string& /*sid*/ )
+    {
+      printf( "ft request error\n" );
+      m_quit = true;
+    }
+
+    virtual void handleFTBytestream( Bytestream* bs )
+    {
+      printf( "received bytestream of type: %s", bs->type() == Bytestream::S5B ? "s5b" : "ibb" );
+      m_bs = bs;
+      m_bs->registerBytestreamDataHandler( this );
+      if( m_bs->connect() )
+      {
+        if( bs->type() == Bytestream::S5B )
+          printf( "ok! s5b connected to streamhost\n" );
+        else
+          printf( "ok! ibb sent request to remote entity\n" );
+      }
+    }
+
+    virtual const std::string handleOOBRequestResult( const JID& /*from*/, const JID& /*to*/, const std::string& /*sid*/ )
+    {
+      return std::string();
+    };
+
+    virtual void handleBytestreamData( Bytestream* /*bs*/, const std::string& data )
+    {
+      printf( "received %d bytes of data:\n%s\n", data.length(), data.c_str() );
+    }
+
+    virtual void handleBytestreamError( Bytestream* /*bs*/, const IQ& /*iq*/ )
+    {
+      printf( "bytestream error\n" );
+    }
+
+    virtual void handleBytestreamOpen( Bytestream* /*bs*/ )
+    {
+      printf( "bytestream opened\n" );
+    }
+
+    virtual void handleBytestreamClose( Bytestream* /*bs*/ )
+    {
+      printf( "bytestream closed\n" );
+      m_quit = true;
+    }
+
+  private:
+    Client *j;
+    SIProfileFT* f;
+    Bytestream* m_bs;
+    SOCKS5BytestreamServer* m_server;
+    JID m_to;
+    std::string m_file;
+    bool m_quit;
+    int m_size;
+};
+
+int main( int argc, char** argv )
+{
+  if( argc == 3 )
+  {
+    JID j( argv[1] );
+    if( j.resource().empty() )
+    {
+      printf( "error: need full jid\n" );
+      return 1;
+    }
+    FTTest *r = new FTTest( j, argv[2] );
+    r->start();
+    delete( r );
+  }
+  else
+  {
+    printf( "error: need jid + file\n" );
+  }
+  return 0;
+}

code/train/C++/0025348_sweeperdaemon.cpp

@@ -0,0 +1,274 @@
+/*
+ *  STaRS, Scalable Task Routing approach to distributed Scheduling
+ *  Copyright (C) 2012 Javier Celaya
+ *
+ *  This file is part of STaRS.
+ *
+ *  STaRS is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  STaRS is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with STaRS; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <csignal>
+#include <sstream>
+#include <iostream>
+#include <fstream>
+#include <list>
+#include <map>
+#include <string>
+#include <boost/thread.hpp>
+#include <boost/thread/condition.hpp>
+#include <boost/bind.hpp>
+#include <boost/filesystem.hpp>
+using namespace std;
+using namespace boost;
+namespace fs = boost::filesystem;
+
+
+unsigned long int getAvailableMemory() {
+    unsigned long int free;
+    unsigned long int total;
+    string dummy;
+    ifstream file("/proc/meminfo");
+    file >> dummy >> total;
+    file.ignore(1000, '\n');
+    file >> dummy >> free;
+    return (free - total / 10) >> 10;   // Approx 90% of total memory
+}
+
+
+class Simulations {
+public:
+    static Simulations & getInstance() {
+        static Simulations s;
+        return s;
+    }
+
+    void parseCmdLine(int argc, char * argv[]);
+    int run(int argc, char * argv[]);
+    void stop();
+    void getNewCases();
+    void waitProcesses();
+
+    pid_t spawnProcess(const map<string, string> & properties);
+    unsigned long int getMemoryLimit(const map<string, string> & properties) const {
+        unsigned long int mem = 0;
+        auto it = properties.find("max_mem");
+        if (it != properties.end())
+            istringstream(it->second) >> mem;
+        return mem;
+    }
+    void reschedule();
+
+private:
+    list<map<string, string> > caseInstances;
+    bool end, waitOnPipe;
+    unsigned int numProcesses;
+    unsigned long int availableMemory;
+    list<pair<pid_t, unsigned long int> > processes;
+    string simExec, pipeName;
+    thread pipeThread, waitThread;
+    mutex m;            ///< Mutex to put and get queue messages.
+    condition newCasesOrProcesses;     ///< Barrier to wait for a message
+    condition children;     ///< Barrier to wait for children
+
+    Simulations() : end(false), waitOnPipe(false), numProcesses(1), availableMemory(getAvailableMemory()), pipeName("sweeperpipe") {}
+};
+
+
+void getPropertiesList(const string & fileName, std::list<std::map<std::string, std::string> > & combinations);
+
+
+void finish(int param) {
+    Simulations::getInstance().stop();
+}
+
+
+int main(int argc, char * argv[]) {
+    return Simulations::getInstance().run(argc, argv);
+}
+
+
+void Simulations::parseCmdLine(int argc, char * argv[]) {
+    for (int i = 1; i < argc; i++) {
+        if (argv[i] == string("-f") && ++i < argc)
+            pipeName = argv[i];
+        else if (argv[i] == string("-e") && ++i < argc)
+            simExec = argv[i];
+        else if (argv[i] == string("-p") && ++i < argc)
+            istringstream(argv[i]) >> numProcesses;
+        else if (argv[i] == string("-m") && ++i < argc)
+            istringstream(argv[i]) >> availableMemory;
+    }
+}
+
+
+void Simulations::getNewCases() {
+    while (true) {
+        list<map<string, string> > newInstances;
+        getPropertiesList(pipeName, newInstances);
+        this_thread::interruption_point();
+        if (newInstances.empty()) continue;
+        cout << "Adding " << newInstances.size() << " more cases." << endl;
+        {
+            mutex::scoped_lock lock(m);
+            caseInstances.splice(caseInstances.end(), newInstances);
+        }
+        newCasesOrProcesses.notify_all();
+    }
+}
+
+
+void Simulations::waitProcesses() {
+    while (true) {
+        {
+            mutex::scoped_lock lock(m);
+            if (processes.empty()) {
+                if (end)
+                    return;
+                children.wait(lock);
+                if (end)
+                    return;
+            }
+        }
+        pid_t pid = wait(NULL);
+        if (pid != -1) {
+            cout << "Process " << pid << " ended." << endl;
+            {
+                mutex::scoped_lock lock(m);
+                for (auto it = processes.begin(); it != processes.end(); ++it) {
+                    if (it->first == pid) {
+                        availableMemory += it->second;
+                        processes.erase(it);
+                        break;
+                    }
+                }
+            }
+            newCasesOrProcesses.notify_all();
+        }
+    }
+}
+
+
+int Simulations::run(int argc, char * argv[]) {
+    signal(SIGTERM, finish);
+    signal(SIGINT, finish);
+
+    parseCmdLine(argc, argv);
+    if (simExec == "") {
+        cerr << "Usage: " << argv[0] << " -e sim_program [-f pipe_name] [-p num_processes] [-m max_memory]" << endl;
+        return 1;
+    }
+    cout << "Using " << numProcesses << " processors and " << availableMemory << " megabytes of memory." << endl;
+
+    if (fs::exists(pipeName) && fs::is_regular_file(pipeName)) {
+        cout << "Reading configuration from " << pipeName << endl;
+        getPropertiesList(pipeName, caseInstances);
+        waitOnPipe = false;
+    } else {
+        mknod(pipeName.c_str(), S_IFIFO | 0600, 0);
+        cout << "Listening on " << pipeName << endl;
+        pipeThread = thread(bind(&Simulations::getNewCases, this));
+        waitOnPipe = true;
+    }
+
+    waitThread = thread(bind(&Simulations::waitProcesses, this));
+
+    do {
+        mutex::scoped_lock lock(m);
+        reschedule();
+        if (!waitOnPipe && caseInstances.empty()) {
+            end = true;
+        } else {
+            if (processes.empty() && waitOnPipe) {
+                cout << "Waiting for tests..." << endl;
+            }
+            newCasesOrProcesses.wait(lock);
+        }
+    } while (!end);
+
+    pipeThread.join();
+    waitThread.join();
+    return 0;
+}
+
+
+void Simulations::reschedule() {
+    // Schedule as many cases as possible until memory is full
+    auto instance = caseInstances.begin();
+    while (processes.size() < numProcesses && instance != caseInstances.end()) {
+        // Try to launch this case
+        unsigned long int mem = getMemoryLimit(*instance);
+        if (mem <= availableMemory) {
+            pid_t pid = spawnProcess(*instance);
+            availableMemory -= mem;
+            processes.push_back(make_pair(pid, mem));
+            children.notify_all();
+            instance = caseInstances.erase(instance);
+        }
+        else {
+            if (processes.empty()) {
+                cout << "Unable to run simulation, not enough memory." << endl;
+                instance = caseInstances.erase(instance);
+            } else ++instance;
+        }
+    }
+}
+
+
+pid_t Simulations::spawnProcess(const map<string, string> & properties) {
+    // Redirect stdio
+    int fd[2];
+    pipe(fd);
+    pid_t pid;
+    if ((pid = fork())) {
+        // Close read end
+        close(fd[0]);
+        // Feed configuration through write end
+        ostringstream oss;
+        for (auto & i : properties) {
+            oss << i.first << "=" << i.second << endl;
+        }
+        write(fd[1], oss.str().c_str(), oss.tellp());
+        close(fd[1]);
+        return pid;
+    } else {
+        // Close write end
+        close(fd[1]);
+        // Set read end as standard input
+        dup2(fd[0], 0);
+        execl(simExec.c_str(), simExec.c_str(), "-", NULL);
+        // This function only returns on error
+        cout << "Error running simulation." << endl;
+        close(fd[0]);
+        exit(1);
+    }
+}
+
+
+void Simulations::stop() {
+    end = true;
+    pipeThread.interrupt();
+    //waitThread.interrupt();
+    cout << "Stopping current processes." << endl;
+    for (list<pair<pid_t, unsigned long int> >::iterator it = processes.begin(); it != processes.end(); it++)
+        kill(it->first, SIGTERM);
+    children.notify_all();
+    // Signal end of file in the pipe
+    ofstream(pipeName.c_str(), ios::out | ios::app).close();
+    newCasesOrProcesses.notify_all();
+}

code/train/C++/0025395_part-tld-test.cc

@@ -0,0 +1,64 @@
+#include <iostream>
+#include <fstream>
+
+#include "common/Arguments.hpp"
+#include "core/Sequence.hpp"
+#include "parttld/PartTLD.hpp"
+
+int main(int argc, char** args) {
+    Arguments arguments = Arguments(argc, args);
+
+    string key = arguments.getString("sequence");
+    int limit = arguments.getIntOrDefault("limit", NO_LIMIT);
+
+    printf("Going to run for %s\n", key.c_str());
+    Sequence sequence = Sequence(key, 0, limit);
+    Frame* firstFrame = sequence.next();
+    Box* initBox = sequence.initBox;
+    initBox->isValid = true;
+
+    initBox->x1 -= 1.0;
+    initBox->y1 -= 1.0;
+    initBox->x2 -= 1.0;
+    initBox->y2 -= 1.0;
+
+    PartTLD* tld = new PartTLD();
+
+    Shape* shape0 = tld->init(firstFrame, initBox);
+
+    Frame* previous = firstFrame;
+    while (sequence.hasNext()) {
+        Frame* current = sequence.next();
+        printf("Frame(%d) >> Frame(%d)\n", previous->id, current->id);
+
+        Shape* shape1 = tld->track(previous, current, shape0);
+
+        vector<Box*> currentCorrectedBoxList = shape1->parts;
+        ImageBuilder* builder = new ImageBuilder(current);
+        int nrOfModels = (int) currentCorrectedBoxList.size();
+        for (int i = 0; i < nrOfModels; i++) {
+            Box* box = currentCorrectedBoxList[i];
+
+            if (box != nullptr) {
+                // string boxString = box->toTLDString();
+                builder->withBox(box, Colors::colors[i]);
+            } else {
+                printf("Frame(%d) >> Frame(%d) FAILED\n", previous->id, current->id);
+            }
+        }
+
+        builder->withCircle(shape1->center, 10);
+
+        builder->display(1);
+
+        shape0 = shape1;
+
+        delete previous;
+        previous = current;
+    }
+
+    delete previous;
+    delete tld;
+
+    return EXIT_SUCCESS;
+}

code/train/C++/0025424_possibilities.cc

@@ -0,0 +1,120 @@
+#include "tournament.h"
+#include <iostream>
+#include <iomanip>
+#include <algorithm>
+#include <iterator>
+#include <stdint.h>
+#include "ez/progress.h"
+
+struct PossibleScore {
+  int pickIndex;
+  int score;
+  int champ;
+} _PossibleScore;
+
+bool sortScores(const PossibleScore& first, const PossibleScore& second) {
+  return first.score > second.score;
+}
+
+Tournament::Possibilities::Possibilities(const Tournament::Bracket& b, const Tournament::Scorer& s, int batch, int num_batches) :
+    bracket_(b), scorer_(s), batch_(batch), number_of_batches_(num_batches), shifts_(NULL) {
+  reset();
+}
+
+Tournament::Possibilities::~Possibilities() {
+  delete shifts_;
+}
+
+void Tournament::Possibilities::reset() {
+  if (shifts_) {
+    delete shifts_;
+  }
+  games_left_ = bracket_.totalGames() - bracket_.gamesPlayed();
+  shifts_ = new std::vector<int>(games_left_ + 1);
+  uint64_t left = Tournament::flipBits(bracket_.played());
+  uint64_t offset = 0ULL;
+  uint64_t limit = bracket_.numberOfOutcomes();
+  if (number_of_batches_ > 1) {
+    limit = (uint64_t) ((double) limit / number_of_batches_ + 0.5);
+    offset = limit * batch_;
+  }
+  int shift_count = 0;
+  for (int left_bit = 0; left_bit < bracket_.numberOfTeams(); ++left_bit) {
+    if (left & (1ULL << left_bit)) {
+      shifts_->at(shift_count++) = left_bit;
+    }
+  }
+  start_ = bracket_.numberOfOutcomes() - 1ULL - offset;
+  end_ = batch_ == number_of_batches_ - 1 ?  0ULL : bracket_.numberOfOutcomes() - offset - limit;
+}
+
+std::vector<Tournament::Stats>
+  Tournament::Possibilities::scorePicks(const std::vector<Tournament::Bracket>& picks,
+  bool debug) {
+  uint64_t possibility = start_;
+  uint64_t played = (1ULL << (bracket_.numberOfTeams() - 1)) - 1;
+  uint64_t total = start_ - end_ + 1;
+  if (debug) {
+    std::cout << "Checking " << total << " outcomes of bracket: " << bracket_ << std::endl;
+    std::cout << "Number of entries: " << picks.size() << std::endl;
+    std::cout << "Start: " << start_ << " -> End: " << end_ << std::endl;
+    std::cout << "Total Outcomes: " << bracket_.numberOfOutcomes() << std::endl;
+  }
+
+  ez::Progress progress(total);
+  progress.width = 60;
+
+  std::vector<Stats> allStats(picks.size());
+  std::vector<PossibleScore> pickScores(picks.size());
+  if (debug) {
+    progress.start();
+  }
+  while (possibility != end_) {
+    uint64_t real_poss = 0;
+    for(int i = 0; i < games_left_; ++i) {
+      real_poss |= (((possibility & (1ULL << i)) ? 1ULL : 0ULL) << shifts_->at(i));
+    }
+    real_poss = bracket_.results() | real_poss;
+    Tournament::Bracket possible_bracket(bracket_.numberOfTeams(), real_poss, played);
+    for(int p = 0; p < picks.size(); p++) {
+      Tournament::Scorer::Score score = scorer_.score(possible_bracket, picks[p]);
+      pickScores[p].pickIndex = p;
+      pickScores[p].score = score.score;
+      pickScores[p].champ = possible_bracket.winner();
+      //std::cout <<  "POSS: " << possibility << ": " << picks[p] << " <-> " << possible_bracket << ": score=" << score.score << " max=" << score.max << std::endl;
+    }
+    std::sort(pickScores.begin(), pickScores.end(), sortScores);
+    int currentScore = pickScores[0].score;
+    int actualRank = 1;
+    for(int i = 0; i < picks.size(); ++i) {
+      PossibleScore& score = pickScores[i];
+      Tournament::Stats& stats = allStats[score.pickIndex];
+      if (score.score < currentScore) {
+        actualRank++;
+        currentScore = score.score;
+      }
+      if (score.score > stats.maxScore) {
+        stats.maxScore = score.score;
+      }
+      if (actualRank < stats.maxRank) {
+        stats.maxRank = actualRank;
+      }
+      if (actualRank > stats.minRank) {
+        stats.minRank = actualRank;
+      }
+      if (actualRank == 1) {
+        stats.champCounts[score.champ]++;
+      }
+    }
+
+    if (possibility == end_) {
+      break;
+    }
+    if (debug) {
+      ++progress;
+    }
+    possibility--;
+  }
+  if (debug) { std::cout << std::endl << "Done." << std::endl; }
+  return allStats;
+}

code/train/C++/0025962_Otsu.cc

@@ -0,0 +1,78 @@
+/* -*-c++-*-
+
+ This file is part of the IC reverse engineering tool degate.
+
+ Copyright 2013 by Taekgwan Kim 
+
+ Degate is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ any later version.
+
+ Degate is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with degate. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include <Otsu.h>
+
+using namespace degate;
+
+Otsu::Otsu() : 
+  otsu_threshold(0) {}
+
+Otsu::~Otsu() {}
+
+double Otsu::get_otsu_threshold() {
+  return otsu_threshold;
+}
+
+void Otsu::run(TileImage_GS_DOUBLE_shptr gray) {
+  unsigned long histData[256] = {0,};
+
+  for(unsigned int y = 0; y < gray->get_height(); y++)
+    for(unsigned int x = 0; x < gray->get_width(); x++) {
+      gs_byte_pixel_t h = gray->get_pixel_as<gs_byte_pixel_t>(x, y);
+      assert((h >= 0) && (h < 256));
+      histData[h]++;
+    }
+
+  unsigned long total = gray->get_height() * gray->get_width();
+
+  double sum = 0;
+  for(int t=0; t < 256; t++)
+    sum += t * histData[t];
+
+  double sumB = 0;
+  unsigned long wB = 0;
+  unsigned long wF = 0;
+
+  double varMax = 0;
+
+  for(int t=0; t<256; t++)
+  {
+    wB += histData[t];
+    if(wB == 0)
+      continue;
+
+    wF = total - wB;
+    if(wF == 0)
+      break;
+    sumB += (double)(t * histData[t]);
+
+    double mB = sumB / wB;
+    double mF = (sum - sumB) /wF;
+    double varBetween = (double)wB * (double)wF * (mB-mF) * (mB-mF);
+
+    if(varBetween > varMax)
+    {
+      varMax = varBetween;
+      otsu_threshold = t;
+    }
+  }
+}

code/train/C++/0025967_16.cpp

@@ -0,0 +1,71 @@
+#include "stdafx.h"
+#include <vector>
+#include <map>
+#include <unordered_set>
+#include <string>
+#include <iostream>
+#include <assert.h>
+#include <algorithm>
+using namespace std;
+
+
+// https://leetcode.com/problems/3sum-closest/
+class Solution {
+public:
+
+  int threeSumClosest(vector<int>& nums, int target) {
+    int result = -1;
+    int minDiffSoFar = INT32_MAX;
+
+    if (nums.size() < 3) {
+      return result;
+    }
+    else if (nums.size() == 3) {
+      return (nums[0] + nums[1] + nums[2]);
+    }
+
+    std::sort(nums.begin(), nums.end());
+
+    int n = nums.size();
+    for (int i = 0; i < n - 2; i++) {
+      int a = nums[i];
+      int start = i + 1;
+      int end = n - 1;
+      while (start < end) {
+        assert(i != start);
+        assert(i != end);
+        assert(start != end);
+        int b = nums[start];
+        int c = nums[end];
+        int sum = a + b + c;
+        int diff = sum - target;
+        int absDiff = abs(diff);
+        if (absDiff < minDiffSoFar) {
+          minDiffSoFar = absDiff;
+          result = sum;
+        }
+
+        if (diff > 0) {
+          end--;
+        }
+        else if(diff < 0) {
+          start++;
+        }
+
+        if (diff == 0) {
+          return target;
+        }
+      }
+    }
+    return result;
+  }
+};
+
+int _16(int argc, _TCHAR* argv[])
+{
+  Solution s;
+  vector<int> input = { 1,1,1,1 };
+
+  printf("%d\n", s.threeSumClosest(input, 0));
+  return 0;
+}

code/train/C++/0026485_tst_qscopedvaluerollback.cpp

@@ -0,0 +1,203 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QtTest>
+#include <QtCore/QScopedValueRollback>
+
+/*!
+ \class tst_QScopedValueRollback
+ \internal
+ \since 4.8
+ \brief Tests class QScopedValueRollback.
+
+ */
+class tst_QScopedValueRollback : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void leavingScope();
+    void leavingScopeAfterCommit();
+    void rollbackToPreviousCommit();
+    void exceptions();
+    void earlyExitScope();
+private:
+    void earlyExitScope_helper(int exitpoint, int &member);
+};
+
+void tst_QScopedValueRollback::leavingScope()
+{
+    int i = 0;
+    bool b = false;
+    QString s("This is useful");
+
+    //test rollback on going out of scope
+    {
+        QScopedValueRollback<int> ri(i);
+        QScopedValueRollback<bool> rb(b);
+        QScopedValueRollback<QString> rs(s);
+        QCOMPARE(b, false);
+        QCOMPARE(i, 0);
+        QCOMPARE(s, QString("This is useful"));
+        b = true;
+        i = 1;
+        s = "Useless";
+        QCOMPARE(b, true);
+        QCOMPARE(i, 1);
+        QCOMPARE(s, QString("Useless"));
+    }
+    QCOMPARE(b, false);
+    QCOMPARE(i, 0);
+    QCOMPARE(s, QString("This is useful"));
+}
+
+void tst_QScopedValueRollback::leavingScopeAfterCommit()
+{
+    int i = 0;
+    bool b = false;
+    QString s("This is useful");
+
+    //test rollback on going out of scope
+    {
+        QScopedValueRollback<int> ri(i);
+        QScopedValueRollback<bool> rb(b);
+        QScopedValueRollback<QString> rs(s);
+        QCOMPARE(b, false);
+        QCOMPARE(i, 0);
+        QCOMPARE(s, QString("This is useful"));
+        b = true;
+        i = 1;
+        s = "Useless";
+        QCOMPARE(b, true);
+        QCOMPARE(i, 1);
+        QCOMPARE(s, QString("Useless"));
+        ri.commit();
+        rb.commit();
+        rs.commit();
+    }
+    QCOMPARE(b, true);
+    QCOMPARE(i, 1);
+    QCOMPARE(s, QString("Useless"));
+}
+
+void tst_QScopedValueRollback::rollbackToPreviousCommit()
+{
+    int i=0;
+    {
+        QScopedValueRollback<int> ri(i);
+        i++;
+        ri.commit();
+        i++;
+    }
+    QCOMPARE(i,1);
+    {
+        QScopedValueRollback<int> ri1(i);
+        i++;
+        ri1.commit();
+        i++;
+        ri1.commit();
+        i++;
+    }
+    QCOMPARE(i,3);
+}
+
+void tst_QScopedValueRollback::exceptions()
+{
+    bool b = false;
+    bool caught = false;
+    QT_TRY
+    {
+        QScopedValueRollback<bool> rb(b);
+        b = true;
+        QT_THROW(std::bad_alloc()); //if Qt compiled without exceptions this is noop
+        rb.commit(); //if Qt compiled without exceptions, true is committed
+    }
+    QT_CATCH(...)
+    {
+        caught = true;
+    }
+    QCOMPARE(b, !caught); //expect false if exception was thrown, true otherwise
+}
+
+void tst_QScopedValueRollback::earlyExitScope()
+{
+    int i=0;
+    int j=0;
+    while (true) {
+        QScopedValueRollback<int> ri(i);
+        i++;
+        j=i;
+        if (i>8) break;
+        ri.commit();
+    }
+    QCOMPARE(i,8);
+    QCOMPARE(j,9);
+
+    for (i = 0; i < 5; i++) {
+        j=1;
+        earlyExitScope_helper(i,j);
+        QCOMPARE(j, 1<<i);
+    }
+}
+
+void tst_QScopedValueRollback::earlyExitScope_helper(int exitpoint, int& member)
+{
+    QScopedValueRollback<int> r(member);
+    member *= 2;
+    if (exitpoint == 0)
+        return;
+    r.commit();
+    member *= 2;
+    if (exitpoint == 1)
+        return;
+    r.commit();
+    member *= 2;
+    if (exitpoint == 2)
+        return;
+    r.commit();
+    member *= 2;
+    if (exitpoint == 3)
+        return;
+    r.commit();
+}
+
+QTEST_MAIN(tst_QScopedValueRollback)
+#include "tst_qscopedvaluerollback.moc"

code/train/C++/0026931_FEEPROM.cpp

@@ -0,0 +1,42 @@
+//all the functions are defined in the header file .cpp file have the constructor the wrapped up class is in the header file
+ 
+#include "FEEPROM.h"   // access to the definitions of the hmorse header file
+
+FEEPROM::FEEPROM(word sA, word eA)  //constructor when a object of this type is created this constructor is called 
+{
+  startAdd = sA;
+  endAdd = eA;
+}
+
+void FEEPROM::clearAllFEEPROM(void) //this function clears all the values in the eeprom block
+{
+  for(word i=0; i<=endAdd; i+=4)   
+     {
+     EEPROM.put(i,0);  
+     } 
+}
+
+void FEEPROM::writeCircularFEEPROM(float f)  //this function will write values in a circular buffer way
+{
+  static word add = startAdd;
+  EEPROM.put(add,f);
+  add+=4;
+  if(add>endAdd)
+     add=startAdd;   
+}
+
+float FEEPROM::readMaxFEEPROM(void)          //returns max value of a block
+{
+ static float maxValue=0.0;
+ EEPROM.get(startAdd,maxValue);
+ for(word i=startAdd; i<=endAdd; i+=4)
+	{
+	  float tmp;
+	  EEPROM.get(i,tmp);
+	  maxValue=max(tmp,maxValue);
+	}
+ return maxValue;  
+}
+
+
+ 

code/train/C++/0027205_main.cpp

@@ -0,0 +1,105 @@
+// https://github.com/KubaO/stackoverflown/tree/master/questions/process-fix-binary-crlf-51519654
+#include <QtCore>
+#include <algorithm>
+
+bool appendBinFix(QByteArray &buf, const char *src, int size) {
+   bool okData = true;
+   if (!size) return okData;
+   constexpr char CR = '\x0d';
+   constexpr char LF = '\x0a';
+   bool hasCR = buf.endsWith(CR);
+   buf.resize(buf.size() + size);
+   char *dst = buf.end() - size;
+   const char *lastSrc = src;
+   for (const char *const end = src + size; src != end; src++) {
+      char const c = *src;
+      if (c == LF) {
+         if (hasCR) {
+            std::copy(lastSrc, src, dst);
+            dst += (src - lastSrc);
+            dst[-1] = LF;
+            lastSrc = src + 1;
+         } else
+            okData = false;
+      }
+      hasCR = (c == CR);
+   }
+   dst = std::copy(lastSrc, src, dst);
+   buf.resize(dst - buf.constData());
+   return okData;
+}
+
+bool appendBinFix(QByteArray &buf, const QByteArray &src) {
+   return appendBinFix(buf, src.data(), src.size());
+}
+
+#include <QtTest>
+#include <cstdio>
+#ifdef Q_OS_WIN
+#include <fcntl.h>
+#include <io.h>
+#endif
+
+const auto dataFixed = QByteArrayLiteral("\x00\x11\x0d\x0a\x33");
+const auto data = QByteArrayLiteral("\x00\x11\x0d\x0d\x0a\x33");
+
+int writeOutput() {
+#ifdef Q_OS_WIN
+   _setmode(_fileno(stdout), _O_BINARY);
+#endif
+   auto size = fwrite(data.data(), 1, data.size(), stdout);
+   qDebug() << size << data.size();
+   return (size == data.size()) ? 0 : 1;
+}
+
+class AppendTest : public QObject {
+   Q_OBJECT
+   struct Result {
+      QByteArray d;
+      bool ok;
+      bool operator==(const Result &o) const { return ok == o.ok && d == o.d; }
+   };
+   static Result getFixed(const QByteArray &src, int split) {
+      Result f;
+      f.ok = appendBinFix(f.d, src.data(), split);
+      f.ok = appendBinFix(f.d, src.data() + split, src.size() - split) && f.ok;
+      return f;
+   }
+   Q_SLOT void worksWithLFCR() {
+      const auto lf_cr = QByteArrayLiteral("\x00\x11\x0a\x0d\x33");
+      for (int i = 0; i < lf_cr.size(); ++i)
+         QCOMPARE(getFixed(lf_cr, i), (Result{lf_cr, false}));
+   }
+   Q_SLOT void worksWithCRLF() {
+      const auto cr_lf = QByteArrayLiteral("\x00\x11\x0d\x0a\x33");
+      const auto cr_lf_fixed = QByteArrayLiteral("\x00\x11\x0a\x33");
+      for (int i = 0; i < cr_lf.size(); ++i)
+         QCOMPARE(getFixed(cr_lf, i), (Result{cr_lf_fixed, true}));
+   }
+   Q_SLOT void worksWithCRCRLF() {
+      for (int i = 0; i < data.size(); ++i) QCOMPARE(getFixed(data, i).d, dataFixed);
+   }
+   Q_SLOT void worksWithQProcess() {
+      QProcess proc;
+      proc.start(QCoreApplication::applicationFilePath(), {"output"},
+                 QIODevice::ReadOnly);
+      proc.waitForFinished(5000);
+      QCOMPARE(proc.exitCode(), 0);
+      QCOMPARE(proc.exitStatus(), QProcess::NormalExit);
+
+      QByteArray out = proc.readAllStandardOutput();
+      QByteArray fixed;
+      appendBinFix(fixed, out);
+      QCOMPARE(out, data);
+      QCOMPARE(fixed, dataFixed);
+   }
+};
+
+int main(int argc, char *argv[]) {
+   QCoreApplication app(argc, argv);
+   if (app.arguments().size() > 1) return writeOutput();
+   AppendTest test;
+   QTEST_SET_MAIN_SOURCE_PATH
+   return QTest::qExec(&test, argc, argv);
+}
+#include "main.moc"

code/train/C++/0027411_Defines.cpp

@@ -0,0 +1,300 @@
+#include "Common/Defines.h"
+#include "Crypto/Commit.h"
+#include "Common/BitVector.h"
+//#include "Common/Timer.h"
+#include <boost/math/special_functions/binomial.hpp>
+#include <boost/multiprecision/cpp_bin_float.hpp>
+
+namespace bOPRF {
+
+	Timer gTimer;
+	const block ZeroBlock = _mm_set_epi64x(0, 0);
+	const block OneBlock = _mm_set_epi64x(0, 1);
+	const block AllOneBlock = _mm_set_epi64x(u64(-1), u64(-1));
+	const block CCBlock = ([]() {block cc; memset(&cc, 0xcc, sizeof(block)); return cc; })();
+
+	std::ostream& operator<<(std::ostream& out, const block& blk)
+	{
+		out << std::hex;
+		u64* data = (u64*)&blk;
+
+		out << std::setw(16) << std::setfill('0') << data[0]
+			<< std::setw(16) << std::setfill('0') << data[1];
+
+		out << std::dec << std::setw(0);
+
+		return out;
+	}
+
+	std::ostream& operator<<(std::ostream& out, const blockBop& blk)
+	{
+		out << std::hex;
+		u64* data = (u64*)&blk;
+
+		out << std::setw(16) << std::setfill('0') << data[0] << "..."
+			//<< std::setw(16) << std::setfill('0') << data[1]
+			//<< std::setw(16) << std::setfill('0') << data[2]
+			//<< std::setw(16) << std::setfill('0') << data[3]
+			//<< std::setw(16) << std::setfill('0') << data[4]
+			//<< std::setw(16) << std::setfill('0') << data[5]
+			<< std::setw(16) << std::setfill('0') << data[6];
+
+		out << std::dec << std::setw(0);
+
+		return out;
+	}
+
+
+	std::ostream* gOut = &std::cout;
+
+
+
+	std::ostream& operator<<(std::ostream& out, const Commit& comm)
+	{
+		out << std::hex;
+
+		u32* data = (u32*)comm.data();
+
+		out << std::setw(8) << std::setfill('0') << data[0]
+			<< std::setw(8) << std::setfill('0') << data[1]
+			<< std::setw(8) << std::setfill('0') << data[2]
+			<< std::setw(8) << std::setfill('0') << data[3]
+			<< std::setw(8) << std::setfill('0') << data[4];
+
+		out << std::dec << std::setw(0);
+
+		return out;
+	}
+	block PRF(const block& b, u64 i)
+	{
+		//TODO("REMOVE THIS!!");
+		//return b;
+
+
+
+
+
+		block ret, tweak = _mm_set1_epi64x(i), enc;
+
+		ret = b ^ tweak;
+
+		mAesFixedKey.ecbEncBlock(ret, enc);
+
+		ret = ret ^ enc; // H( a0 ) 
+
+		return ret;
+	}
+
+	void split(const std::string &s, char delim, std::vector<std::string> &elems) {
+		std::stringstream ss(s);
+		std::string item;
+		while (std::getline(ss, item, delim)) {
+			elems.push_back(item);
+		}
+	}
+
+	std::vector<std::string> split(const std::string &s, char delim) {
+		std::vector<std::string> elems;
+		split(s, delim, elems);
+		return elems;
+	}
+
+	const int tab64[64] = {
+		63,  0, 58,  1, 59, 47, 53,  2,
+		60, 39, 48, 27, 54, 33, 42,  3,
+		61, 51, 37, 40, 49, 18, 28, 20,
+		55, 30, 34, 11, 43, 14, 22,  4,
+		62, 57, 46, 52, 38, 26, 32, 41,
+		50, 36, 17, 19, 29, 10, 13, 21,
+		56, 45, 25, 31, 35, 16,  9, 12,
+		44, 24, 15,  8, 23,  7,  6,  5 };
+
+
+	u64 log2floor(u64 value)
+	{
+		value |= value >> 1;
+		value |= value >> 2;
+		value |= value >> 4;
+		value |= value >> 8;
+		value |= value >> 16;
+		value |= value >> 32;
+		return tab64[((uint64_t)((value - (value >> 1)) * 0x07EDD5E59A4E28C2)) >> 58];
+	}
+
+	u64 log2ceil(u64 value)
+	{
+		return u64(std::ceil(std::log2(value)));
+	}
+
+	u64 get_stash_size(u64 neles) {
+		if (neles >= (1 << 24))
+			return 2;
+		if (neles >= (1 << 20))
+			return 3;
+		if (neles >= (1 << 16))
+			return 4;
+		if (neles >= (1 << 12))
+			return 6;
+		if (neles >= (1 << 8))
+			return 12;
+
+		return 12; //other
+
+		throw std::runtime_error("get_stash_size: rt error at " LOCATION);
+
+	}
+
+	//template<unsigned int N = 16>
+	double getBinOverflowProb(u64 numBins, u64 numBalls, u64 binSize, double epsilon = 0.0001)
+	{
+		if (numBalls <= binSize)
+			return std::numeric_limits<double>::max();
+
+		if (numBalls > unsigned(-1))
+		{
+			auto msg = ("boost::math::binomial_coefficient(...) only supports " + std::to_string(sizeof(unsigned) * 8) + " bit inputs which was exceeded." LOCATION);
+			std::cout << msg << std::endl;
+			throw std::runtime_error(msg);
+		}
+
+		//try 
+		//{
+
+			//std::cout << numBalls << " " << numBins << " " << binSize << std::endl;
+		typedef boost::multiprecision::number<boost::multiprecision::backends::cpp_bin_float<16>> T;
+		T sum = 0.0;
+		T sec = 0.0;// minSec + 1;
+		T diff = 1;
+		u64 i = binSize + 1;
+
+
+		while (diff > T(epsilon) && numBalls >= i /*&& sec > minSec*/)
+		{
+			sum += numBins * boost::math::binomial_coefficient<T>(numBalls, i)
+				* boost::multiprecision::pow(T(1.0) / numBins, i) * boost::multiprecision::pow(1 - T(1.0) / numBins, numBalls - i);
+
+			//std::cout << "sum[" << i << "] " << sum << std::endl;
+
+			T sec2 = boost::multiprecision::log2(sum);
+			diff = boost::multiprecision::abs(sec - sec2);
+			//std::cout << diff << std::endl;
+			sec = sec2;
+
+			i++;
+		}
+
+		return std::max<double>(0, (double)-sec);
+		//}
+		//catch (std::exception& e)
+		//{
+		//	if (N == 16)
+		//	{
+		//		std::cout << "percision failure at " << LOCATION << "\n tring again with high percision (performance penalty)" << std::endl;
+		//		// try again with higher percition
+		//		return getBinOverflowProb<128>(numBins, numBalls, binSize);
+		//	}
+		//		
+		//	std::cout << "retry percision failure at " << LOCATION << "\n" << e.what() << std::endl;
+		//	throw;
+		//}
+	}
+
+	u64 get_bin_size(u64 numBins, u64 numBalls, u64 statSecParam)
+	{
+
+		auto B = std::max<u64>(1, numBalls / numBins);
+
+		double currentProb = 0;
+		u64 step = 1;
+
+		bool doubling = true;
+
+		while (currentProb < statSecParam || step > 1)
+		{
+			if (!step)
+				throw std::runtime_error(LOCATION);
+
+
+			if (statSecParam > currentProb)
+			{
+				if (doubling) step = std::max<u64>(1, step * 2);
+				else          step = std::max<u64>(1, step / 2);
+
+				B += step;
+			}
+			else
+			{
+				doubling = false;
+				step = std::max<u64>(1, step / 2);
+				B -= step;
+			}
+			currentProb = getBinOverflowProb(numBins, numBalls, B);
+		}
+
+
+
+		return B;
+		//if (simpleSize <= cuckooSize)
+		//{
+
+		//	if (simpleSize >= (1 << 24))
+		//		return 28;
+		//	if (simpleSize >= (1 << 20))
+		//		return 27;
+		//	if (simpleSize >= (1 << 16))
+		//		return 26;
+		//	if (simpleSize >= (1 << 12))
+		//		return 25;
+		//	if (simpleSize >= (1 << 8))
+		//		return 24;
+
+		//	//return 30;  //other
+		//}
+		//else 
+		//{
+		//	return simpleSize / cuckooSize + 16 + 4 * std::sqrt(simpleSize * std::log2(cuckooSize) / cuckooSize);
+		//}
+
+		//throw std::runtime_error("get_bin_size: rt error at " LOCATION);
+	}
+
+	u64 get_codeword_size(u64 neles) {
+		if (neles >= (1 << 24))
+			return 448 / 8; // in byte
+		if (neles >= (1 << 20))
+			return 448 / 8;
+		if (neles >= (1 << 16))
+			return 440 / 8;
+		if (neles >= (1 << 12))
+			return 432 / 8;
+		if (neles >= (1 << 8))
+			return 424 / 8;
+
+		return 424 / 8;
+
+		//throw std::runtime_error("get_codeword_size: rt error at " LOCATION);
+	}
+	u64 get_mask_size(u64 neles, u64 othersize, u64 statSecParam) {
+
+
+		return (statSecParam + log2(neles * othersize) + 7 ) / 8;
+
+		//if (neles >= (1 << 24))
+		//	return 88 / 8;  // in byte
+		//if (neles >= (1 << 20))
+		//	return 80 / 8;
+		//if (neles >= (1 << 16))
+		//	return 72 / 8;
+		//if (neles >= (1 << 12))
+		//	return 64 / 8;
+		//if (neles >= (1 << 8))
+		//	return 56 / 8;
+
+		//return 56 / 8;
+		////return (40 + 2 * log(neles)) / 8;
+
+	//	throw std::runtime_error("get_codeword_size: rt error at " LOCATION);
+	}
+}
+
+

code/train/C++/0027495_uf.cc

@@ -0,0 +1,210 @@
+//
+// libsemigroups - C++ library for semigroups and monoids
+// Copyright (C) 2017 Michael Torpey
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+// This file defines UF, a class used to make an equivalence relation on
+// the integers {1 .. n}, using the UNION-FIND METHOD: new pairs can be added
+// and the appropriate classes combined quickly.
+
+#include "uf.h"
+
+#include "libsemigroups-debug.h"
+
+namespace libsemigroups {
+
+  // Copy constructor
+  UF::UF(const UF& copy)
+      : _size(copy._size),
+        _table(new table_t(*copy._table)),
+        _blocks(nullptr),
+        _haschanged(copy._haschanged) {
+    if (copy._blocks != nullptr) {
+      // Copy the blocks as well
+      _blocks = new blocks_t();
+      _blocks->reserve(copy._blocks->size());
+      for (auto const& block : *copy._blocks) {
+        if (block == nullptr) {
+          _blocks->push_back(nullptr);
+        } else {
+          _blocks->push_back(new table_t(*block));
+        }
+      }
+    }
+  }
+
+  // Constructor by table
+  UF::UF(const table_t& table)
+      : _size(table.size()),
+        _table(new table_t(table)),
+        _blocks(nullptr),
+        _haschanged(true),
+        _next_rep(0) {}
+
+  // Constructor by size
+  UF::UF(size_t size)
+      : _size(size),
+        _table(new table_t()),
+        _blocks(nullptr),
+        _haschanged(false),
+        _next_rep(0) {
+    _table->reserve(size);
+    for (size_t i = 0; i < size; i++) {
+      _table->push_back(i);
+    }
+  }
+
+  // Destructor
+  UF::~UF() {
+    delete _table;
+    if (_blocks != nullptr) {
+      for (size_t i = 0; i < _blocks->size(); i++) {
+        delete _blocks->at(i);
+      }
+      delete _blocks;
+    }
+  }
+
+  // Getters
+  size_t UF::get_size() {
+    return _size;
+  }
+
+  UF::table_t* UF::get_table() {
+    return _table;
+  }
+
+  // get_blocks
+  UF::blocks_t* UF::get_blocks() {
+    table_t* block;
+    // Is _blocks "bound" yet?
+    if (_blocks == nullptr) {
+      _blocks = new blocks_t();
+      _blocks->reserve(_size);
+      for (size_t i = 0; i < _size; i++) {
+        block = new table_t(1, i);
+        _blocks->push_back(block);
+      }
+    }
+    // Do we need to update the blocks?
+    if (_haschanged) {
+      size_t ii;
+      for (size_t i = 0; i < _size; i++) {
+        if (_blocks->at(i) != nullptr) {
+          ii = find(i);
+          if (ii != i) {
+            // Combine the two blocks
+            _blocks->at(ii)->reserve(_blocks->at(ii)->size()
+                                     + _blocks->at(i)->size());
+            _blocks->at(ii)->insert(_blocks->at(ii)->end(),
+                                    _blocks->at(i)->begin(),
+                                    _blocks->at(i)->end());
+            delete _blocks->at(i);
+            _blocks->at(i) = nullptr;
+          }
+        }
+      }
+      _haschanged = false;
+    }
+    return _blocks;
+  }
+
+  // find
+  size_t UF::find(size_t i) {
+    size_t ii;
+    LIBSEMIGROUPS_ASSERT(_size == _table->size());
+    do {
+      ii = i;
+      LIBSEMIGROUPS_ASSERT(ii < _size);
+      i = (*_table)[ii];
+    } while (ii != i);
+    return i;
+  }
+
+  // union
+  void UF::unite(size_t i, size_t j) {
+    size_t ii, jj;
+    LIBSEMIGROUPS_ASSERT(_size == _table->size());
+    ii = find(i);
+    jj = find(j);
+    if (ii < jj) {
+      LIBSEMIGROUPS_ASSERT(jj < _size);
+      (*_table)[jj] = ii;
+    } else {
+      LIBSEMIGROUPS_ASSERT(ii < _size);
+      (*_table)[ii] = jj;
+    }
+    _haschanged = true;
+  }
+
+  // flatten
+  void UF::flatten() {
+    LIBSEMIGROUPS_ASSERT(_size == _table->size());
+    for (size_t i = 0; i < _size; i++) {
+      (*_table)[i] = find(i);
+    }
+  }
+
+  // add_entry
+  void UF::add_entry() {
+    _table->push_back(_size);
+    if (_blocks != nullptr) {
+      _blocks->push_back(new table_t(1, _size));
+    }
+    _size++;
+  }
+
+  // nr_blocks
+  size_t UF::nr_blocks() {
+    LIBSEMIGROUPS_ASSERT(_size == _table->size());
+    if (_size == 0) {
+      return 0;
+    }
+    size_t count = 1;
+    size_t max   = 0;
+    flatten();  // So we can use [i] instead of ->find(i)
+    LIBSEMIGROUPS_ASSERT((*_table)[0] == 0);
+    for (size_t i = 1; i < _size; i++) {
+      if ((*_table)[i] > max) {
+        max = (*_table)[i];
+        count++;
+      }
+    }
+    return count;
+  }
+
+  void UF::reset_next_rep() {
+    flatten();
+    _next_rep = 0;
+  }
+
+  // Returns the next representative of a block, invalidated by anything that
+  // changes the partition
+  size_t UF::next_rep() {
+    size_t current_rep = _next_rep;
+    while (_next_rep < _size && (*_table)[_next_rep] <= current_rep) {
+      _next_rep++;
+    }
+    return current_rep;
+  }
+
+  void UF::join(UF const& uf) {
+    LIBSEMIGROUPS_ASSERT(this->_size == uf._size);
+    for (size_t i = 0; i < _size; i++) {
+      unite((*_table)[i], (*uf._table)[i]);
+    }
+  }
+}  // namespace libsemigroups

code/train/C++/0027730_reverse_geocoder.cpp

@@ -0,0 +1,218 @@
+#include "reverse_geocoder.hpp"
+
+#include "search/mwm_context.hpp"
+
+#include "indexer/feature.hpp"
+#include "indexer/feature_algo.hpp"
+#include "indexer/ftypes_matcher.hpp"
+#include "indexer/index.hpp"
+#include "indexer/scales.hpp"
+#include "indexer/search_string_utils.hpp"
+
+#include "base/stl_helpers.hpp"
+
+#include "std/limits.hpp"
+
+namespace search
+{
+namespace
+{
+size_t constexpr kSimilarityThresholdPercent = 10;
+int constexpr kQueryScale = scales::GetUpperScale();
+/// Max number of tries (nearest houses with housenumber) to check when getting point address.
+size_t constexpr kMaxNumTriesToApproxAddress = 10;
+} // namespace
+
+ReverseGeocoder::ReverseGeocoder(Index const & index) : m_index(index) {}
+
+void ReverseGeocoder::GetNearbyStreets(MwmSet::MwmId const & id, m2::PointD const & center,
+                                       vector<Street> & streets) const
+{
+  m2::RectD const rect = GetLookupRect(center, kLookupRadiusM);
+
+  auto const addStreet = [&](FeatureType & ft)
+  {
+    if (ft.GetFeatureType() != feature::GEOM_LINE ||
+        !ftypes::IsStreetChecker::Instance()(ft))
+    {
+      return;
+    }
+
+    string name;
+    if (!ft.GetName(StringUtf8Multilang::kDefaultCode, name))
+      return;
+
+    ASSERT(!name.empty(), ());
+
+    streets.emplace_back(ft.GetID(), feature::GetMinDistanceMeters(ft, center), name);
+  };
+
+  MwmSet::MwmHandle mwmHandle = m_index.GetMwmHandleById(id);
+  if (mwmHandle.IsAlive())
+  {
+    search::MwmContext(move(mwmHandle)).ForEachFeature(rect, addStreet);
+    sort(streets.begin(), streets.end(), my::LessBy(&Street::m_distanceMeters));
+  }
+}
+
+void ReverseGeocoder::GetNearbyStreets(FeatureType & ft, vector<Street> & streets) const
+{
+  ASSERT(ft.GetID().IsValid(), ());
+  GetNearbyStreets(ft.GetID().m_mwmId, feature::GetCenter(ft), streets);
+}
+
+// static
+size_t ReverseGeocoder::GetMatchedStreetIndex(strings::UniString const & keyName,
+                                              vector<Street> const & streets)
+{
+  // Find the exact match or the best match in kSimilarityTresholdPercent limit.
+  size_t const count = streets.size();
+  size_t result = count;
+  size_t minPercent = kSimilarityThresholdPercent + 1;
+
+  for (size_t i = 0; i < count; ++i)
+  {
+    strings::UniString const actual = GetStreetNameAsKey(streets[i].m_name);
+
+    size_t const editDistance = strings::EditDistance(keyName.begin(), keyName.end(),
+                                                      actual.begin(), actual.end());
+
+    if (editDistance == 0)
+      return i;
+
+    if (actual.empty())
+      continue;
+
+    size_t const percent = editDistance * 100 / actual.size();
+    if (percent < minPercent)
+    {
+      result = i;
+      minPercent = percent;
+    }
+  }
+
+  return result;
+}
+
+pair<vector<ReverseGeocoder::Street>, uint32_t>
+ReverseGeocoder::GetNearbyFeatureStreets(FeatureType & ft) const
+{
+  pair<vector<ReverseGeocoder::Street>, uint32_t> result;
+
+  GetNearbyStreets(ft, result.first);
+
+  HouseTable table(m_index);
+  if (!table.Get(ft.GetID(), result.second))
+    result.second = numeric_limits<uint32_t>::max();
+
+  return result;
+}
+
+void ReverseGeocoder::GetNearbyAddress(m2::PointD const & center, Address & addr) const
+{
+  vector<Building> buildings;
+  GetNearbyBuildings(center, buildings);
+
+  HouseTable table(m_index);
+  size_t triesCount = 0;
+
+  for (auto const & b : buildings)
+  {
+    // It's quite enough to analize nearest kMaxNumTriesToApproxAddress houses for the exact nearby address.
+    // When we can't guarantee suitable address for the point with distant houses.
+    if (GetNearbyAddress(table, b, addr) || (++triesCount == kMaxNumTriesToApproxAddress))
+      break;
+  }
+}
+
+bool ReverseGeocoder::GetExactAddress(FeatureType & ft, Address & addr) const
+{
+  if (ft.GetHouseNumber().empty())
+    return false;
+  HouseTable table(m_index);
+  return GetNearbyAddress(table, FromFeature(ft, 0.0 /* distMeters */), addr);
+}
+
+bool ReverseGeocoder::GetNearbyAddress(HouseTable & table, Building const & bld,
+                                       Address & addr) const
+{
+  string street;
+  if (osm::Editor::Instance().GetEditedFeatureStreet(bld.m_id, street))
+  {
+    addr.m_building = bld;
+    addr.m_street.m_name = street;
+    return true;
+  }
+
+  uint32_t ind;
+  if (!table.Get(bld.m_id, ind))
+    return false;
+
+  vector<Street> streets;
+  GetNearbyStreets(bld.m_id.m_mwmId, bld.m_center, streets);
+  if (ind < streets.size())
+  {
+    addr.m_building = bld;
+    addr.m_street = streets[ind];
+    return true;
+  }
+  else
+  {
+    LOG(LWARNING, ("Out of bound street index", ind, "for", bld.m_id));
+    return false;
+  }
+}
+
+void ReverseGeocoder::GetNearbyBuildings(m2::PointD const & center, vector<Building> & buildings) const
+{
+  m2::RectD const rect = GetLookupRect(center, kLookupRadiusM);
+
+  auto const addBuilding = [&](FeatureType & ft)
+  {
+    if (!ft.GetHouseNumber().empty())
+      buildings.push_back(FromFeature(ft, feature::GetMinDistanceMeters(ft, center)));
+  };
+
+  m_index.ForEachInRect(addBuilding, rect, kQueryScale);
+  sort(buildings.begin(), buildings.end(), my::LessBy(&Building::m_distanceMeters));
+}
+
+// static
+ReverseGeocoder::Building ReverseGeocoder::FromFeature(FeatureType & ft, double distMeters)
+{
+  return { ft.GetID(), distMeters, ft.GetHouseNumber(), feature::GetCenter(ft) };
+}
+
+// static
+m2::RectD ReverseGeocoder::GetLookupRect(m2::PointD const & center, double radiusM)
+{
+  return MercatorBounds::RectByCenterXYAndSizeInMeters(center, radiusM);
+}
+
+bool ReverseGeocoder::HouseTable::Get(FeatureID const & fid, uint32_t & streetIndex)
+{
+  if (!m_table || m_handle.GetId() != fid.m_mwmId)
+  {
+    m_handle = m_index.GetMwmHandleById(fid.m_mwmId);
+    if (!m_handle.IsAlive())
+    {
+      LOG(LWARNING, ("MWM", fid, "is dead"));
+      return false;
+    }
+    m_table = search::HouseToStreetTable::Load(*m_handle.GetValue<MwmValue>());
+  }
+
+  return m_table->Get(fid.m_index, streetIndex);
+}
+
+string DebugPrint(ReverseGeocoder::Object const & obj)
+{
+  return obj.m_name;
+}
+
+string DebugPrint(ReverseGeocoder::Address const & addr)
+{
+  return "{ " + DebugPrint(addr.m_building) + ", " + DebugPrint(addr.m_street) + " }";
+}
+
+} // namespace search

code/train/C++/0027996_gain_change_calculator.cc

@@ -0,0 +1,55 @@
+/*
+ *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "webrtc/modules/audio_mixer/gain_change_calculator.h"
+
+#include <math.h>
+#include <vector>
+
+namespace webrtc {
+
+namespace {
+constexpr int16_t kReliabilityThreshold = 100;
+}  // namespace
+
+float GainChangeCalculator::CalculateGainChange(
+    rtc::ArrayView<const int16_t> in,
+    rtc::ArrayView<const int16_t> out) {
+  RTC_DCHECK_EQ(in.size(), out.size());
+
+  std::vector<float> gain(in.size());
+  CalculateGain(in, out, gain);
+  return CalculateDifferences(gain);
+}
+
+void GainChangeCalculator::CalculateGain(rtc::ArrayView<const int16_t> in,
+                                         rtc::ArrayView<const int16_t> out,
+                                         rtc::ArrayView<float> gain) {
+  RTC_DCHECK_EQ(in.size(), out.size());
+  RTC_DCHECK_EQ(in.size(), gain.size());
+
+  for (size_t i = 0; i < in.size(); ++i) {
+    if (std::abs(in[i]) >= kReliabilityThreshold) {
+      last_reliable_gain_ = out[i] / static_cast<float>(in[i]);
+    }
+    gain[i] = last_reliable_gain_;
+  }
+}
+
+float GainChangeCalculator::CalculateDifferences(
+    rtc::ArrayView<const float> values) {
+  float res = 0;
+  for (float f : values) {
+    res += fabs(f - last_value_);
+    last_value_ = f;
+  }
+  return res;
+}
+}  // namespace webrtc

code/train/C++/0028086_StacksDP.cpp

@@ -0,0 +1,65 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <string>
+using std::string;
+
+#include <iostream>
+using std::cin;
+using std::cout;
+using std::stringstream;
+
+#include <sstream>
+#include "StacksAD.cpp"
+
+using namespace std;
+
+
+class StacksDP
+{
+private:
+    Nodo *FirstNode, *tempNode;
+public:
+    string push(string info){
+        if(FirstNode == NULL){
+            FirstNode = new Nodo(info);
+            FirstNode->setNext(NULL);
+            return "Exitosamente Guardado: "+info;
+        }
+        else{
+            tempNode = FirstNode;
+            FirstNode = new Nodo(info);
+            FirstNode->setNext(tempNode);
+            return "Exitosamente Guardado: " + info;
+        }
+    }
+    string pop(void){
+        
+        if (FirstNode == NULL) {
+            return "EMPTY LIST";
+        }
+        
+        string result = FirstNode->getString();
+        FirstNode = FirstNode->getNext();
+        return result;
+    }
+    string desplegar(void){
+        string result ="";
+        
+        if (FirstNode == NULL) {
+            return "NULL LIST";
+        }
+        
+        Nodo *cursor = FirstNode;
+        while(cursor!=NULL){
+            result += cursor->getString() +"\n";
+            cursor = cursor->getNext();
+        }
+        return result;
+    }
+    void getData(void);
+    void saveData(void);
+
+};
+