diff --git a/code/train/C++/0000525_main.cpp b/code/train/C++/0000525_main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a272f232496d4b992f50f7d70c1c8eec54471da6
--- /dev/null
+++ b/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;
+}
diff --git a/code/train/C++/0000584_main.cpp b/code/train/C++/0000584_main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..053ccb54b5d81e2218e8e9fd2b7bb4aa0b1f2d03
--- /dev/null
+++ b/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();
+}
diff --git a/code/train/C++/0000623_asgn8.cpp b/code/train/C++/0000623_asgn8.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4885054596d91328dc089b8e9d85c61898bebb0
--- /dev/null
+++ b/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]++;
+	            }
+    }
+  }
+
diff --git a/code/train/C++/0000658_DoAHeuristicPreferredAngle.cpp b/code/train/C++/0000658_DoAHeuristicPreferredAngle.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0f43692e26d4d562556505329bb8b880e5294510
--- /dev/null
+++ b/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;
+}
+
+
+
+
+
+
diff --git a/code/train/C++/0000762_statistic.cpp b/code/train/C++/0000762_statistic.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..986b4d60f328f69960bd23f2624fd50c8c7022f5
--- /dev/null
+++ b/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;
+}
\ No newline at end of file
diff --git a/code/train/C++/0000894_7771448.cpp b/code/train/C++/0000894_7771448.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..69a911f22f9ec6f9f11198e1509d8605c0a59c9e
--- /dev/null
+++ b/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;
+}
diff --git a/code/train/C++/0001490_bip32_tests.cpp b/code/train/C++/0001490_bip32_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fbec756806253d581d9a6fd9a5b285f8301a09e3
--- /dev/null
+++ b/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()
diff --git a/code/train/C++/0002138_A.cpp b/code/train/C++/0002138_A.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..223cf76f7565c6c37b4b433f18f7f3c9cca5dd2d
--- /dev/null
+++ b/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;
+}
diff --git a/code/train/C++/0002412_authmessagevalidator.cpp b/code/train/C++/0002412_authmessagevalidator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..87fdef9719dcdf92c552a39030d3e2218fd9c8ef
--- /dev/null
+++ b/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;
+}
+
diff --git a/code/train/C++/0002530_AppMoblet.cpp b/code/train/C++/0002530_AppMoblet.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5e0047fda3fdddd9f463f11c579c4f2039c71dcb
--- /dev/null
+++ b/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;
+}
diff --git a/code/train/C++/0002981_vcardmanager.cpp b/code/train/C++/0002981_vcardmanager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2845e82a263223460937128f6a29378e1728186e
--- /dev/null
+++ b/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 );
+    }
+  }
+
+}
diff --git a/code/train/C++/0003712_PEMer_Lite.cpp b/code/train/C++/0003712_PEMer_Lite.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7782cc5953d2dd03f6d37597369c81bf116c5da0
--- /dev/null
+++ b/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;
+}
+ 
diff --git a/code/train/C++/0003837_poj1852.cc b/code/train/C++/0003837_poj1852.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ab08e984ce0cb6966d622f5d3f4bdda11a14f963
--- /dev/null
+++ b/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;
+}
diff --git a/code/train/C++/0004781_heapSort.cpp b/code/train/C++/0004781_heapSort.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..50c3e6f13ee67903945cb57a4fb39c0effcec78d
--- /dev/null
+++ b/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
+
+
+*/
diff --git a/code/train/C++/0004813_276A.cpp b/code/train/C++/0004813_276A.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a53a23c2da232ebe350c5cb8bf0c5ef7cebe2f13
--- /dev/null
+++ b/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;
+}
diff --git a/code/train/C++/0005979_WorldRunnable.cpp b/code/train/C++/0005979_WorldRunnable.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..321e1aa6bffc901c9c1b48b942ab19cf32f35e7c
--- /dev/null
+++ b/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
+}
diff --git a/code/train/C++/0006023_SpecificPartialLoudnessGM.cpp b/code/train/C++/0006023_SpecificPartialLoudnessGM.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0959efad81dde55debb0c609fb542c6f325b660e
--- /dev/null
+++ b/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(){};
+}
+
+
+
diff --git a/code/train/C++/0006349_XScaleBar.cpp b/code/train/C++/0006349_XScaleBar.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ed57279c657638874d2aad4742f5e0a9f8099e80
--- /dev/null
+++ b/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; 
diff --git a/code/train/C++/0006416_TestStanfordCPPLib.cpp b/code/train/C++/0006416_TestStanfordCPPLib.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..44595a6b0970d494b514427c2975b003ca26b837
--- /dev/null
+++ b/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;
+}
diff --git a/code/train/C++/0006687_instprofile.cpp b/code/train/C++/0006687_instprofile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2b4ec2710cea451716c8e3b55586a10dcd10e3b3
--- /dev/null
+++ b/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;
+    }
+}
+    
diff --git a/code/train/C++/0006795_testscore.ex3.cpp b/code/train/C++/0006795_testscore.ex3.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eaac5934f22c6caf60176012753edfb8bc822bb0
--- /dev/null
+++ b/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;
+}
diff --git a/code/train/C++/0006861_sqldb.cpp b/code/train/C++/0006861_sqldb.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..597a999cf5de7c12114103e3fa953d6633fd6e6b
--- /dev/null
+++ b/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;
+}
+
diff --git a/code/train/C++/0007941_solution.cpp b/code/train/C++/0007941_solution.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e15e733103b68f10acfeb21d9fdbf55a72c102ce
--- /dev/null
+++ b/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;
+    }
+};
\ No newline at end of file
diff --git a/code/train/C++/0008009_FoxAndDoraemon.cpp b/code/train/C++/0008009_FoxAndDoraemon.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5176ae38bdb20599e69c82eba62c4f86676fe33e
--- /dev/null
+++ b/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;
+    }
+};
diff --git a/code/train/C++/0008879_IPCWorkerThread.cpp b/code/train/C++/0008879_IPCWorkerThread.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4660e558531ed8dc69423d71c041dadffb5a32c7
--- /dev/null
+++ b/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)");
+}
+
diff --git a/code/train/C++/0009074_cafToggleItemsOnOthersOffFeature.cpp b/code/train/C++/0009074_cafToggleItemsOnOthersOffFeature.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c44e94f9e4543a082505d2e238f8f4b63b209b43
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/code/train/C++/0009203_PathTransform.cpp b/code/train/C++/0009203_PathTransform.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9f7b18fd8b67e217390ec3ac2fbdc4e6ce1b3024
--- /dev/null
+++ b/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);
+}
diff --git a/code/train/C++/0009912_zonedessin.cpp b/code/train/C++/0009912_zonedessin.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..13777021e045ce6aea95402cf9cb6f03fda85b77
--- /dev/null
+++ b/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();
+}
diff --git a/code/train/C++/0009915_sp-switch.cpp b/code/train/C++/0009915_sp-switch.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d2dcde15d2ec8e0d6afc0f934ec45f8ad80371aa
--- /dev/null
+++ b/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 :
diff --git a/code/train/C++/0010000_track.cpp b/code/train/C++/0010000_track.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..31b945f001d381a32c74f561a49267fd6e089a2d
--- /dev/null
+++ b/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;
+}
diff --git a/code/train/C++/0010267_sgmm-acc-fmllrbasis-ali.cc b/code/train/C++/0010267_sgmm-acc-fmllrbasis-ali.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3c33e47dde2997addc57f8b7ede51a15265db961
--- /dev/null
+++ b/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;
+  }
+}
+
+
diff --git a/code/train/C++/0010531_CCSequence3D.cpp b/code/train/C++/0010531_CCSequence3D.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aecb8efff2e3abcb0dd22d7c602c56e730eeb249
--- /dev/null
+++ b/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
diff --git a/code/train/C++/0010760_laser.cpp b/code/train/C++/0010760_laser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6df0e38d46551a768f7c145ed6f6671e87a43d4f
--- /dev/null
+++ b/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;
+}
diff --git a/code/train/C++/0011798_chapter04_ex16.cpp b/code/train/C++/0011798_chapter04_ex16.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c91d738a951757589057e752ec605e7c4eed84ad
--- /dev/null
+++ b/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;
+}
diff --git a/code/train/C++/0012078_edit_distance.cc b/code/train/C++/0012078_edit_distance.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a6719d36a37b4d6ad489ea2c2f68e3fe2616986b
--- /dev/null
+++ b/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];
+}
diff --git a/code/train/C++/0024658_MaxPID.cpp b/code/train/C++/0024658_MaxPID.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7631ba99540deaa997e65952aebca9d11211e41e
--- /dev/null
+++ b/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 > >())
+      ;
+    }
+  }
+}
diff --git a/code/train/C++/0024892_ft_send.cpp b/code/train/C++/0024892_ft_send.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..679d388eb333f55ae83454ef6399585c26bb72c8
--- /dev/null
+++ b/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;
+}
diff --git a/code/train/C++/0025348_sweeperdaemon.cpp b/code/train/C++/0025348_sweeperdaemon.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1943d94266baf642f662055cfb830c988aaf7000
--- /dev/null
+++ b/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();
+}
diff --git a/code/train/C++/0025395_part-tld-test.cc b/code/train/C++/0025395_part-tld-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9f81e194b4ff62b6bef8256b94814ed01edea0fc
--- /dev/null
+++ b/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;
+}
diff --git a/code/train/C++/0025424_possibilities.cc b/code/train/C++/0025424_possibilities.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3b7ef20298882f7c3fdb7a205ad580b427bab3d2
--- /dev/null
+++ b/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;
+}
diff --git a/code/train/C++/0025962_Otsu.cc b/code/train/C++/0025962_Otsu.cc
new file mode 100644
index 0000000000000000000000000000000000000000..44e839650a4e716ea293a117c41a52d4ad6b7488
--- /dev/null
+++ b/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;
+    }
+  }
+}
diff --git a/code/train/C++/0025967_16.cpp b/code/train/C++/0025967_16.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a39a1999b19e1af4e0a10a0bc4b146fec3ccca7d
--- /dev/null
+++ b/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;
+}
\ No newline at end of file
diff --git a/code/train/C++/0026485_tst_qscopedvaluerollback.cpp b/code/train/C++/0026485_tst_qscopedvaluerollback.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..af82897179ff4478067d01f8a900897b37db251c
--- /dev/null
+++ b/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"
diff --git a/code/train/C++/0026931_FEEPROM.cpp b/code/train/C++/0026931_FEEPROM.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4e3ecd33aadf011d52da2d3ca97d6f133a70adb2
--- /dev/null
+++ b/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;  
+}
+
+
+ 
\ No newline at end of file
diff --git a/code/train/C++/0027205_main.cpp b/code/train/C++/0027205_main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b0332d989520c74c553554b38586cfe1983c6ee2
--- /dev/null
+++ b/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"
diff --git a/code/train/C++/0027411_Defines.cpp b/code/train/C++/0027411_Defines.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..53993d109bd5ab577f174af6808b85b0cea462b6
--- /dev/null
+++ b/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);
+	}
+}
+
+
diff --git a/code/train/C++/0027495_uf.cc b/code/train/C++/0027495_uf.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f4cc13e2ffe2636ead35dc32caa1e9d8d85f62b8
--- /dev/null
+++ b/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
diff --git a/code/train/C++/0027730_reverse_geocoder.cpp b/code/train/C++/0027730_reverse_geocoder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c2796138dcb0400b5b46f08fae813e302155d317
--- /dev/null
+++ b/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
diff --git a/code/train/C++/0027996_gain_change_calculator.cc b/code/train/C++/0027996_gain_change_calculator.cc
new file mode 100644
index 0000000000000000000000000000000000000000..13017d4220b5b7c41f8f500a198204e4cd0bc879
--- /dev/null
+++ b/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
diff --git a/code/train/C++/0028086_StacksDP.cpp b/code/train/C++/0028086_StacksDP.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..71390f268699852c641293595d9c5e7247a98d5f
--- /dev/null
+++ b/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);
+
+};
+
diff --git a/code/train/C++/0028526_Squirrel_Simulation.cpp b/code/train/C++/0028526_Squirrel_Simulation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e098e15a98e9aeaa76de4c51c390a465d6bb68cf
--- /dev/null
+++ b/code/train/C++/0028526_Squirrel_Simulation.cpp
@@ -0,0 +1,45 @@
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <map>
+#include <climits>
+#include <unordered_set>
+#include <algorithm>
+#include <cmath>
+
+using namespace std;
+
+
+class Solution {
+public:
+    int minDistance(int height, int width, vector<int>& tree, vector<int>& squirrel, vector<vector<int>>& nuts) {
+        int cnt = 0;
+        int save = INT_MIN;
+        for (auto nut : nuts) {
+            int treeD = calcDis(nut, tree);
+            int squD = calcDis(nut, squirrel);
+            save = max(save, treeD - squD);
+            cnt += treeD * 2;
+        }
+        cnt = cnt - save;
+        return cnt;
+    }
+
+    int calcDis(vector<int> pos1, vector<int> pos2) {
+        return abs(pos1[0] - pos2[0]) + abs(pos1[1] - pos2[1]);
+    }
+};
+
+
+
+int main(int argc, char const *argv[]) {
+    
+    Solution s;
+    vector<int> tree = {3,2};
+    vector<int> squ = {0,1};
+    vector<vector<int> > nuts = {{2,0},{4,1},{0,4},{1,3},{1,0},{3,4},{3,0},{2,3},{0,2},{0,0},{2,2},{4,2},{3,3},{4,4},{4,0},{4,3},{3,1},{2,1},{1,4},{2,4}};
+    
+    cout << s.minDistance(5,5,tree,squ,nuts) << endl;
+    return 0;
+}
diff --git a/code/train/C++/0028563_cblas_d.cpp b/code/train/C++/0028563_cblas_d.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..39cbc77fd9398dd4b88d5d1d54200b2301d38449
--- /dev/null
+++ b/code/train/C++/0028563_cblas_d.cpp
@@ -0,0 +1,245 @@
+/*
+    -- MAGMA (version 2.1.0) --
+       Univ. of Tennessee, Knoxville
+       Univ. of California, Berkeley
+       Univ. of Colorado, Denver
+       @date August 2016
+ 
+       @author Mark Gates
+       @generated from src/cblas_z.cpp, normal z -> d, Tue Aug 30 09:38:00 2016
+
+    Wrappers around a few CBLAS functions.
+    
+    Primarily, we use the standard Fortran BLAS interface in MAGMA. However,
+    functions that return a value (as opposed to subroutines that are void)
+    are not portable, as they depend on how Fortran returns values. The routines
+    here provide a portable interface. These are not identical to CBLAS, in
+    particular, [cz]dot[uc] return real numbers (as in Fortran BLAS) rather
+    than return values via an argument.
+    
+    Only these BLAS-1 functions are provided:
+    
+    magma_cblas_dasum / dasum
+    magma_cblas_dnrm2 / dnrm2
+    magma_cblas_ddot  / ddot
+    magma_cblas_ddot  / ddot
+
+*/
+#include "magma_internal.h"
+
+#define REAL
+
+/***************************************************************************//**
+    @return Sum of absolute values of vector x;
+            \f$ \sum_i | real(x_i) | + | imag(x_i) | \f$.
+
+    To avoid dependence on CBLAS and incompatability issues between BLAS
+    libraries, MAGMA uses its own implementation, following BLAS reference.
+    
+    @param[in]
+    n       Number of elements in vector x. n >= 0.
+
+    @param[in]
+    x       DOUBLE PRECISION array on CPU host.
+            The n element vector x of dimension (1 + (n-1)*incx).
+
+    @param[in]
+    incx    Stride between consecutive elements of x. incx > 0.
+
+    @ingroup magma_asum
+*******************************************************************************/
+extern "C"
+double magma_cblas_dasum(
+    magma_int_t n,
+    const double *x, magma_int_t incx )
+{
+    if ( n <= 0 || incx <= 0 ) {
+        return 0;
+    }
+    double result = 0;
+    if ( incx == 1 ) {
+        for( magma_int_t i=0; i < n; ++i ) {
+            result += MAGMA_D_ABS1( x[i] );
+        }
+    }
+    else {
+        magma_int_t nincx = n*incx;
+        for( magma_int_t i=0; i < nincx; i += incx ) {
+            result += MAGMA_D_ABS1( x[i] );
+        }
+    }
+    return result;
+}
+
+
+static inline double sqr( double x ) { return x*x; }
+
+/***************************************************************************//**
+    Returns 2-norm of vector x. Avoids unnecesary over/underflow.
+
+    To avoid dependence on CBLAS and incompatability issues between BLAS
+    libraries, MAGMA uses its own implementation, following BLAS reference.
+    
+    @param[in]
+    n       Number of elements in vector x. n >= 0.
+
+    @param[in]
+    x       DOUBLE PRECISION array on CPU host.
+            The n element vector x of dimension (1 + (n-1)*incx).
+
+    @param[in]
+    incx    Stride between consecutive elements of x. incx > 0.
+
+    @ingroup magma_nrm2
+*******************************************************************************/
+extern "C"
+double magma_cblas_dnrm2(
+    magma_int_t n,
+    const double *x, magma_int_t incx )
+{
+    if (n <= 0 || incx <= 0) {
+        return 0;
+    }
+    else {
+        double scale = 0;
+        double ssq   = 1;
+        // the following loop is equivalent to this call to the lapack
+        // auxiliary routine:
+        // call zlassq( n, x, incx, scale, ssq )
+        for( magma_int_t ix=0; ix < 1 + (n-1)*incx; ix += incx ) {
+            if ( real( x[ix] ) != 0 ) {
+                double temp = fabs( real( x[ix] ));
+                if (scale < temp) {
+                    ssq = 1 + ssq * sqr(scale/temp);
+                    scale = temp;
+                }
+                else {
+                    ssq += sqr(temp/scale);
+                }
+            }
+            #ifdef COMPLEX
+            if ( imag( x[ix] ) != 0 ) {
+                double temp = fabs( imag( x[ix] ));
+                if (scale < temp) {
+                    ssq = 1 + ssq * sqr(scale/temp);
+                    scale = temp;
+                }
+                else {
+                    ssq += sqr(temp/scale);
+                }
+            }
+            #endif
+        }
+        return scale*magma_dsqrt(ssq);
+    }
+}
+
+
+#ifdef COMPLEX
+/***************************************************************************//**
+    Returns dot product of vectors x and y; \f$ x^H y \f$.
+
+    To avoid dependence on CBLAS and incompatability issues between BLAS
+    libraries, MAGMA uses its own implementation, following BLAS reference.
+    
+    @param[in]
+    n       Number of elements in vector x and y. n >= 0.
+
+    @param[in]
+    x       DOUBLE PRECISION array on CPU host.
+            The n element vector x of dimension (1 + (n-1)*incx).
+
+    @param[in]
+    incx    Stride between consecutive elements of x. incx > 0.
+
+    @param[in]
+    y       DOUBLE PRECISION array on CPU host.
+            The n element vector y of dimension (1 + (n-1)*incy).
+
+    @param[in]
+    incy    Stride between consecutive elements of dy. incy > 0.
+
+    @ingroup magma__dot
+*******************************************************************************/
+extern "C"
+double magma_cblas_ddot(
+    magma_int_t n,
+    const double *x, magma_int_t incx,
+    const double *y, magma_int_t incy )
+{
+    // after too many issues with MKL and other BLAS, just write our own dot product!
+    double value = MAGMA_D_ZERO;
+    magma_int_t i;
+    if ( incx == 1 && incy == 1 ) {
+        for( i=0; i < n; ++i ) {
+            value += conj( x[i] ) * y[i];
+        }
+    }
+    else {
+        magma_int_t ix=0, iy=0;
+        if ( incx < 0 ) { ix = (-n + 1)*incx; }
+        if ( incy < 0 ) { iy = (-n + 1)*incy; }
+        for( i=0; i < n; ++i ) {
+            value += conj( x[ix] ) * y[iy];
+            ix += incx;
+            iy += incy;
+        }
+    }
+    return value;
+}
+#endif  // COMPLEX
+
+
+/***************************************************************************//**
+    @return dot product (unconjugated) of vectors x and y; \f$ x^T y \f$.
+
+    To avoid dependence on CBLAS and incompatability issues between BLAS
+    libraries, MAGMA uses its own implementation, following BLAS reference.
+
+    @param[in]
+    n       Number of elements in vector x and y. n >= 0.
+
+    @param[in]
+    x       DOUBLE PRECISION array on CPU host.
+            The n element vector x of dimension (1 + (n-1)*incx).
+
+    @param[in]
+    incx    Stride between consecutive elements of x. incx > 0.
+
+    @param[in]
+    y       DOUBLE PRECISION array on CPU host.
+            The n element vector y of dimension (1 + (n-1)*incy).
+
+    @param[in]
+    incy    Stride between consecutive elements of dy. incy > 0.
+
+    @ingroup magma__dot
+*******************************************************************************/
+extern "C"
+double magma_cblas_ddot(
+    magma_int_t n,
+    const double *x, magma_int_t incx,
+    const double *y, magma_int_t incy )
+{
+    // after too many issues with MKL and other BLAS, just write our own dot product!
+    double value = MAGMA_D_ZERO;
+    magma_int_t i;
+    if ( incx == 1 && incy == 1 ) {
+        for( i=0; i < n; ++i ) {
+            value += x[i] * y[i];
+        }
+    }
+    else {
+        magma_int_t ix=0, iy=0;
+        if ( incx < 0 ) { ix = (-n + 1)*incx; }
+        if ( incy < 0 ) { iy = (-n + 1)*incy; }
+        for( i=0; i < n; ++i ) {
+            value += x[ix] * y[iy];
+            ix += incx;
+            iy += incy;
+        }
+    }
+    return value;
+}
+
+#undef REAL
diff --git a/code/train/C++/0028606_largestnum.cpp b/code/train/C++/0028606_largestnum.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..656fd30df7d67fbdef8fd48ae83b608a573f7f70
--- /dev/null
+++ b/code/train/C++/0028606_largestnum.cpp
@@ -0,0 +1,72 @@
+/*Given a list of non negative integers, arrange them such that they form the largest number.
+
+For example, given [3, 30, 34, 5, 9], the largest formed number is 9534330.
+
+Note: The result may be very large, so you need to return a string instead of an integer.*/
+
+#include <vector>
+#include <algorithm>
+#include <iostream>
+using namespace std;
+
+char *itoa(int num,int radix = 10){
+    const int MAX_LEN = 12;
+    int isNega = 0;
+    if(num < 0){
+        isNega = 1;
+        num = -num;
+    }
+    char* str = new char[MAX_LEN];
+    str[MAX_LEN - 1] = '\0';
+    int t = MAX_LEN - 2;
+    while(1){
+        int end = num%radix;
+        str[t--] = end + '0';
+        num = (num-end)/radix;
+        if(num == 0)
+            break;
+    }
+    if(isNega){str[t--] = '-';}
+    return &str[++t];
+}
+
+bool cmp(int a, int b) {
+    char* sa = itoa(a);
+    char* sb = itoa(b);
+    for(;*sa && *sb;sa++,sb++){
+        if(*sa == *sb)
+            continue;
+        else if(*sa > *sb){
+            return true;
+        }else{
+            return false;
+        }
+    }
+    return !*sa?true:false;
+}
+
+string largestNumber(vector<int> &num) {
+    sort(num.begin(), num.end(), cmp);
+    if (num[0] == 0) {
+        return "0";
+    }
+
+    char strn[11] = { 0 }; // 最大整形为11个数
+    string result;
+
+    result.reserve(8 * num.size()); // 开辟保留空间会快点
+    for (vector<int>::iterator it = num.begin(); it != num.end(); ++it) {
+        sprintf(strn, "%d", *it);
+        result += strn;
+    }
+
+    return result;
+}
+
+
+int main(int argc, char const *argv[])
+{
+    vector<int> v = {1,2,3,4,91,89,10,5,6,9};
+    cout << largestNumber(v) << endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/code/train/C++/0028956_2.4.6_K-d_Tree__Nearest_Neighbor_.cpp b/code/train/C++/0028956_2.4.6_K-d_Tree__Nearest_Neighbor_.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..382233a2ddf270e2d553d7cd29ee3dae6b20eab6
--- /dev/null
+++ b/code/train/C++/0028956_2.4.6_K-d_Tree__Nearest_Neighbor_.cpp
@@ -0,0 +1,132 @@
+/*
+
+Maintain a set of two-dimensional points while supporting queries for the
+closest point in the set to a given query point. This implementation uses
+std::pair to represent points, requiring operators <, ==, -, and long double
+casting to be defined on the numeric template type.
+
+- kd_tree(lo, hi) constructs a set from two RandomAccessIterators to std::pair
+  as a range [lo, hi) of points.
+- nearest(x, y, can_equal) returns a point in the set that is closest to (x, y)
+  by Euclidean distance. This may be equal to (x, y) only if can_equal is true.
+
+Time Complexity:
+- O(n log n) per call to the constructor, where n is the number of points.
+- O(log n) on average per call to nearest().
+
+Space Complexity:
+- O(n) for storage of the points.
+- O(log n) auxiliary stack space for nearest().
+
+*/
+
+#include <algorithm>
+#include <limits>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+template<class T>
+class kd_tree {
+  typedef std::pair<T, T> point;
+
+  static inline bool comp1(const point &a, const point &b) {
+    return a.first < b.first;
+  }
+
+  static inline bool comp2(const point &a, const point &b) {
+    return a.second < b.second;
+  }
+
+  std::vector<point> tree;
+  std::vector<bool> div_x;
+
+  void build(int lo, int hi) {
+    if (lo >= hi) {
+      return;
+    }
+    int mid = lo + (hi - lo)/2;
+    T minx, maxx, miny, maxy;
+    minx = maxx = tree[lo].first;
+    miny = maxy = tree[lo].second;
+    for (int i = lo + 1; i < hi; i++) {
+      minx = std::min(minx, tree[i].first);
+      miny = std::min(miny, tree[i].second);
+      maxx = std::max(maxx, tree[i].first);
+      maxy = std::max(maxy, tree[i].second);
+    }
+    div_x[mid] = !((maxx - minx) < (maxy - miny));
+    std::nth_element(tree.begin() + lo, tree.begin() + mid, tree.begin() + hi,
+                     div_x[mid] ? comp1 : comp2);
+    if (lo + 1 == hi) {
+      return;
+    }
+    build(lo, mid);
+    build(mid + 1, hi);
+  }
+
+  // Helper variables for nearest().
+  long double min_dist;
+  int id;
+
+  void nearest(int lo, int hi, const T &x, const T &y, bool can_equal) {
+    if (lo >= hi) {
+      return;
+    }
+    int mid = lo + (hi - lo)/2;
+    T dx = x - tree[mid].first, dy = y - tree[mid].second;
+    long double d = dx*(long double)dx + dy*(long double)dy;
+    if (d < min_dist && (can_equal || d != 0)) {
+      min_dist = d;
+      id = mid;
+    }
+    if (lo + 1 == hi) {
+      return;
+    }
+    d = (long double)(div_x[mid] ? dx : dy);
+    int l1 = lo, r1 = mid, l2 = mid + 1, r2 = hi;
+    if (d > 0) {
+      std::swap(l1, l2);
+      std::swap(r1, r2);
+    }
+    nearest(l1, r1, x, y, can_equal);
+    if (d*(long double)d < min_dist) {
+      nearest(l2, r2, x, y, can_equal);
+    }
+  }
+
+ public:
+  template<class It>
+  kd_tree(It lo, It hi) : tree(lo, hi) {
+    int n = std::distance(lo, hi);
+    if (n <= 1) {
+      throw std::runtime_error("K-d tree must be have at least 2 points.");
+    }
+    div_x.resize(n);
+    build(0, n);
+  }
+
+  point nearest(const T &x, const T &y, bool can_equal = true) {
+    min_dist = std::numeric_limits<long double>::max();
+    nearest(0, tree.size(), x, y, can_equal);
+    return tree[id];
+  }
+};
+
+/*** Example Usage ***/
+
+#include <cassert>
+using namespace std;
+
+int main() {
+  pair<int, int> p[3];
+  p[0] = make_pair(0, 2);
+  p[1] = make_pair(0, 3);
+  p[2] = make_pair(-1, 0);
+  kd_tree<int> t(p, p + 3);
+  assert(t.nearest(0, 2, true) == make_pair(0, 2));
+  assert(t.nearest(0, 2, false) == make_pair(0, 3));
+  assert(t.nearest(0, 0) == make_pair(-1, 0));
+  assert(t.nearest(-10000, 0) == make_pair(-1, 0));
+  return 0;
+}
diff --git a/code/train/C++/0029412_tree-height.cpp b/code/train/C++/0029412_tree-height.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6ce3d3ad27a977594d7a74db8ac0c13eabb2f2c0
--- /dev/null
+++ b/code/train/C++/0029412_tree-height.cpp
@@ -0,0 +1,121 @@
+#include <iostream>
+#include <cstddef>
+
+using namespace std;    
+
+class Node{
+    public:
+        int data;
+        Node *left;
+        Node *right;
+        Node(int d){
+            data = d;
+            left = NULL;
+            right = NULL;
+        }
+};
+
+class Solution {
+    public:
+        Node* insert(Node* root, int data) {
+            if(root == NULL) {
+                return new Node(data);
+            }
+            else {
+                Node* cur;
+                if(data <= root->data){
+                    cur = insert(root->left, data);
+                    root->left = cur;
+                }
+                else{
+                    cur = insert(root->right, data);
+                    root->right = cur;
+               }
+
+               return root;
+           }
+        }
+/*The tree node has data, left child and right child 
+class Node {
+    int data;
+    Node* left;
+    Node* right;
+};
+
+*/
+
+    // recursive
+    int height1(Node* root) {
+        return max(root->left  ? (1 + height1(root->left)) : 0,
+                   root->right ? (1 + height1(root->right)) : 0);
+    }
+
+    // Gosh I need a stack
+    class stack {
+      public:
+        stack() : head(nodes) {}
+        void push(Node* v) { *head++ = v; }
+        Node* pop() { return *(--head); }
+        bool empty() const { return head == nodes; }
+      private:
+        Node* nodes[10000];
+        Node** head;
+    };
+
+    // iterative
+    int height(Node* root) {
+        if (!root) return 0;
+        int depth = 0, max_depth = 0;
+        
+        Node* prev = root;
+        Node* current = root;
+        stack path;
+        while (true) {
+            bool from_left = prev == current->left;
+            bool from_right = prev == current->right;
+            bool from_top = !from_left && !from_right;
+            bool go_left = from_top && current->left;
+            bool go_right = (!go_left || from_left) && !from_right && current->right;
+            bool go_up = !go_left && !go_right;
+            prev = current;
+            if (go_left) {
+                path.push(current);
+                ++depth;
+                current = current->left;
+            }
+            if (go_right) {
+                path.push(current);
+                ++depth;
+                current = current->right;
+            }
+            if (go_up) {
+                if (!current->left && !current->right) {
+                    max_depth = max(depth, max_depth);
+                }
+                if (path.empty()) {
+                    return max_depth;
+                }
+                current = path.pop();
+                --depth;
+            }
+        }
+    }
+}; //End of Solution
+
+int main() {
+    Solution myTree;
+    Node* root = NULL;
+    int t;
+    int data;
+
+    cin >> t;
+
+    while(t-- > 0){
+        cin >> data;
+        root = myTree.insert(root, data);
+    }
+    int height = myTree.height(root);
+    cout << height;
+
+    return 0;
+}
diff --git a/code/train/C++/0029708_op_stats_to_pod_stats.cc b/code/train/C++/0029708_op_stats_to_pod_stats.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c6a3f15ea6a808c3bcceacccd656bd72e31517ae
--- /dev/null
+++ b/code/train/C++/0029708_op_stats_to_pod_stats.cc
@@ -0,0 +1,96 @@
+/* Copyright 2020 The TensorFlow Authors. 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 "tensorflow/core/profiler/convert/op_stats_to_pod_stats.h"
+
+#include "google/protobuf/any.pb.h"
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/lib/gtl/map_util.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/profiler/protobuf/steps_db.pb.h"
+#include "tensorflow/core/profiler/utils/diagnostics.h"
+#include "tensorflow/core/profiler/utils/event_span.h"
+#include "tensorflow/core/profiler/utils/math_utils.h"
+
+namespace tensorflow {
+namespace profiler {
+
+namespace {
+
+PodStatsRecord CreatePodStatsRecord(absl::string_view host_name,
+                                    const StepInfoResult& step_info) {
+  PodStatsRecord record;
+  GenericStepBreakdown generic;
+  bool success = step_info.step_breakdown().UnpackTo(&generic);
+  DCHECK(success);
+  record.set_host_name(string(host_name));
+  record.set_step_num(step_info.step_num());
+  record.set_total_duration_us(PicoToMicro(step_info.duration_ps()));
+  auto& step_breakdown_map = *record.mutable_step_breakdown_us();
+  std::vector<std::pair<uint64, absl::string_view>> metrics;
+
+  auto add_event = [&](GenericEventType type,
+                       std::initializer_list<EventType> event_list) {
+    uint64 ps = 0;
+    for (const auto& event_type : event_list) {
+      ps += gtl::FindWithDefault(generic.type_ps(), event_type, /*value=*/0);
+    }
+    step_breakdown_map[type] = PicoToMicro(ps);
+    metrics.emplace_back(ps, GetGenericEventTypeStr(type));
+  };
+
+  add_event(kDeviceCompute, {DEVICE_COMPUTE_32, DEVICE_COMPUTE_16});
+  add_event(kDeviceToDevice, {DEVICE_TO_DEVICE, DEVICE_WAIT_DEVICE});
+  add_event(kDeviceCollectives, {DEVICE_COLLECTIVES});
+  add_event(kHostCompute, {HOST_COMPUTE});
+  add_event(kHostPrepare, {HOST_PREPARE});
+  add_event(kInput, {HOST_WAIT_INPUT, HOST_TO_DEVICE, DEVICE_WAIT_HOST});
+  add_event(kOutput, {DEVICE_TO_HOST});
+  add_event(kCompile, {HOST_COMPILE});
+  add_event(kAllOthers, {UNKNOWN_TIME});
+
+  std::sort(metrics.begin(), metrics.end());
+  record.set_bottleneck(metrics.back().second.data(),
+                        metrics.back().second.size());
+  return record;
+}
+
+}  // namespace
+
+PodStatsDatabase ConvertOpStatsToPodStats(const OpStats& op_stats) {
+  PodStatsDatabase pod_stats_db;
+  const auto& core_id_map = op_stats.core_id_to_details();
+  for (int i = GenericEventType::kFirstGenericEventType;
+       i <= GenericEventType::kLastGenericEventType; i++) {
+    auto& event = *pod_stats_db.add_step_breakdown_events();
+    event.set_id(i);
+    absl::string_view type_str =
+        GetGenericEventTypeStr(static_cast<GenericEventType>(i));
+    event.set_name(type_str.data(), type_str.size());
+  }
+
+  for (const auto& step_sequence : op_stats.step_db().step_sequence()) {
+    for (const auto& entry : step_sequence.step_info_per_core()) {
+      const CoreDetails& details = core_id_map.at(entry.first);
+      *pod_stats_db.add_pod_stats_record() =
+          CreatePodStatsRecord(details.hostname(), entry.second);
+    }
+  }
+  PopulateStepDiagnostics(op_stats, pod_stats_db.mutable_diagnostics());
+  return pod_stats_db;
+}
+
+}  // namespace profiler
+}  // namespace tensorflow
diff --git a/code/train/C++/0029712_1098.cpp b/code/train/C++/0029712_1098.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a6acc4b9440cf6766a8a2f632b49e24defc7d0ba
--- /dev/null
+++ b/code/train/C++/0029712_1098.cpp
@@ -0,0 +1,88 @@
+#include <iostream>
+#include <vector>
+#include <set>
+#include <map>
+#include <algorithm>
+#include <numeric>
+#include <utility>
+#include <functional>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+using namespace std;
+
+void AdjustHeap(vector<int>& heap, int heapSize, int adjustIndex) {
+	// pMaxIndex point to the max node of cur,left,right nodes
+	int pMaxIndex = adjustIndex;
+	if (2*adjustIndex+1 < heapSize && heap[2*adjustIndex+1] > heap[pMaxIndex])
+		pMaxIndex = 2 * adjustIndex + 1;
+	if (2*adjustIndex+2 < heapSize && heap[2*adjustIndex+2] > heap[pMaxIndex])
+		pMaxIndex = 2 * adjustIndex + 2;
+
+	// the cur node has max value, no need to adjust
+	if (pMaxIndex == adjustIndex) {
+		return;
+	} else {
+		swap(heap[adjustIndex], heap[pMaxIndex]);
+		AdjustHeap(heap, heapSize, pMaxIndex);
+	}
+}
+
+void PrintVector(const vector<int>& v) {
+	for (size_t i = 0; i < v.size(); ++i) {
+		if (i == 0) printf("%d", v[i]);
+		else printf(" %d", v[i]);
+	}
+	printf("\n");
+}
+
+int main()
+{
+	freopen("input.txt", "r", stdin);
+	int n;
+	scanf("%d", &n);
+
+	vector<int> input(n, 0);
+	vector<int> output(n, 0);
+	for (int i = 0; i < n; ++i) scanf("%d", &input[i]);
+	for (int i = 0; i < n; ++i) scanf("%d", &output[i]);
+
+	vector<int> temp(input.begin(), input.end());
+	sort(temp.begin(), temp.end());
+
+	bool isHeapSort = true;
+	int j = n - 1;
+	while (j >= 0 && temp[j] == output[j]) j--;
+	for (int i = 0; i <= j; ++i) {
+		if (2*i+1 <= j) {
+			if (output[i] < output[2*i+1]) isHeapSort = false;
+		}
+		if (2*i+2 <= j) {
+			if (output[i] < output[2*i+2]) isHeapSort = false;
+		}
+	}
+
+	if (isHeapSort) {
+		printf("Heap Sort\n");
+		int heapSize = j + 1;
+		swap(output[0], output[heapSize-1]);
+		heapSize--;
+		AdjustHeap(output, heapSize, 0);
+		PrintVector(output);
+
+	} else {
+		printf("Insertion Sort\n");
+		int k = 0;
+		while (k+1 < n && output[k] <= output[k+1]) k++;
+		int next = k + 1;
+		int temp = output[next];
+		int start = 0;
+		while (output[start] <= output[next]) start++;
+		for (int idx = next - 1; idx >= start; --idx) {
+			output[idx+1] = output[idx];
+		}
+		output[start] = temp;
+		PrintVector(output);
+	}
+	return 0;
+}
\ No newline at end of file
diff --git a/code/train/C++/0029948_1913.cpp b/code/train/C++/0029948_1913.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b2d83174b371bc87db08b0a8bb959de006c7a9aa
--- /dev/null
+++ b/code/train/C++/0029948_1913.cpp
@@ -0,0 +1,80 @@
+//{
+#include<bits/stdc++.h>
+using namespace std;
+typedef long long ll;
+typedef double lf;
+typedef pair<ll,ll> ii;
+#define REP(i,n) for(ll i=0;i<n;i++)
+#define REP1(i,n) for(ll i=1;i<=n;i++)
+#define FILL(i,n) memset(i,n,sizeof i)
+#define X first
+#define Y second
+#define SZ(_a) (int)_a.size()
+#define ALL(_a) _a.begin(),_a.end()
+#define pb push_back
+#ifdef brian
+#define debug(...) do{\
+    fprintf(stderr,"%s - %d (%s) = ",__PRETTY_FUNCTION__,__LINE__,#__VA_ARGS__);\
+    _do(__VA_ARGS__);\
+}while(0)
+template<typename T>void _do(T &&_x){cerr<<_x<<endl;}
+template<typename T,typename ...S> void _do(T &&_x,S &&..._t){cerr<<_x<<" ,";_do(_t...);}
+template<typename _a,typename _b> ostream& operator << (ostream &_s,const pair<_a,_b> &_p){return _s<<"("<<_p.X<<","<<_p.Y<<")";}
+template<typename It> ostream& _OUTC(ostream &_s,It _ita,It _itb)
+{
+    _s<<"{";
+    for(It _it=_ita;_it!=_itb;_it++)
+    {
+        _s<<(_it==_ita?"":",")<<*_it;
+    }
+    _s<<"}";
+    return _s;
+}
+template<typename _a> ostream &operator << (ostream &_s,vector<_a> &_c){return _OUTC(_s,ALL(_c));}
+template<typename _a> ostream &operator << (ostream &_s,set<_a> &_c){return _OUTC(_s,ALL(_c));}
+template<typename _a,typename _b> ostream &operator << (ostream &_s,map<_a,_b> &_c){return _OUTC(_s,ALL(_c));}
+template<typename _t> void pary(_t _a,_t _b){_OUTC(cerr,_a,_b);cerr<<endl;}
+#define IOS()
+#else
+#define debug(...)
+#define pary(...)
+#define endl '\n'
+#define IOS() ios_base::sync_with_stdio(0);cin.tie(0);
+#endif // brian
+//}
+
+
+const ll MAXn=5e3+5,MAXlg=__lg(MAXn)+2;
+const ll MOD=1000000007;
+const ll INF=ll(1e15);
+
+ll d[MAXn],ct[MAXn];
+
+int main()
+{
+    IOS();
+    ll T;
+    cin>>T;
+    while(T--)
+    {
+      ll n,ans=0;
+      cin>>n;
+      REP(i,n)cin>>d[i];
+      REP(i,n-1)
+      {
+        FILL(ct,0);
+        ll mn=d[i],mx=d[i],t=1;ct[d[i]]=1;
+        for(int j=i+1;j<n;j++)
+        {
+          mn=min(mn,d[j]);mx=max(mx,d[j]);
+          if(!ct[d[j]])ct[d[j]]++,t++;
+          if(mn==min(d[i],d[j])&&mx==max(d[i],d[j])&&t==j-i+1&&mx-mn==j-i)
+          {
+            ans++;
+            
+          }
+        }
+      }
+      cout<<ans<<endl;
+    }
+}
diff --git a/code/train/C++/0029997_DbaccInit.cpp b/code/train/C++/0029997_DbaccInit.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2cb3b0f4e186f94a42514f10c79a686d78942dda
--- /dev/null
+++ b/code/train/C++/0029997_DbaccInit.cpp
@@ -0,0 +1,187 @@
+/*
+   Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved.
+
+   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; version 2 of the License.
+
+   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 St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+
+
+
+#define DBACC_C
+#include "Dbacc.hpp"
+
+#define JAM_FILE_ID 346
+
+
+#define DEBUG(x) { ndbout << "ACC::" << x << endl; }
+
+void Dbacc::initData() 
+{
+  coprecsize = ZOPRECSIZE;
+  cpagesize = ZPAGESIZE;
+  ctablesize = ZTABLESIZE;
+  cfragmentsize = ZFRAGMENTSIZE;
+  cscanRecSize = ZSCAN_REC_SIZE;
+
+  Pool_context pc;
+  pc.m_block = this;
+  directoryPool.init(RT_DBACC_DIRECTORY, pc);
+
+  fragmentrec = 0;
+  operationrec = 0;
+  page8 = 0;
+  scanRec = 0;
+  tabrec = 0;
+
+  m_free_pct = 0;
+  m_oom = false;
+  cnoOfAllocatedPagesMax = cnoOfAllocatedPages = cpagesize = cpageCount = m_maxAllocPages = 0;
+  // Records with constant sizes
+
+  RSS_OP_COUNTER_INIT(cnoOfFreeFragrec);
+
+}//Dbacc::initData()
+
+void Dbacc::initRecords() 
+{
+  {
+    AllocChunk chunks[16];
+    const Uint32 pages = (cpagesize + 3) / 4;
+    const Uint32 chunkcnt = allocChunks(chunks, 16, RT_DBTUP_PAGE, pages,
+                                        CFG_DB_INDEX_MEM);
+
+    /**
+     * Set base ptr
+     */
+    Ptr<GlobalPage> pagePtr;
+    m_shared_page_pool.getPtr(pagePtr, chunks[0].ptrI);
+    page8 = (Page8*)pagePtr.p;
+
+    /**
+     * 1) Build free-list per chunk
+     * 2) Add chunks to cfreepages-list
+     */
+    cfreepages.init();
+    cpagesize = 0;
+    cpageCount = 0;
+    LocalPage8List freelist(*this, cfreepages);
+    for (Int32 i = chunkcnt - 1; i >= 0; i--)
+    {
+      Ptr<GlobalPage> pagePtr;
+      m_shared_page_pool.getPtr(pagePtr, chunks[i].ptrI);
+      const Uint32 cnt = 4 * chunks[i].cnt; // 4 8k per 32k
+      Page8* base = (Page8*)pagePtr.p;
+      ndbrequire(base >= page8);
+      const Uint32 ptrI = Uint32(base - page8);
+      if (ptrI + cnt > cpagesize)
+        cpagesize = ptrI + cnt;
+      for (Uint32 j = 0; j < cnt; j++)
+      {
+        refresh_watch_dog();
+        freelist.addFirst(Page8Ptr::get(&base[j], ptrI + j));
+      }
+
+      cpageCount += cnt;
+      ndbassert(freelist.getCount() + cnoOfAllocatedPages == cpageCount);
+    }
+    m_maxAllocPages = cpagesize;
+  }
+
+  operationrec = (Operationrec*)allocRecord("Operationrec",
+					    sizeof(Operationrec),
+					    coprecsize);
+
+  fragmentrec = (Fragmentrec*)allocRecord("Fragmentrec",
+					  sizeof(Fragmentrec), 
+					  cfragmentsize);
+
+  scanRec = (ScanRec*)allocRecord("ScanRec",
+				  sizeof(ScanRec), 
+				  cscanRecSize);
+
+  tabrec = (Tabrec*)allocRecord("Tabrec",
+				sizeof(Tabrec),
+				ctablesize);
+}//Dbacc::initRecords()
+
+Dbacc::Dbacc(Block_context& ctx, Uint32 instanceNumber):
+  SimulatedBlock(DBACC, ctx, instanceNumber),
+  c_tup(0)
+{
+  BLOCK_CONSTRUCTOR(Dbacc);
+
+  // Transit signals
+  addRecSignal(GSN_DUMP_STATE_ORD, &Dbacc::execDUMP_STATE_ORD);
+  addRecSignal(GSN_DEBUG_SIG, &Dbacc::execDEBUG_SIG);
+  addRecSignal(GSN_CONTINUEB, &Dbacc::execCONTINUEB);
+  addRecSignal(GSN_ACC_CHECK_SCAN, &Dbacc::execACC_CHECK_SCAN);
+  addRecSignal(GSN_EXPANDCHECK2, &Dbacc::execEXPANDCHECK2);
+  addRecSignal(GSN_SHRINKCHECK2, &Dbacc::execSHRINKCHECK2);
+  addRecSignal(GSN_READ_PSEUDO_REQ, &Dbacc::execREAD_PSEUDO_REQ);
+
+  // Received signals
+  addRecSignal(GSN_STTOR, &Dbacc::execSTTOR);
+  addRecSignal(GSN_ACCKEYREQ, &Dbacc::execACCKEYREQ);
+  addRecSignal(GSN_ACCSEIZEREQ, &Dbacc::execACCSEIZEREQ);
+  addRecSignal(GSN_ACCFRAGREQ, &Dbacc::execACCFRAGREQ);
+  addRecSignal(GSN_NEXT_SCANREQ, &Dbacc::execNEXT_SCANREQ);
+  addRecSignal(GSN_ACC_ABORTREQ, &Dbacc::execACC_ABORTREQ);
+  addRecSignal(GSN_ACC_SCANREQ, &Dbacc::execACC_SCANREQ);
+  addRecSignal(GSN_ACCMINUPDATE, &Dbacc::execACCMINUPDATE);
+  addRecSignal(GSN_ACC_COMMITREQ, &Dbacc::execACC_COMMITREQ);
+  addRecSignal(GSN_ACC_TO_REQ, &Dbacc::execACC_TO_REQ);
+  addRecSignal(GSN_ACC_LOCKREQ, &Dbacc::execACC_LOCKREQ);
+  addRecSignal(GSN_NDB_STTOR, &Dbacc::execNDB_STTOR);
+  addRecSignal(GSN_DROP_TAB_REQ, &Dbacc::execDROP_TAB_REQ);
+  addRecSignal(GSN_READ_CONFIG_REQ, &Dbacc::execREAD_CONFIG_REQ, true);
+  addRecSignal(GSN_DROP_FRAG_REQ, &Dbacc::execDROP_FRAG_REQ);
+
+  addRecSignal(GSN_DBINFO_SCANREQ, &Dbacc::execDBINFO_SCANREQ);
+  addRecSignal(GSN_NODE_STATE_REP, &Dbacc::execNODE_STATE_REP, true);
+
+  initData();
+
+#ifdef VM_TRACE
+  {
+    void* tmp[] = { &fragrecptr,
+                    &operationRecPtr,
+                    &queOperPtr,
+                    &expPageptr,
+                    &scanPtr,
+                    &tabptr
+    };
+    init_globals_list(tmp, sizeof(tmp)/sizeof(tmp[0]));
+  }
+#endif
+}//Dbacc::Dbacc()
+
+Dbacc::~Dbacc() 
+{
+  deallocRecord((void **)&fragmentrec, "Fragmentrec",
+		sizeof(Fragmentrec), 
+		cfragmentsize);
+  
+  deallocRecord((void **)&operationrec, "Operationrec",
+		sizeof(Operationrec),
+		coprecsize);
+  
+  deallocRecord((void **)&scanRec, "ScanRec",
+		sizeof(ScanRec), 
+		cscanRecSize);
+  
+  deallocRecord((void **)&tabrec, "Tabrec",
+		sizeof(Tabrec),
+		ctablesize);
+  }//Dbacc::~Dbacc()
+
+BLOCK_FUNCTIONS(Dbacc)
diff --git a/code/train/C++/0031123_sgu148.cpp b/code/train/C++/0031123_sgu148.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a0aa8d3623386c922c212e8da5e50f233c957a3d
--- /dev/null
+++ b/code/train/C++/0031123_sgu148.cpp
@@ -0,0 +1,72 @@
+/* SGU ID:  #148
+ * Type  :  Heap + Mathematics
+ * Author:  Hangchen Yu
+ * Date  :  03/06/2015
+ */
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <vector>
+#include <utility>
+#include <cmath>
+#include <queue>
+
+using namespace std;
+
+typedef pair<long, long> Pair;
+#define INF 1000000000
+
+int main() {
+    int n;
+    scanf("%d", &n);
+    long W[n+1], L[n+1], P[n+1];
+    long SumOfWeight[n+1];
+    memset(P, 0, sizeof(P));
+    memset(SumOfWeight, 0, sizeof(SumOfWeight));
+    for (int i = 1; i <= n; i++) {
+        scanf("%ld%ld%ld", W+i, L+i, P+i);
+        SumOfWeight[i] = SumOfWeight[i-1] + W[i];
+    }
+
+    priority_queue<Pair> que, ans;
+    long best = INF, money = 0;
+    for (int i = n; i >= 1; i--) {
+        money += P[i];
+        while (!que.empty() && que.top().first > SumOfWeight[i-1]) {
+            money -= P[que.top().second];
+            que.pop();
+        }
+        que.push(make_pair(SumOfWeight[i]-L[i], i));
+        if (money < best) {
+            best = money;
+            ans = que;
+        }
+    }
+
+    while (!ans.empty()) {
+        printf("%ld\n", ans.top().second);
+        ans.pop();
+    }
+    
+    return 0;
+}
+
+
+/*
+ * Suppose the topest level (N is the lowest one) that terrorists
+ * need to depressurize is p. Then the p-level water must flow to
+ * the N-level, otherwise it makes no sense. So the levels which 
+ * need to be depressurized are:
+ *      {p} U {i | i>p, SumOfWeight[p~i]<=L[i]}
+ * Assume SumOfWeight[p] = W[1]+W[2]+...+W[p], then the expressi-
+ * on becomes
+ *      {p} U {i | i>p, SumOfWeight[i]-SumOfWeight[p-1]<=L[i]}
+ *      {p} U {i | i>p, SumOfWeight[i]-L[i]<=SumOfWeight[p-1]}
+ * Enumerate p and i, we get an O(N^2) algorithm.
+ *
+ * Notice that SumOfWeight[p-1] is increasing. If we enumerate p
+ * from N downto 1, on each step:
+ *      1. add p
+ *      2. delete i that SumOfWeight[i]-L[i] > SumOfWeight[p-1]
+ * We can use a heap to achieve such expression.
+ */
diff --git a/code/train/C++/0031570_subsets.cpp b/code/train/C++/0031570_subsets.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3ef01ce1d4d7cebc223d7b5dcd889700b0935e6e
--- /dev/null
+++ b/code/train/C++/0031570_subsets.cpp
@@ -0,0 +1,70 @@
+#include "basic_includes.hpp"
+
+using namespace std;
+
+void print_res(const vector<vector<int>> &res);
+
+class Solution {
+    public:
+        vector<vector<int>> subsets_recur(const vector<int>& nums, int idx)
+        {
+            if (idx == 0)
+            {
+                // Base case
+                vector<vector<int>> res;
+                vector<int> val;
+                res.push_back(val);
+                val.push_back(nums[0]);
+                res.push_back(val);
+                return res;
+            }
+            else
+            {
+                auto res = subsets_recur(nums, idx - 1);
+                size_t original_size = res.size();
+                for (size_t i = 0; i < original_size; i++)
+                {
+                    auto new_val = res[i];
+                    new_val.push_back(nums[idx]);
+                    res.push_back(new_val);
+                }
+                return res;
+            }
+        }
+        vector<vector<int>> subsets(vector<int>& nums) {
+            sort(nums.begin(), nums.end());
+            return subsets_recur(nums, nums.size() - 1);
+        }
+};
+
+void print_res(const vector<vector<int>> &res)
+{
+    for (auto subset: res)
+    {
+        cout << "[";
+        for (auto val: subset)
+        {
+            cout << val << ",";
+        }
+        cout << "]" << endl;
+    }
+}
+
+void test(vector<int> input)
+{
+    Solution sol;
+    auto res = sol.subsets(input);
+    cout << "test:\n";
+    print_res(res);
+}
+
+int main()
+{
+    vector<int> input = {4, 2, 3};
+    test(input);
+    vector<int> input2 = {3};
+    test(input2);
+    vector<int> input3 = {1, 2, 3, 4, 5};
+    test(input3);
+    return 0;
+}
diff --git a/code/train/C++/0031580_ops_dir.cpp b/code/train/C++/0031580_ops_dir.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..89975e1c18ce834c7e98b2ad22224d99bfdebfd3
--- /dev/null
+++ b/code/train/C++/0031580_ops_dir.cpp
@@ -0,0 +1,115 @@
+/*
+ *  Copyright 2009 Michael Stephens
+ *
+ *  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 <pwd.h>
+#include <grp.h>
+
+#include <mongocxx/client.hpp>
+
+#include "operations.h"
+#include "options.h"
+#include "utils.h"
+
+int gridfs_mkdir(const char* path, mode_t mode) {
+  path = fuse_to_mongo_path(path);
+
+  auto sdc = make_ScopedDbConnection();
+  mongo::DBClientBase &client = sdc->conn();
+
+  mongo::OID id;
+  id.init();
+  fuse_context *context = fuse_get_context();
+
+  mongo::BSONObjBuilder file;
+  file << "_id" << id
+       << "filename" << path
+       << "chunkSize" << 0
+       << "uploadDate" << mongo::DATENOW
+       << "md5" << 0
+       << "mode" << (mode | S_IFDIR);
+  {
+    passwd *pw = getpwuid(context->uid);
+    if (pw)
+      file << "owner" << pw->pw_name;
+  }
+  {
+    group *gr = getgrgid(context->gid);
+    if (gr)
+      file << "group" << gr->gr_name;
+  }
+
+  client.insert(db_name() + ".files",
+		file.obj());
+
+  return 0;
+}
+
+int gridfs_rmdir(const char* path) {
+  auto sdc = make_ScopedDbConnection();
+  mongo::GridFS gf = get_gridfs(sdc);
+
+  path = fuse_to_mongo_path(path);
+  gf.removeFile(path);
+
+  return 0;
+}
+
+int gridfs_readdir(const char *path, void *buf, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi) {
+  path = fuse_to_mongo_path(path);
+
+  filler(buf, ".", NULL, 0);
+  filler(buf, "..", NULL, 0);
+
+  auto sdc = make_ScopedDbConnection();
+  mongo::BSONObj proj = BSON("filename" << 1);
+  std::string path_start = path;
+  if (strlen(path) > 0)
+    path_start += "/";
+  std::unique_ptr<mongo::DBClientCursor> cursor = sdc->conn().query(db_name() + ".files",
+								    BSON("filename" <<
+									 BSON("$regex" << "^" + path_start)
+									 ),
+								    0, 0,
+								    &proj);
+  std::string lastFN;
+  while (cursor->more()) {
+    std::string filename = cursor->next()["filename"].String();
+    std::string rel = filename.substr(path_start.length());
+    if (rel.find("/") != std::string::npos)
+      continue;
+
+    /* If this filename matches the last filename we've seen, *do not* add it to the buffer because it's a duplicate filename */ 
+    if (lastFN != filename)
+      filler(buf, rel.c_str(), NULL, 0);
+
+    /* Update lastFN with our cursor's current filename */
+    lastFN = filename;
+    fprintf(stderr, "DEBUG: %s\n", lastFN.c_str());
+  }
+
+  for (auto i : open_files)
+    if (i.first.find(path_start) == 0) {
+      std::string rel = i.first.substr(path_start.length());
+      if (rel.find("/") != std::string::npos)
+	continue;
+
+      filler(buf, i.first.c_str(), NULL, 0);
+    }
+
+  return 0;
+}
+
diff --git a/code/train/C++/0031772_anim_audio_view.cpp b/code/train/C++/0031772_anim_audio_view.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cd4749968f3f115877835f9cb90c04dcbaf32b7b
--- /dev/null
+++ b/code/train/C++/0031772_anim_audio_view.cpp
@@ -0,0 +1,100 @@
+/**
+ * Mandelbulber v2, a 3D fractal generator       ,=#MKNmMMKmmßMNWy,
+ *                                             ,B" ]L,,p%%%,,,§;, "K
+ * Copyright (C) 2016-18 Mandelbulber Team     §R-==%w["'~5]m%=L.=~5N
+ *                                        ,=mm=§M ]=4 yJKA"/-Nsaj  "Bw,==,,
+ * This file is part of Mandelbulber.    §R.r= jw",M  Km .mM  FW ",§=ß., ,TN
+ *                                     ,4R =%["w[N=7]J '"5=],""]]M,w,-; T=]M
+ * Mandelbulber is free software:     §R.ß~-Q/M=,=5"v"]=Qf,'§"M= =,M.§ Rz]M"Kw
+ * you can redistribute it and/or     §w "xDY.J ' -"m=====WeC=\ ""%""y=%"]"" §
+ * modify it under the terms of the    "§M=M =D=4"N #"%==A%p M§ M6  R' #"=~.4M
+ * GNU General Public License as        §W =, ][T"]C  §  § '§ e===~ U  !§[Z ]N
+ * published by the                    4M",,Jm=,"=e~  §  §  j]]""N  BmM"py=ßM
+ * Free Software Foundation,          ]§ T,M=& 'YmMMpM9MMM%=w=,,=MT]M m§;'§,
+ * either version 3 of the License,    TWw [.j"5=~N[=§%=%W,T ]R,"=="Y[LFT ]N
+ * or (at your option)                   TW=,-#"%=;[  =Q:["V""  ],,M.m == ]N
+ * any later version.                      J§"mr"] ,=,," =="""J]= M"M"]==ß"
+ *                                          §= "=C=4 §"eM "=B:m|4"]#F,§~
+ * Mandelbulber is distributed in            "9w=,,]w em%wJ '"~" ,=,,ß"
+ * the hope that it will be useful,                 . "K=  ,=RMMMßM"""
+ * 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 Mandelbulber. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * ###########################################################################
+ *
+ * Authors: Krzysztof Marczak (buddhi1980@gmail.com)
+ *
+ * cAnimAudioView - promoted QWidget to display the animation curve extracted from
+ * the audio data and the audio settings
+ */
+
+#include "anim_audio_view.h"
+
+#include <QPainter>
+
+#include "src/audio_track.h"
+
+cAnimAudioView::cAnimAudioView(QWidget *parent) : QWidget(parent)
+{
+	playbackPositionX = 0;
+	framesPerSecond = 30.0;
+}
+
+cAnimAudioView::~cAnimAudioView() = default;
+
+void cAnimAudioView::UpdateChart(const QSharedPointer<cAudioTrack> audioTrack)
+{
+	if (audioTrack && audioTrack->isLoaded())
+	{
+		const int numberOfFrames = audioTrack->getNumberOfFrames();
+		framesPerSecond = audioTrack->getFramesPerSecond();
+		setFixedWidth(numberOfFrames);
+
+		animAudioImage = QImage(QSize(numberOfFrames, height()), QImage::Format_RGB32);
+		animAudioImage.fill(Qt::black);
+
+		QPainter painter(&animAudioImage);
+
+		const int maxY = height() - 1;
+		QPoint prevPoint(0, maxY);
+
+		painter.setPen(Qt::green);
+		painter.setRenderHint(QPainter::Antialiasing, true);
+
+		for (int frame = 0; frame < numberOfFrames; frame++)
+		{
+			const QPoint point(frame, maxY - audioTrack->getAnimation(frame) * maxY);
+			painter.drawLine(prevPoint, point);
+			prevPoint = point;
+		}
+		update();
+	}
+	else
+	{
+		animAudioImage = QImage();
+		update();
+	}
+}
+
+void cAnimAudioView::paintEvent(QPaintEvent *event)
+{
+	Q_UNUSED(event);
+	QPainter painter(this);
+	painter.drawImage(0, 0, animAudioImage);
+	const QPen pen(QColor(255, 255, 255, 128));
+
+	painter.setPen(pen);
+	painter.drawLine(playbackPositionX, 0, playbackPositionX, height() - 1);
+}
+
+void cAnimAudioView::positionChanged(qint64 position)
+{
+	const double time = position * 0.001;
+	playbackPositionX = time * framesPerSecond;
+	update();
+}
diff --git a/code/train/C++/0031969_diamond_manager.cpp b/code/train/C++/0031969_diamond_manager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ba97fa8740ff35d1f626f53811dea3ac958b9b4c
--- /dev/null
+++ b/code/train/C++/0031969_diamond_manager.cpp
@@ -0,0 +1,257 @@
+/*
+ * (C) 2007-2013 Alibaba Group Holding Limited
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ *
+ * Version: $Id: tair_mc_client_api.hpp 1245 2013-05-13 11:32:45Z huan.wanghuan@alibaba-inc.com $
+ *
+ * Authors:
+ *   yunhen <huan.wanghuan@alibaba-inc.com>
+ *
+ */
+
+#include "diamond_manager.hpp"
+
+#include <sys/types.h>
+#include <ifaddrs.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <sstream>
+
+namespace tair{
+
+   using std::string;
+
+   diamond_manager::diamond_manager(cluster_controller* a_controller)
+   {
+      listener = NULL;
+      config["diamond.invoke.timeout"] = "30";    // timeout，单位秒
+      config["diamond.polling.interval"] = "5000000"; // 轮询间隔，单位纳秒，5ms = 5*1000*1000ns
+//    容灾目录配置，默认是 ${HOME}/diamond
+//    config["diamond.localConfigDir"] = ...
+      diamond_client = new DIAMOND::DiamondClient(&config);
+      controller = a_controller;
+   }
+
+   diamond_manager::~diamond_manager()
+   {
+      if (diamond_client) {
+         delete diamond_client;
+         diamond_client = NULL;
+      }
+   }
+
+   void diamond_manager::set_net_device_name(const string& a_net_device_name) {
+      net_device_name = a_net_device_name;
+   }
+
+   bool diamond_manager::connect(const string& a_config_id, DIAMOND::SubscriberListener *a_listener)
+   {
+      listener = a_listener;
+      config_id = a_config_id;
+      rule_group_id = config_id + "-GROUP";
+
+      string md5;
+      string rule_group_content;
+      string error;
+      string bad_content("config data not exist");
+      if((!diamond_client->getConfig(config_id.c_str(), rule_group_id.c_str(), md5 ,rule_group_content, error))
+         || (rule_group_content.compare(0, bad_content.size(), bad_content) == 0))
+      {
+         TBSYS_LOG(ERROR, "can't get config info from the diamond dataId=%s, groupId=%s: %s",
+                   config_id.c_str(), rule_group_id.c_str(), error.c_str());
+         return false;
+      }
+      if (!update_data_group_id(rule_group_content))
+         return false;
+      if (listener)
+         diamond_client->registerListener(config_id.c_str(), rule_group_id.c_str(), listener, md5);
+      return true;
+   }
+
+   void diamond_manager::close()
+   {
+      diamond_client->shutdownListen();
+   }
+
+   const string& diamond_manager::get_config_id()
+   {
+      return config_id;
+   }
+
+   const string& diamond_manager::get_rule_group_id()
+   {
+      return rule_group_id;
+   }
+
+   const string& diamond_manager::get_data_group_id()
+   {
+      return data_group_id;
+   }
+
+   bool diamond_manager::update_data_group_id(const string& rule_group_content)
+   {
+      vector<string> rule_ip, rule_dest;
+      get_route_rule(rule_group_content, rule_ip, rule_dest);
+      vector<string> local_ip;
+      if (!get_local_ip(local_ip))
+      {
+         TBSYS_LOG(ERROR, "get local ip failed");
+         return false;
+      }
+      string new_data_group_id;
+      if (!search_data_group(local_ip, rule_ip, rule_dest, new_data_group_id))
+      {
+         TBSYS_LOG(ERROR, "get diamond data group id failed, you ip doesn't match any group rule");
+         return false;
+      }
+
+      if (new_data_group_id.empty())
+      {
+         TBSYS_LOG(ERROR, "get diamond data group id failed, you rule group config is invalid");
+         return false;
+      }
+      //rule group改变了，本机 对应的data group未变的话，直接返回
+      if (!(new_data_group_id != data_group_id))
+      {
+         TBSYS_LOG(INFO, "data group id doesn't change");
+         return true;
+      }
+
+      string md5, data_group_content, error;
+      string bad_content("config data not exist");
+      if ((!diamond_client->getConfig(config_id.c_str(), new_data_group_id.c_str(), md5, data_group_content, error))
+          || (data_group_content.compare(0, bad_content.size(), bad_content) == 0))
+      {
+         TBSYS_LOG(ERROR, "can't get config info from the diamond dataId=%s, groupId=%s: %s",
+                   config_id.c_str(), new_data_group_id.c_str(), error.c_str());
+         return false;
+      }
+         
+      if (!update_config(data_group_content))
+      {
+         TBSYS_LOG(ERROR, "using config info of diamond dataId=%s, groupId=%s to update tair configserver failed",
+                   config_id.c_str(), new_data_group_id.c_str());
+         return false;
+      }
+
+      if (listener)
+      {
+         if(!data_group_id.empty())
+            diamond_client->removeListener(config_id.c_str(), data_group_id.c_str());
+         diamond_client->registerListener(config_id.c_str(), new_data_group_id.c_str(), listener, md5);
+      }
+      
+      data_group_id = new_data_group_id;
+
+      return true;
+   }
+
+   bool diamond_manager::update_config(const string& json)
+   {
+      if (!controller)
+      {
+         TBSYS_LOG(ERROR, "cluster_controller == NULL");
+         return false;
+      }
+      return controller->update_config(json);
+   }
+
+   void diamond_manager::get_route_rule(const string& group_rule, vector<string>& rule_ip, vector<string>& rule_dest)
+   {
+      istringstream group_rule_in(group_rule);
+      while(true)
+      {
+         string one_line;
+         if (!getline(group_rule_in, one_line))
+            break;
+         
+         string::size_type pos = one_line.find_first_of('=');
+         if (string::npos == pos)
+            continue;
+
+         string ip(one_line, 0, pos);
+         string dest(one_line, pos + 1);
+         
+         string::size_type begin_ip = ip.find_first_not_of(" \r\t");
+         if (string::npos == begin_ip)
+            continue;
+         string::size_type end_ip = ip.find_last_not_of(" \r\t");
+
+         
+         string::size_type begin_dest = dest.find_first_not_of(" \r\t");
+         if (string::npos == begin_dest)
+            continue;
+         string::size_type end_dest = dest.find_last_not_of(" \r\t");
+         
+         rule_ip.push_back(ip.substr(begin_ip, end_ip - begin_ip + 1));
+         rule_dest.push_back(dest.substr(begin_dest, end_dest - begin_dest + 1));
+      }
+   }
+
+   bool diamond_manager::get_local_ip(vector<string>& ip)
+   {
+      struct ifaddrs *ifaddr, *ifa;
+      int family, s;
+      char host[NI_MAXHOST];
+
+      if (getifaddrs(&ifaddr) == -1)
+         return false;
+      /* Walk through linked list, maintaining head pointer so we
+         can free list later */
+      for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next)
+      {
+         if (!ifa->ifa_addr)
+            continue;
+         family = ifa->ifa_addr->sa_family;
+         if (family == AF_INET && strcmp(ifa->ifa_name, "lo") != 0)
+         {
+            s = getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
+            if (s)
+               continue;
+            //若设置了net_device_name, 只取net_device_name对应的ip; 否则取所有ipv4的ip（回环除外）
+            if (net_device_name.empty())
+               ip.push_back(host);
+            else
+            {
+               if(ifa->ifa_name == net_device_name)
+               {
+                  ip.push_back(host);
+                  break;
+               }
+            }
+         }
+      } // end of for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next)
+      freeifaddrs(ifaddr);
+      return true;
+   }
+
+   // 对于多个本地ip，若与分组规则都有匹配，选匹配分组最靠前的。
+   // 例如，ipA 匹配了 第1个分组，ipB 匹配了 第4个分组，则选择 第1个分组规则。
+   bool diamond_manager::search_data_group(const vector<string>& local_ip, const vector<string>& rule_ip,
+                                           const vector<string>& rule_dest, string& data_group_id)
+   {
+      vector<string>::size_type min = rule_ip.size();
+      for (vector<string>::const_iterator ip_iter = local_ip.begin(); ip_iter != local_ip.end(); ++ip_iter)
+      {
+         vector<string>::size_type number = 0;
+         for(vector<string>::const_iterator rule_ip_iter = rule_ip.begin(); rule_ip_iter != rule_ip.end(); ++rule_ip_iter)
+         {
+            if (ip_iter->compare(0, rule_ip_iter->size(), *rule_ip_iter) == 0)
+            {
+               if (number < min)
+                  min = number;
+               break;
+            }
+            ++number;
+         }
+      }// end of for (vector<string>::const_iterator ip_iter; ip_iter != local_ip.end(); ++ip_iter)
+      if (rule_ip.size() == min)
+         return false;
+      data_group_id = rule_dest[min];
+      return true;
+   }
+}
diff --git a/code/train/C++/0032568_governancepage.cpp b/code/train/C++/0032568_governancepage.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..61156f5077b2b5765fd0919a17382da39a4d472c
--- /dev/null
+++ b/code/train/C++/0032568_governancepage.cpp
@@ -0,0 +1,148 @@
+// Copyright (c) 2018-2019 The NPCcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "governancepage.h"
+#include "ui_governancepage.h"
+
+#include "activemasternode.h"
+#include "chainparams.h"
+#include "clientmodel.h"
+#include "masternode-budget.h"
+#include "masternode-sync.h"
+#include "masternodeconfig.h"
+#include "masternodeman.h"
+#include "utilmoneystr.h"
+#include "walletmodel.h"
+#include "askpassphrasedialog.h"
+#include "proposalframe.h"
+
+#include <QMessageBox>
+#include <QString>
+#include <QTimer>
+#include <QToolButton>
+
+GovernancePage::GovernancePage(QWidget* parent) : QWidget(parent),
+                                                  ui(new Ui::GovernancePage),
+                                                  clientModel(0),
+                                                  walletModel(0)
+{
+    ui->setupUi(this);
+
+    timer = new QTimer(this);
+    connect(timer, SIGNAL(timeout()), this, SLOT(updateProposalList()));
+    timer->start(100000);
+    fLockUpdating = false;
+}
+
+
+GovernancePage::~GovernancePage()
+{
+    delete ui;
+}
+
+void GovernancePage::setClientModel(ClientModel* model)
+{
+    this->clientModel = model;
+}
+
+void GovernancePage::setWalletModel(WalletModel* model)
+{
+    this->walletModel = model;
+}
+
+void GovernancePage::lockUpdating(bool lock)
+{
+    fLockUpdating = lock;
+}
+
+struct sortProposalsByVotes
+{
+    bool operator() (const CBudgetProposal* left, const CBudgetProposal* right)
+    {
+        if (left != right)
+            return (left->GetYeas() - left->GetNays() > right->GetYeas() - right->GetNays());
+        return (left->nFeeTXHash > right->nFeeTXHash);
+    }
+};
+
+void GovernancePage::updateProposalList()
+{
+    if (fLockUpdating) return;
+
+    QLayoutItem* child;
+    while ((child = ui->proposalGrid->takeAt(0)) != 0) {
+        if (child->widget() != 0)
+        {
+            delete child->widget();
+        }
+        delete child;
+    }
+
+    std::vector<CBudgetProposal*> allotedProposals = budget.GetBudget();
+    CAmount nTotalAllotted = 0;
+    std::vector<CBudgetProposal*> proposalsList = budget.GetAllProposals();
+    std::sort (proposalsList.begin(), proposalsList.end(), sortProposalsByVotes());
+    int nRow = 0;
+    CBlockIndex* pindexPrev;
+    {
+        LOCK(cs_main);
+        pindexPrev = chainActive.Tip();
+    }
+    if (!pindexPrev) return;
+    int nBlockStart = pindexPrev->nHeight - pindexPrev->nHeight % Params().GetBudgetCycleBlocks() + Params().GetBudgetCycleBlocks();
+    int nBlocksLeft = nBlockStart - pindexPrev->nHeight;
+    int nBlockEnd = nBlockStart + Params().GetBudgetCycleBlocks() - 1;
+    int mnCount = mnodeman.CountEnabled(ActiveProtocol());
+
+    for (CBudgetProposal* pbudgetProposal : proposalsList) {
+        if (!pbudgetProposal->fValid) continue;
+        if (pbudgetProposal->GetRemainingPaymentCount() < 1) continue;
+
+        ProposalFrame* proposalFrame = new ProposalFrame();
+        proposalFrame->setWalletModel(walletModel);
+        proposalFrame->setProposal(pbudgetProposal);
+        proposalFrame->setGovernancePage(this);
+
+        if (std::find(allotedProposals.begin(), allotedProposals.end(), pbudgetProposal) != allotedProposals.end()) {
+            nTotalAllotted += pbudgetProposal->GetAllotted();
+            proposalFrame->setObjectName(QStringLiteral("proposalFramePassing"));
+        } else if (!pbudgetProposal->IsEstablished()) {
+            proposalFrame->setObjectName(QStringLiteral("proposalFrameNotEstablished"));
+        } else if (pbudgetProposal->IsPassing(pindexPrev, nBlockStart, nBlockEnd, mnCount)) {
+            proposalFrame->setObjectName(QStringLiteral("proposalFramePassingUnfunded"));
+        } else {
+            proposalFrame->setObjectName(QStringLiteral("proposalFrame"));
+        }
+        proposalFrame->setFrameShape(QFrame::StyledPanel);
+
+        if (extendedProposal == pbudgetProposal)
+            proposalFrame->extend();
+        proposalFrame->setMaximumHeight(150);
+        ui->proposalGrid->addWidget(proposalFrame, nRow);
+
+        ++nRow;
+    }
+
+    ui->next_superblock_value->setText(QString::number(nBlockStart));
+    ui->blocks_before_super_value->setText(QString::number(nBlocksLeft));
+    ui->time_before_super_value->setText(QString::number(nBlocksLeft/60/24));
+    ui->alloted_budget_value->setText(QString::number(nTotalAllotted/COIN));
+    ui->unallocated_budget_value->setText(QString::number((budget.GetTotalBudget(pindexPrev->nHeight) - nTotalAllotted)/COIN));
+    ui->masternode_count_value->setText(QString::number(mnodeman.CountEnabled(ActiveProtocol())));
+}
+
+void GovernancePage::setExtendedProposal(CBudgetProposal* proposal)
+{
+    bool update = false;
+    if (extendedProposal != proposal)
+        update = true;
+    extendedProposal = proposal;
+    if (update)
+        updateProposalList();
+}
+
+void GovernancePage::on_UpdateButton_clicked()
+{
+    updateProposalList();
+}
diff --git a/code/train/C++/0032966_workload-stat.cpp b/code/train/C++/0032966_workload-stat.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9c20ae1aea05fbfdd8d108b44aeccc127e4dc02f
--- /dev/null
+++ b/code/train/C++/0032966_workload-stat.cpp
@@ -0,0 +1,114 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <limits.h>
+
+#include <vector>
+#include <algorithm>
+#include <unordered_map>
+
+#define SCALE_FACTOR 100
+
+#include "workload.h"
+
+bool histogram = true;
+
+int main(int argc, char *argv[])
+{
+	if (argc < 2) {
+		fprintf(stderr, "stat file\n");
+		exit(1);
+	}
+
+	char *name = argv[1];
+	int fd = open(name, O_RDONLY);
+	if (fd < 0) {
+		perror("open");
+		exit(1);
+	}
+
+	/* get the file size */
+	struct stat stats;
+	if (fstat(fd, &stats) < 0) {
+		perror("fstat");
+		exit(1);
+	}
+	long file_size = stats.st_size;
+
+	/* the numbers of accesses of each page */
+	int num_accesses = (int) (file_size / sizeof(workload_t));
+	workload_t *workloads = new workload_t[num_accesses];
+	read(fd, (void *) workloads, file_size);
+
+	std::unordered_map<off_t, int> page_map;
+	int num_page_reads = 0;
+	int num_page_writes = 0;
+	int num_reads = 0;
+	int num_writes = 0;
+	size_t read_size = 0;
+	size_t write_size = 0;
+	int max_size = 0;
+	int min_size = INT_MAX;
+	long tot_size = 0;
+	off_t min_off = LONG_MAX;
+	off_t max_off = 0;
+	for (int i = 0; i < num_accesses; i++) {
+		if (min_off > workloads[i].off)
+			min_off = workloads[i].off;
+		if (max_off < workloads[i].off)
+			max_off = workloads[i].off;
+		off_t page_off = ROUND_PAGE(workloads[i].off);
+		if (max_size < workloads[i].size)
+			max_size = workloads[i].size;
+		if (min_size > workloads[i].size)
+			min_size = workloads[i].size;
+		tot_size += workloads[i].size;
+		off_t last_page = ROUNDUP_PAGE(workloads[i].off + workloads[i].size);
+		int num_pages = (last_page - page_off) / safs::PAGE_SIZE;
+		for (; page_off < last_page; page_off += safs::PAGE_SIZE) {
+			std::unordered_map<off_t, int>::iterator it = page_map.find(page_off);
+			if (it == page_map.end()) {
+				page_map.insert(std::pair<off_t, int>(page_off, 1));
+			}
+			else
+				it->second++;
+		}
+		if (workloads[i].read) {
+			num_page_reads += num_pages;
+			num_reads++;
+			read_size += workloads[i].size;
+		}
+		else {
+			num_page_writes += num_pages;
+			num_writes++;
+			write_size += workloads[i].size;
+		}
+	}
+
+	if (histogram) {
+		std::map<int, int> count_nums;
+		for (std::unordered_map<off_t, int>::iterator it = page_map.begin();
+				it != page_map.end(); it++) {
+			int num_accesses = it->second;
+			std::map<int, int>::iterator it1 = count_nums.find(num_accesses);
+			if (it1 != count_nums.end())
+				it1->second++;
+			else
+				count_nums.insert(std::pair<int, int>(num_accesses, 1));
+		}
+		for (std::map<int, int>::const_iterator it = count_nums.begin();
+				it != count_nums.end(); it++) {
+			printf("%d pages get %d hits\n", it->second, it->first);
+		}
+	}
+	printf("min request size: %d, max req size: %d, avg size: %ld\n",
+			min_size, max_size, tot_size / num_accesses);
+	printf("min off: %ld, max off: %ld\n", min_off, max_off);
+	printf("there are %d accesses\n", num_accesses);
+	printf("there are %d reads and %d writes\n", num_reads, num_writes);
+	printf("there are %d reads in pages, %d writes in pages\n",
+			num_page_reads, num_page_writes);
+	printf("read %ld in bytes and write %ld in bytes\n", read_size, write_size);
+	printf("there are %ld accessed pages\n", page_map.size());
+}
diff --git a/code/train/C++/0032990_3-longest-substring-without-repeating-characters.cpp b/code/train/C++/0032990_3-longest-substring-without-repeating-characters.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d3e0de2e51cbe7f27f4da8a182eff08f1cf1ca18
--- /dev/null
+++ b/code/train/C++/0032990_3-longest-substring-without-repeating-characters.cpp
@@ -0,0 +1,66 @@
+#include<iostream>
+#include<vector>
+
+using namespace std;
+/*
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+        int max_length = 0;
+        int length = 0;
+        int pos = 0;
+		vector<int> set;
+        set.reserve(256); // note, input source like " " so reserve 2^8 for char
+        for (int i = 0; i < s.length(); i++) {
+            int idxInSet = char2int(s[i]);
+            while (pos < i && set[idxInSet] == 1) {
+                int delIdx = char2int(s[pos]);
+                set[delIdx] = 0;
+                length -= 1;
+                pos += 1;
+            }
+            set[idxInSet] = 1;
+            length += 1;
+            if (length > max_length) {
+                max_length = length;
+            }
+
+        }
+		return max_length;
+    }
+
+    int char2int(char ch) {
+        return int(ch);
+    }
+    
+};
+
+*/
+
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+        if (s.size() == 0) return 0;
+        int res = 0;
+        int counter[256] = {0};
+        int start_idx = 0;
+        for (int i = 0; i < s.size(); i++) {
+            while(counter[s[i]] != 0 && start_idx < i) {
+                counter[s[start_idx]] -= 1;
+                start_idx += 1;
+            }
+            counter[s[i]] += 1;
+            res = max(res, i - start_idx + 1);
+        }
+        return res;
+    }
+};
+
+int main() {
+    Solution s;
+    cout << s.char2int('a') << endl;
+    cout << s.lengthOfLongestSubstring("abcabcbb") << endl;
+    cout << s.lengthOfLongestSubstring("bbbbb") << endl;
+    cout << s.lengthOfLongestSubstring("pwwkew") << endl;
+    return 0;
+}
diff --git a/code/train/C++/0033091_Logger.cpp b/code/train/C++/0033091_Logger.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ebfd09d56e3424933aaef95f97f992496fbc08ae
--- /dev/null
+++ b/code/train/C++/0033091_Logger.cpp
@@ -0,0 +1,258 @@
+/*
+  Copyright_License {
+
+  XCSoar Glide Computer - http://www.xcsoar.org/
+  Copyright (C) 2000-2016 The XCSoar Project
+  A detailed list of copyright holders can be found in the file "AUTHORS".
+
+  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.
+}
+*/
+
+#include "Internal.hpp"
+#include "NanoLogger.hpp"
+#include "Protocol.hpp"
+#include "Convert.hpp"
+#include "Device/Port/Port.hpp"
+#include "Device/RecordedFlight.hpp"
+#include "Operation/Operation.hpp"
+#include "OS/ByteOrder.hpp"
+#include "OS/Path.hpp"
+#include "IO/BufferedOutputStream.hxx"
+#include "IO/FileOutputStream.hxx"
+#include "Util/ScopeExit.hxx"
+
+#include <memory>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static bool
+ParseDate(BrokenDate &date, const char *p)
+{
+  char *endptr;
+  unsigned long l = strtoul(p, &endptr, 10);
+  if (l < 1 || l > 31 || *endptr != '.')
+    return false;
+
+  date.day = l;
+
+  p = endptr + 1;
+  l = strtoul(p, &endptr, 10);
+  if (l < 1 || l > 12 || *endptr != '.')
+    return false;
+
+  date.month = l;
+
+  p = endptr + 1;
+  l = strtoul(p, &endptr, 10);
+  if (l >= 100 || *endptr != 0)
+    return false;
+
+  date.year = 2000 + l; // Y2100 problem
+  return true;
+}
+
+static bool
+ParseTime(BrokenTime &time, const char *p)
+{
+  char *endptr;
+  unsigned long l = strtoul(p, &endptr, 10);
+  if (l >= 24 || *endptr != ':')
+    return false;
+
+  time.hour = l;
+
+  p = endptr + 1;
+  l = strtoul(p, &endptr, 10);
+  if (l >= 60 || *endptr != ':')
+    return false;
+
+  time.minute = l;
+
+  p = endptr + 1;
+  l = strtoul(p, &endptr, 10);
+  if (l >= 60 || *endptr != 0)
+    return false;
+
+  time.second = l;
+  return true;
+}
+
+static bool
+Copy(RecordedFlightInfo &dest, const LX::FlightInfo &src)
+{
+  if (!ParseDate(dest.date, src.date) ||
+      !ParseTime(dest.start_time, src.start_time) ||
+      !ParseTime(dest.end_time, src.stop_time))
+    return false;
+
+  /* not a Nano recording */
+  dest.internal.lx.nano_filename[0] = 0;
+
+  dest.internal.lx.start_address[0] = src.start_address.address0;
+  dest.internal.lx.start_address[1] = src.start_address.address1;
+  dest.internal.lx.start_address[2] = src.start_address.address2;
+  dest.internal.lx.end_address[0] = src.end_address.address0;
+  dest.internal.lx.end_address[1] = src.end_address.address1;
+  dest.internal.lx.end_address[2] = src.end_address.address2;
+
+  return true;
+}
+
+static bool
+ReadFlightListInner(Port &port, RecordedFlightList &flight_list,
+                    OperationEnvironment &env)
+{
+  if (!LX::CommandMode(port, env))
+    return false;
+
+  port.Flush();
+  if (!LX::SendCommand(port, LX::READ_FLIGHT_LIST))
+    return false;
+
+  bool success = false;
+  while (!flight_list.full()) {
+    LX::FlightInfo flight;
+    if (!LX::ReadCRC(port, &flight, sizeof(flight), env,
+                     std::chrono::seconds(20),
+                     std::chrono::seconds(2),
+                     std::chrono::minutes(3)))
+      break;
+
+    success = true;
+    if (!flight.IsValid())
+      break;
+
+    RecordedFlightInfo dest;
+    if (Copy(dest, flight))
+      flight_list.append(dest);
+  }
+
+  return success;
+}
+
+bool
+LXDevice::ReadFlightList(RecordedFlightList &flight_list,
+                         OperationEnvironment &env)
+{
+  if (IsNano()) {
+    if (!EnableNanoNMEA(env))
+      return false;
+
+    assert(!busy);
+    busy = true;
+    AtScopeExit(this) { busy = false; };
+
+    return Nano::ReadFlightList(port, flight_list, env);
+  }
+
+  if (!EnableCommandMode(env))
+    return false;
+
+  assert(!busy);
+  busy = true;
+  AtScopeExit(this) { busy = false; };
+
+  bool success = ReadFlightListInner(port, flight_list, env);
+
+  LX::CommandModeQuick(port, env);
+  return success;
+}
+
+static bool
+DownloadFlightInner(Port &port, const RecordedFlightInfo &flight,
+                    BufferedOutputStream &os, OperationEnvironment &env)
+{
+  if (!LX::CommandMode(port, env))
+    return false;
+
+  port.Flush();
+
+  LX::SeekMemory seek;
+  seek.start_address = flight.internal.lx.start_address;
+  seek.end_address = flight.internal.lx.end_address;
+  if (!LX::SendPacket(port, LX::SEEK_MEMORY, &seek, sizeof(seek), env) ||
+      !LX::ExpectACK(port, env))
+      return false;
+
+  LX::MemorySection memory_section;
+  if (!LX::ReceivePacketRetry(port, LX::READ_MEMORY_SECTION,
+                              &memory_section, sizeof(memory_section), env,
+                              std::chrono::seconds(5),
+                              std::chrono::seconds(2),
+                              std::chrono::minutes(1), 2))
+      return false;
+
+  unsigned lengths[LX::MemorySection::N];
+  unsigned total_length = 0;
+  for (unsigned i = 0; i < LX::MemorySection::N; ++i) {
+    lengths[i] = FromBE16(memory_section.lengths[i]);
+    total_length += lengths[i];
+  }
+
+  env.SetProgressRange(total_length);
+
+  const auto data = std::make_unique<uint8_t[]>(total_length);
+  uint8_t *p = data.get();
+  for (unsigned i = 0; i < LX::MemorySection::N && lengths[i] > 0; ++i) {
+    if (!LX::ReceivePacketRetry(port, (LX::Command)(LX::READ_LOGGER_DATA + i),
+                                p, lengths[i], env,
+                                std::chrono::seconds(20),
+                                std::chrono::seconds(2),
+                                std::chrono::minutes(5), 2)) {
+      return false;
+    }
+
+    p += lengths[i];
+    env.SetProgressPosition(p - data.get());
+  }
+
+  return LX::ConvertLXNToIGC(data.get(), total_length, os);
+}
+
+bool
+LXDevice::DownloadFlight(const RecordedFlightInfo &flight,
+                         Path path,
+                         OperationEnvironment &env)
+{
+  if (flight.internal.lx.nano_filename[0] != 0) {
+    assert(!busy);
+    busy = true;
+    AtScopeExit(this) { busy = false; };
+
+    return Nano::DownloadFlight(port, flight, path, env);
+  }
+
+  if (!EnableCommandMode(env))
+    return false;
+
+  FileOutputStream fos(path);
+  BufferedOutputStream bos(fos);
+
+  assert(!busy);
+  busy = true;
+  AtScopeExit(this) { busy = false; };
+
+  bool success = DownloadFlightInner(port, flight, bos, env);
+
+  if (success) {
+    bos.Flush();
+    fos.Commit();
+  }
+
+  LX::CommandModeQuick(port, env);
+  return success;
+}
diff --git a/code/train/C++/0033274_GeometryClamper.cpp b/code/train/C++/0033274_GeometryClamper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..686a434ee040425c7072e09fd4fec8ec90ba39bc
--- /dev/null
+++ b/code/train/C++/0033274_GeometryClamper.cpp
@@ -0,0 +1,198 @@
+/* -*-c++-*- */
+/* osgEarth - Dynamic map generation toolkit for OpenSceneGraph
+ * Copyright 2016 Pelican Mapping
+ * http://osgearth.org
+ *
+ * osgEarth 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 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 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 <osgEarth/GeometryClamper>
+
+#include <osgUtil/IntersectionVisitor>
+
+#include <osg/Geode>
+#include <osg/Geometry>
+#include <osg/UserDataContainer>
+
+#define LC "[GeometryClamper] "
+
+using namespace osgEarth;
+
+#define ZOFFSETS_NAME "GeometryClamper::zOffsets"
+
+//-----------------------------------------------------------------------
+
+GeometryClamper::GeometryClamper() :
+osg::NodeVisitor( osg::NodeVisitor::TRAVERSE_ALL_CHILDREN ),
+_preserveZ      ( false ),
+_scale          ( 1.0f ),
+_offset         ( 0.0f )
+{
+    this->setNodeMaskOverride( ~0 );
+    _lsi = new osgEarth::DPLineSegmentIntersector(osg::Vec3d(0,0,0), osg::Vec3d(0,0,0));
+}
+
+void
+GeometryClamper::apply(osg::Transform& xform)
+{
+    osg::Matrixd matrix;
+    if ( !_matrixStack.empty() ) matrix = _matrixStack.back();
+    xform.computeLocalToWorldMatrix( matrix, this );
+    _matrixStack.push_back( matrix );
+    traverse(xform);
+    _matrixStack.pop_back();
+}
+
+void
+GeometryClamper::apply(osg::Geode& geode)
+{
+    if ( !_terrainSRS.valid() )
+        return;
+
+    const osg::Matrixd& local2world = _matrixStack.back();
+    osg::Matrix world2local;
+    world2local.invert( local2world );
+
+    const osg::EllipsoidModel* em = _terrainSRS->getEllipsoid();
+    osg::Vec3d n_vector(0,0,1), start, end, msl;
+
+    bool isGeocentric = _terrainSRS->isGeographic();
+
+    osgUtil::IntersectionVisitor iv( _lsi.get() );
+
+    double r = std::min( em->getRadiusEquator(), em->getRadiusPolar() );
+
+    unsigned count = 0;
+
+    for( unsigned i=0; i<geode.getNumDrawables(); ++i )
+    {
+        bool geomDirty = false;
+        osg::Geometry* geom = geode.getDrawable(i)->asGeometry();
+        if ( geom )
+        {
+            osg::Vec3Array*  verts = static_cast<osg::Vec3Array*>(geom->getVertexArray());
+            osg::FloatArray* zOffsets = 0L;
+
+            // if preserve-Z is on, check for our elevations array. Create it if is doesn't
+            // already exist.
+            bool buildZOffsets = false;
+            if ( _preserveZ )
+            {
+                osg::UserDataContainer* udc = geom->getOrCreateUserDataContainer();
+                unsigned n = udc->getUserObjectIndex( ZOFFSETS_NAME );
+                if ( n < udc->getNumUserObjects() )
+                {
+                    zOffsets = dynamic_cast<osg::FloatArray*>(udc->getUserObject(n));
+                }
+
+                else
+                {
+                    zOffsets = new osg::FloatArray();
+                    zOffsets->setName( ZOFFSETS_NAME );
+                    zOffsets->reserve( verts->size() );
+                    udc->addUserObject( zOffsets );
+                    buildZOffsets = true;
+                }
+            }
+
+            for( unsigned k=0; k<verts->size(); ++k )
+            {
+                osg::Vec3d vw = (*verts)[k];
+                vw = vw * local2world;
+
+                if ( isGeocentric )
+                {
+                    // normal to the ellipsoid:
+                    n_vector = em->computeLocalUpVector(vw.x(),vw.y(),vw.z());
+
+                    // if we need to build to z-offsets array, calculate the z offset now:
+                    if ( buildZOffsets || _scale != 1.0 )
+                    {
+                        double lat,lon,hae;
+                        em->convertXYZToLatLongHeight(vw.x(), vw.y(), vw.z(), lat, lon, hae);
+
+                        if ( buildZOffsets )
+                        {
+                            zOffsets->push_back( (*verts)[k].z() );
+                        }
+
+                        if ( _scale != 1.0 )
+                        {
+                            msl = vw - n_vector*hae;
+                        }
+                    }
+                }
+
+                else if ( buildZOffsets ) // flat map
+                {
+                    zOffsets->push_back( float(vw.z()) );
+                }
+
+                _lsi->reset();
+                _lsi->setStart( vw + n_vector*r*_scale );
+                _lsi->setEnd( vw - n_vector*r );
+                _lsi->setIntersectionLimit( _lsi->LIMIT_NEAREST );
+
+                _terrainPatch->accept( iv );
+
+                if ( _lsi->containsIntersections() )
+                {
+                    osg::Vec3d fw = _lsi->getFirstIntersection().getWorldIntersectPoint();
+                    if ( _scale != 1.0 )
+                    {
+                        osg::Vec3d delta = fw - msl;
+                        fw += delta*_scale;
+                    }
+                    if ( _offset != 0.0 )
+                    {
+                        fw += n_vector*_offset;
+                    }
+                    if ( _preserveZ && (zOffsets != 0L) )
+                    {
+                        fw += n_vector * (*zOffsets)[k];
+                    }
+
+                    (*verts)[k] = (fw * world2local);
+                    geomDirty = true;
+                    ++count;
+                }
+            }
+
+            if ( geomDirty )
+            {
+                geom->dirtyBound();
+                if ( geom->getUseVertexBufferObjects() )
+                {
+                    verts->getVertexBufferObject()->setUsage( GL_DYNAMIC_DRAW_ARB );
+                    verts->dirty();
+                }
+                else
+                {
+                    geom->dirtyDisplayList();
+                }
+            }
+        }
+
+        OE_DEBUG << LC << "clamped " << count << " verts." << std::endl;
+    }
+}
+
+
+
+void
+GeometryClamperCallback::onTileAdded(const TileKey&          key, 
+                                     osg::Node*              tile, 
+                                     TerrainCallbackContext& context)
+{
+    tile->accept( _clamper );
+}
diff --git a/code/train/C++/0035216_raycast.cpp b/code/train/C++/0035216_raycast.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..78d7df683114a01f1274018d21ef54405bcbd5e8
--- /dev/null
+++ b/code/train/C++/0035216_raycast.cpp
@@ -0,0 +1,200 @@
+/*
+	This file is part of Warzone 2100.
+	Copyright (C) 1999-2004  Eidos Interactive
+	Copyright (C) 2005-2013  Warzone 2100 Project
+
+	Warzone 2100 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.
+
+	Warzone 2100 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 Warzone 2100; if not, write to the Free Software
+	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+/**
+ * @file raycast.cpp
+ *
+ * Raycasting routine that gives intersection points with map tiles.
+ *
+ */
+
+#include "lib/framework/frame.h"
+
+#include "raycast.h"
+#include "map.h" // TILE_UNITS
+#include "display3d.h" // clipXY()
+
+struct HeightCallbackHelp_t
+{
+	const int height;
+	uint16_t pitch;
+};
+
+static void initSteps(int32_t srcM, int32_t dstM, int32_t &tile, int32_t &step, int32_t &cur, int32_t &end)
+{
+	int increasing = srcM < dstM;
+	step = -1 + 2*increasing;
+	tile = srcM - step;
+	cur = srcM + increasing;
+	end = dstM + increasing;
+}
+
+// Finds the next intersection of the line with a vertical grid line (or with a horizontal grid line, if called with x and y swapped).
+static bool tryStep(int32_t &tile, int32_t step, int32_t &cur, int32_t end, int32_t &px, int32_t &py, int32_t sx, int32_t sy, int32_t dx, int32_t dy)
+{
+	tile += step;
+
+	if (cur == end)
+	{
+		return false;  // No more vertical grid lines to cross before reaching the endpoint.
+	}
+
+	// Find the point on the line with the x coordinate world_coord(cur).
+	px = world_coord(cur);
+	py = sy + int64_t(px - sx) * (dy - sy)/(dx - sx);
+
+	cur += step;
+	return true;
+}
+
+void rayCast(Vector2i src, Vector2i dst, RAY_CALLBACK callback, void *data)
+{
+	if (!callback(src, 0, data) || src == dst)  // Start at src.
+	{
+		return;  // Callback gave up after the first point, or there are no other points.
+	}
+
+	Vector2i srcM = map_coord(src);
+	Vector2i dstM = map_coord(dst);
+
+	Vector2i step, tile, cur, end;
+	initSteps(srcM.x, dstM.x, tile.x, step.x, cur.x, end.x);
+	initSteps(srcM.y, dstM.y, tile.y, step.y, cur.y, end.y);
+
+	Vector2i prev(0, 0);  // Dummy initialisation.
+	bool first = true;
+	Vector2i nextX(0, 0), nextY(0, 0);  // Dummy initialisations.
+	bool canX = tryStep(tile.x, step.x, cur.x, end.x, nextX.x, nextX.y, src.x, src.y, dst.x, dst.y);
+	bool canY = tryStep(tile.y, step.y, cur.y, end.y, nextY.y, nextY.x, src.y, src.x, dst.y, dst.x);
+	while (canX || canY)
+	{
+		int32_t xDist = abs(nextX.x - src.x) + abs(nextX.y - src.y);
+		int32_t yDist = abs(nextY.x - src.x) + abs(nextY.y - src.y);
+		Vector2i sel;
+		Vector2i selTile;
+		if (canX && (!canY || xDist < yDist))  // The line crosses a vertical grid line next.
+		{
+			sel = nextX;
+			selTile = tile;
+			canX = tryStep(tile.x, step.x, cur.x, end.x, nextX.x, nextX.y, src.x, src.y, dst.x, dst.y);
+		}
+		else  // The line crosses a horizontal grid line next.
+		{
+			assert(canY);
+			sel = nextY;
+			selTile = tile;
+			canY = tryStep(tile.y, step.y, cur.y, end.y, nextY.y, nextY.x, src.y, src.x, dst.y, dst.x);
+		}
+		if (!first)
+		{
+			// Find midpoint.
+			Vector2i avg = (prev + sel)/2;
+			// But make sure it's on the right tile, since it could be off-by-one if the line passes exactly through a grid intersection.
+			avg.x = std::min(std::max(avg.x, world_coord(selTile.x)), world_coord(selTile.x + 1) - 1);
+			avg.y = std::min(std::max(avg.y, world_coord(selTile.y)), world_coord(selTile.y + 1) - 1);
+			if (!worldOnMap(avg) || !callback(avg, iHypot(avg), data))
+			{
+				return;  // Callback doesn't want any more points, or we reached the edge of the map, so return.
+			}
+		}
+		prev = sel;
+		first = false;
+	}
+
+	// Include the endpoint.
+	if (!worldOnMap(dst))
+	{
+		return;  // Stop, since reached the edge of the map.
+	}
+	callback(dst, iHypot(dst), data);
+}
+
+//-----------------------------------------------------------------------------------
+/* Will return false when we've hit the edge of the grid */
+static bool getTileHeightCallback(Vector2i pos, int32_t dist, void *data)
+{
+	HeightCallbackHelp_t *help = (HeightCallbackHelp_t *)data;
+#ifdef TEST_RAY
+	Vector3i effect;
+#endif
+
+	/* Are we still on the grid? */
+	if (clipXY(pos.x, pos.y))
+	{
+		bool HasTallStructure = blockTile(map_coord(pos.x), map_coord(pos.y), AUX_MAP) & AIR_BLOCKED;
+
+		if (dist > TILE_UNITS || HasTallStructure)
+		{
+			// Only do it the current tile is > TILE_UNITS away from the starting tile. Or..
+			// there is a tall structure  on the current tile and the current tile is not the starting tile.
+			/* Get height at this intersection point */
+			int height = map_Height(pos.x, pos.y), heightDiff;
+			uint16_t newPitch;
+
+			if (HasTallStructure)
+			{
+				height += TALLOBJECT_ADJUST;
+			}
+
+			if (height <= help->height)
+			{
+				heightDiff = 0;
+			}
+			else
+			{
+				heightDiff = height - help->height;
+			}
+
+			/* Work out the angle to this point from start point */
+			newPitch = iAtan2(heightDiff, dist);
+
+			/* Is this the steepest we've found? */
+			if (angleDelta(newPitch - help->pitch) > 0)
+			{
+				/* Yes, then keep a record of it */
+				help->pitch = newPitch;
+			}
+			//---
+
+#ifdef TEST_RAY
+			effect.x = pos.x;
+			effect.y = height;
+			effect.z = pos.y;
+			addEffect(&effect, EFFECT_EXPLOSION, EXPLOSION_TYPE_SMALL, false, NULL, 0);
+#endif
+		}
+
+		/* Not at edge yet - so exit */
+		return true;
+	}
+
+	/* We've hit edge of grid - so exit!! */
+	return false;
+}
+
+void getBestPitchToEdgeOfGrid(UDWORD x, UDWORD y, uint16_t direction, uint16_t *pitch)
+{
+	HeightCallbackHelp_t help = {map_Height(x,y), 0};
+
+	Vector3i src(x, y, 0);
+	Vector3i delta(iSinCosR(direction, 5430), 0);
+	rayCast(src, src + delta, getTileHeightCallback, &help); // FIXME Magic value
+
+	*pitch = help.pitch;
+}
diff --git a/code/train/C++/0035891_stickman.cpp b/code/train/C++/0035891_stickman.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aa6838d4364927d4aed578de93c160f19cbdd65b
--- /dev/null
+++ b/code/train/C++/0035891_stickman.cpp
@@ -0,0 +1,337 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** 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 Digia Plc and its Subsidiary(-ies) 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 "stickman.h"
+#include "node.h"
+
+#include <QPainter>
+#include <QTimer>
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+static const qreal Coords[NodeCount * 2] = {
+    0.0, -150.0, // head, #0
+
+    0.0, -100.0, // body pentagon, top->bottom, left->right, #1 - 5
+    -50.0, -50.0,
+    50.0, -50.0,
+    -25.0, 50.0,
+    25.0, 50.0,
+
+    -100.0, 0.0, // right arm, #6 - 7
+    -125.0, 50.0,
+
+    100.0, 0.0, // left arm, #8 - 9
+    125.0, 50.0,
+
+    -35.0, 75.0, // lower body, #10 - 11
+    35.0, 75.0,
+
+    -25.0, 200.0, // right leg, #12 - 13
+    -30.0, 300.0,
+
+    25.0, 200.0, // left leg, #14 - 15
+    30.0, 300.0
+
+};
+
+static const int Bones[BoneCount * 2] = {
+    0, 1, // neck
+
+    1, 2, // body
+    1, 3,
+    1, 4,
+    1, 5,
+    2, 3,
+    2, 4,
+    2, 5,
+    3, 4,
+    3, 5,
+    4, 5,
+
+    2, 6, // right arm
+    6, 7,
+
+    3, 8, // left arm
+    8, 9,
+
+    4, 10, // lower body
+    4, 11,
+    5, 10,
+    5, 11,
+    10, 11,
+
+    10, 12, // right leg
+    12, 13,
+
+    11, 14, // left leg
+    14, 15
+
+};
+
+StickMan::StickMan()
+{
+    m_sticks = true;
+    m_isDead = false;
+    m_pixmap = QPixmap("images/head.png");
+    m_penColor = Qt::white;
+    m_fillColor = Qt::black;
+
+    // Set up start position of limbs
+    for (int i=0; i<NodeCount; ++i) {
+        m_nodes[i] = new Node(QPointF(Coords[i * 2], Coords[i * 2 + 1]), this);
+        connect(m_nodes[i], SIGNAL(positionChanged()), this, SLOT(childPositionChanged()));
+    }
+
+    for (int i=0; i<BoneCount; ++i) {
+        int n1 = Bones[i * 2];
+        int n2 = Bones[i * 2 + 1];
+
+        Node *node1 = m_nodes[n1];
+        Node *node2 = m_nodes[n2];
+
+        QPointF dist = node1->pos() - node2->pos();
+        m_perfectBoneLengths[i] = sqrt(pow(dist.x(),2) + pow(dist.y(),2));
+    }
+
+    startTimer(10);
+}
+
+StickMan::~StickMan()
+{
+}
+
+void StickMan::childPositionChanged()
+{
+    prepareGeometryChange();
+}
+
+void StickMan::setDrawSticks(bool on)
+{
+    m_sticks = on;
+    for (int i=0;i<nodeCount();++i) {
+        Node *node = m_nodes[i];
+        node->setVisible(on);
+    }
+}
+
+QRectF StickMan::boundingRect() const
+{
+    // account for head radius=50.0 plus pen which is 5.0
+    return childrenBoundingRect().adjusted(-55.0, -55.0, 55.0, 55.0);
+}
+
+int StickMan::nodeCount() const
+{
+    return NodeCount;
+}
+
+Node *StickMan::node(int idx) const
+{
+    if (idx >= 0 && idx < NodeCount)
+        return m_nodes[idx];
+    else
+        return 0;
+}
+
+void StickMan::timerEvent(QTimerEvent *)
+{
+    update();
+}
+
+void StickMan::stabilize()
+{
+    static const qreal threshold = 0.001;
+
+    for (int i=0; i<BoneCount; ++i) {
+        int n1 = Bones[i * 2];
+        int n2 = Bones[i * 2 + 1];
+
+        Node *node1 = m_nodes[n1];
+        Node *node2 = m_nodes[n2];
+
+        QPointF pos1 = node1->pos();
+        QPointF pos2 = node2->pos();
+
+        QPointF dist = pos1 - pos2;
+        qreal length = sqrt(pow(dist.x(),2) + pow(dist.y(),2));
+        qreal diff = (length - m_perfectBoneLengths[i]) / length;
+
+        QPointF p = dist * (0.5 * diff);
+        if (p.x() > threshold && p.y() > threshold) {
+            pos1 -= p;
+            pos2 += p;
+
+            node1->setPos(pos1);
+            node2->setPos(pos2);
+        }
+    }
+}
+
+QPointF StickMan::posFor(int idx) const
+{
+    return m_nodes[idx]->pos();
+}
+
+//#include <QTime>
+void StickMan::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+{
+  /*  static int frames = 0;
+    static QTime time;
+    if (frames++ % 100 == 0) {
+        frames = 1;
+        time.restart();
+    }
+
+    if (time.elapsed() > 0) {
+        painter->setPen(Qt::white);
+        painter->drawText(0, 0, QString::number(frames / (time.elapsed() / 1000.0)));
+    }*/
+
+    stabilize();
+    if (m_sticks) {
+        painter->setPen(Qt::white);
+        for (int i=0; i<BoneCount; ++i) {
+            int n1 = Bones[i * 2];
+            int n2 = Bones[i * 2 + 1];
+
+            Node *node1 = m_nodes[n1];
+            Node *node2 = m_nodes[n2];
+
+            painter->drawLine(node1->pos(), node2->pos());
+        }
+    } else {
+        // first bone is neck and will be used for head
+
+        QPainterPath path;
+        path.moveTo(posFor(0));
+        path.lineTo(posFor(1));
+
+        // right arm
+        path.lineTo(posFor(2));
+        path.lineTo(posFor(6));
+        path.lineTo(posFor(7));
+
+        // left arm
+        path.moveTo(posFor(3));
+        path.lineTo(posFor(8));
+        path.lineTo(posFor(9));
+
+        // body
+        path.moveTo(posFor(2));
+        path.lineTo(posFor(4));
+        path.lineTo(posFor(10));
+        path.lineTo(posFor(11));
+        path.lineTo(posFor(5));
+        path.lineTo(posFor(3));
+        path.lineTo(posFor(1));
+
+        // right leg
+        path.moveTo(posFor(10));
+        path.lineTo(posFor(12));
+        path.lineTo(posFor(13));
+
+        // left leg
+        path.moveTo(posFor(11));
+        path.lineTo(posFor(14));
+        path.lineTo(posFor(15));
+
+        painter->setPen(QPen(m_penColor, 5.0, Qt::SolidLine, Qt::RoundCap));
+        painter->drawPath(path);
+
+        {
+            int n1 = Bones[0];
+            int n2 = Bones[1];
+            Node *node1 = m_nodes[n1];
+            Node *node2 = m_nodes[n2];
+
+            QPointF dist = node2->pos() - node1->pos();
+
+            qreal sinAngle = dist.x() / sqrt(pow(dist.x(), 2) + pow(dist.y(), 2));
+            qreal angle = asin(sinAngle) * 180.0 / M_PI;
+
+            QPointF headPos = node1->pos();
+            painter->translate(headPos);
+            painter->rotate(-angle);
+
+            painter->setBrush(m_fillColor);
+            painter->drawEllipse(QPointF(0,0), 50.0, 50.0);
+
+            painter->setBrush(m_penColor);
+            painter->setPen(QPen(m_penColor, 2.5, Qt::SolidLine, Qt::RoundCap));
+
+            // eyes
+            if (m_isDead) {
+                painter->drawLine(-30.0, -30.0, -20.0, -20.0);
+                painter->drawLine(-20.0, -30.0, -30.0, -20.0);
+
+                painter->drawLine(20.0, -30.0, 30.0, -20.0);
+                painter->drawLine(30.0, -30.0, 20.0, -20.0);
+            } else {
+                painter->drawChord(QRectF(-30.0, -30.0, 25.0, 70.0), 30.0*16, 120.0*16);
+                painter->drawChord(QRectF(5.0, -30.0, 25.0, 70.0), 30.0*16, 120.0*16);
+            }
+
+            // mouth
+            if (m_isDead) {
+                painter->drawLine(-28.0, 2.0, 29.0, 2.0);
+            } else {
+                painter->setBrush(QColor(128, 0, 64 ));
+                painter->drawChord(QRectF(-28.0, 2.0-55.0/2.0, 57.0, 55.0), 0.0, -180.0*16);
+            }
+
+            // pupils
+            if (!m_isDead) {
+                painter->setPen(QPen(m_fillColor, 1.0, Qt::SolidLine, Qt::RoundCap));
+                painter->setBrush(m_fillColor);
+                painter->drawEllipse(QPointF(-12.0, -25.0), 5.0, 5.0);
+                painter->drawEllipse(QPointF(22.0, -25.0), 5.0, 5.0);
+            }
+        }
+    }
+}
+
+
+
diff --git a/code/train/C++/0036012_razorfen_kraul.cpp b/code/train/C++/0036012_razorfen_kraul.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a1681ab47aefa355790b0b7f361b8c9bca02107c
--- /dev/null
+++ b/code/train/C++/0036012_razorfen_kraul.cpp
@@ -0,0 +1,272 @@
+/* This file is part of the ScriptDev2 Project. See AUTHORS file for Copyright information
+ * 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
+ */
+
+/* ScriptData
+SDName: Razorfen_Kraul
+SD%Complete: 100
+SDComment: Quest support: 1144, 1221
+SDCategory: Razorfen Kraul
+EndScriptData
+
+*/
+
+#include "AI/ScriptDevAI/PreCompiledHeader.h"/* ContentData
+quest_willix_the_importer
+EndContentData */
+
+
+#include "AI/ScriptDevAI/base/escort_ai.h"
+#include "AI/ScriptDevAI/base/pet_ai.h"
+
+/*######
+## npc_willix_the_importer
+######*/
+
+enum
+{
+    QUEST_WILLIX_THE_IMPORTER  = 1144,
+
+    SAY_WILLIX_READY           = -1047000,
+    SAY_WILLIX_1               = -1047001,
+    SAY_WILLIX_2               = -1047002,
+    SAY_WILLIX_3               = -1047003,
+    SAY_WILLIX_4               = -1047004,
+    SAY_WILLIX_5               = -1047005,
+    SAY_WILLIX_6               = -1047006,
+    SAY_WILLIX_7               = -1047007,
+    SAY_WILLIX_END             = -1047008,
+
+    SAY_WILLIX_AGGRO_1         = -1047009,
+    SAY_WILLIX_AGGRO_2         = -1047010,
+    SAY_WILLIX_AGGRO_3         = -1047011,
+    SAY_WILLIX_AGGRO_4         = -1047012,
+
+    NPC_RAGING_AGAMAR          = 4514
+};
+
+static const float aBoarSpawn[4][3] =
+{
+    {2151.420f, 1733.18f, 52.10f},
+    {2144.463f, 1726.89f, 51.93f},
+    {1956.433f, 1597.97f, 81.75f},
+    {1958.971f, 1599.01f, 81.44f}
+};
+
+struct npc_willix_the_importerAI : public npc_escortAI
+{
+    npc_willix_the_importerAI(Creature* m_creature) : npc_escortAI(m_creature) { Reset(); }
+
+    void Reset() override {}
+
+    // Exact use of these texts remains unknown, it seems that he should only talk when he initiates the attack or he is the first who is attacked by a npc
+    void Aggro(Unit* pWho) override
+    {
+        switch (urand(0, 6))                                // Not always said
+        {
+            case 0: DoScriptText(SAY_WILLIX_AGGRO_1, m_creature, pWho); break;
+            case 1: DoScriptText(SAY_WILLIX_AGGRO_2, m_creature, pWho); break;
+            case 2: DoScriptText(SAY_WILLIX_AGGRO_3, m_creature, pWho); break;
+            case 3: DoScriptText(SAY_WILLIX_AGGRO_4, m_creature, pWho); break;
+        }
+    }
+
+    void JustSummoned(Creature* pSummoned) override
+    {
+        pSummoned->AI()->AttackStart(m_creature);
+    }
+
+    void WaypointReached(uint32 uiPointId) override
+    {
+        switch (uiPointId)
+        {
+            case 2:
+                DoScriptText(SAY_WILLIX_1, m_creature);
+                break;
+            case 6:
+                DoScriptText(SAY_WILLIX_2, m_creature);
+                break;
+            case 9:
+                DoScriptText(SAY_WILLIX_3, m_creature);
+                break;
+            case 14:
+                DoScriptText(SAY_WILLIX_4, m_creature);
+                // Summon 2 boars on the pathway
+                m_creature->SummonCreature(NPC_RAGING_AGAMAR, aBoarSpawn[0][0], aBoarSpawn[0][1], aBoarSpawn[0][2], 0, TEMPSUMMON_TIMED_OOC_DESPAWN, 25000);
+                m_creature->SummonCreature(NPC_RAGING_AGAMAR, aBoarSpawn[1][0], aBoarSpawn[1][1], aBoarSpawn[1][2], 0, TEMPSUMMON_TIMED_OOC_DESPAWN, 25000);
+                break;
+            case 25:
+                DoScriptText(SAY_WILLIX_5, m_creature);
+                break;
+            case 33:
+                DoScriptText(SAY_WILLIX_6, m_creature);
+                break;
+            case 44:
+                DoScriptText(SAY_WILLIX_7, m_creature);
+                // Summon 2 boars at the end
+                m_creature->SummonCreature(NPC_RAGING_AGAMAR, aBoarSpawn[2][0], aBoarSpawn[2][1], aBoarSpawn[2][2], 0, TEMPSUMMON_TIMED_OOC_DESPAWN, 25000);
+                m_creature->SummonCreature(NPC_RAGING_AGAMAR, aBoarSpawn[3][0], aBoarSpawn[3][1], aBoarSpawn[3][2], 0, TEMPSUMMON_TIMED_OOC_DESPAWN, 25000);
+                break;
+            case 45:
+                DoScriptText(SAY_WILLIX_END, m_creature);
+                m_creature->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_QUESTGIVER);
+                // Complete event
+                if (Player* pPlayer = GetPlayerForEscort())
+                    pPlayer->GroupEventHappens(QUEST_WILLIX_THE_IMPORTER, m_creature);
+                SetEscortPaused(true);
+                break;
+        }
+    }
+};
+
+CreatureAI* GetAI_npc_willix_the_importer(Creature* pCreature)
+{
+    return new npc_willix_the_importerAI(pCreature);
+}
+
+bool QuestAccept_npc_willix_the_importer(Player* pPlayer, Creature* pCreature, const Quest* pQuest)
+{
+    if (pQuest->GetQuestId() == QUEST_WILLIX_THE_IMPORTER)
+    {
+        if (npc_willix_the_importerAI* pEscortAI = dynamic_cast<npc_willix_the_importerAI*>(pCreature->AI()))
+        {
+            // After 4.0.1 set run = true
+            pEscortAI->Start(false, pPlayer, pQuest);
+            DoScriptText(SAY_WILLIX_READY, pCreature, pPlayer);
+            pCreature->SetFactionTemporary(FACTION_ESCORT_N_NEUTRAL_PASSIVE, TEMPFACTION_RESTORE_RESPAWN);
+        }
+    }
+
+    return true;
+}
+
+/*######
+## npc_snufflenose_gopher
+######*/
+
+enum
+{
+    SPELL_SNUFFLENOSE_COMMAND   = 8283,
+    NPC_SNUFFLENOSE_GOPHER      = 4781,
+    GO_BLUELEAF_TUBBER          = 20920,
+};
+
+struct npc_snufflenose_gopherAI : public ScriptedPetAI
+{
+    npc_snufflenose_gopherAI(Creature* pCreature) : ScriptedPetAI(pCreature) { Reset(); }
+
+    bool m_bIsMovementActive;
+
+    ObjectGuid m_targetTubberGuid;
+
+    void Reset() override
+    {
+        m_bIsMovementActive  = false;
+    }
+
+    void MovementInform(uint32 uiMoveType, uint32 uiPointId) override
+    {
+        if (uiMoveType != POINT_MOTION_TYPE || !uiPointId)
+            return;
+
+        if (GameObject* pGo = m_creature->GetMap()->GetGameObject(m_targetTubberGuid))
+        {
+            pGo->SetRespawnTime(5 * MINUTE);
+            pGo->Refresh();
+
+            pGo->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
+        }
+
+        m_bIsMovementActive = false;
+    }
+
+    // Function to search for new tubber in range
+    void DoFindNewTubber()
+    {
+        std::list<GameObject*> lTubbersInRange;
+        GetGameObjectListWithEntryInGrid(lTubbersInRange, m_creature, GO_BLUELEAF_TUBBER, 40.0f);
+
+        if (lTubbersInRange.empty())
+            return;
+
+        lTubbersInRange.sort(ObjectDistanceOrder(m_creature));
+        GameObject* pNearestTubber = nullptr;
+
+        // Always need to find new ones
+        for (std::list<GameObject*>::const_iterator itr = lTubbersInRange.begin(); itr != lTubbersInRange.end(); ++itr)
+        {
+            if (!(*itr)->isSpawned() && (*itr)->HasFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND) && (*itr)->IsWithinLOSInMap(m_creature))
+            {
+                pNearestTubber = *itr;
+                break;
+            }
+        }
+
+        if (!pNearestTubber)
+            return;
+        m_targetTubberGuid = pNearestTubber->GetObjectGuid();
+
+        float fX, fY, fZ;
+        pNearestTubber->GetContactPoint(m_creature, fX, fY, fZ);
+        m_creature->GetMotionMaster()->MovePoint(1, fX, fY, fZ);
+        m_bIsMovementActive = true;
+    }
+
+    void UpdateAI(const uint32 uiDiff) override
+    {
+        if (!m_bIsMovementActive)
+            ScriptedPetAI::UpdateAI(uiDiff);
+    }
+};
+
+CreatureAI* GetAI_npc_snufflenose_gopher(Creature* pCreature)
+{
+    return new npc_snufflenose_gopherAI(pCreature);
+}
+
+bool EffectDummyCreature_npc_snufflenose_gopher(Unit* pCaster, uint32 uiSpellId, SpellEffectIndex uiEffIndex, Creature* pCreatureTarget, ObjectGuid /*originalCasterGuid*/)
+{
+    // always check spellid and effectindex
+    if (uiSpellId == SPELL_SNUFFLENOSE_COMMAND && uiEffIndex == EFFECT_INDEX_0)
+    {
+        if (pCreatureTarget->GetEntry() == NPC_SNUFFLENOSE_GOPHER)
+        {
+            if (npc_snufflenose_gopherAI* pGopherAI = dynamic_cast<npc_snufflenose_gopherAI*>(pCreatureTarget->AI()))
+                pGopherAI->DoFindNewTubber();
+        }
+
+        // always return true when we are handling this spell and effect
+        return true;
+    }
+
+    return false;
+}
+
+void AddSC_razorfen_kraul()
+{
+    Script* pNewScript;
+
+    pNewScript = new Script;
+    pNewScript->Name = "npc_willix_the_importer";
+    pNewScript->GetAI = &GetAI_npc_willix_the_importer;
+    pNewScript->pQuestAcceptNPC = &QuestAccept_npc_willix_the_importer;
+    pNewScript->RegisterSelf();
+
+    pNewScript = new Script;
+    pNewScript->Name = "npc_snufflenose_gopher";
+    pNewScript->GetAI = &GetAI_npc_snufflenose_gopher;
+    pNewScript->pEffectDummyNPC = &EffectDummyCreature_npc_snufflenose_gopher;
+    pNewScript->RegisterSelf();
+}
diff --git a/code/train/C++/0036183_BoustrophedonCpp.cpp b/code/train/C++/0036183_BoustrophedonCpp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a371ceefa3c12514491f0e7888f94ee7ac12bb30
--- /dev/null
+++ b/code/train/C++/0036183_BoustrophedonCpp.cpp
@@ -0,0 +1,129 @@
+/*
+ * Implementation of dpp::BoustrophdeonCpp class for solving CPP problems
+ * by generating field tracks that cover a convex field, and decomposing
+ * the tracks into waypoints by joining the tracks end-to-end.
+ *
+ * Copyright (C) 2014-2015 DubinsPathPlanner.
+ * Created by David Goodman <dagoodma@gmail.com>
+ * Redistribution and use of this file is allowed according to the terms of the MIT license.
+ * For details see the LICENSE file distributed with DubinsPathPlanner.
+ */
+
+#include <dpp/basic/Logger.h>
+#include <dpp/basic/Path.h>
+
+#include <dpp/planalg/BoustrophedonCpp.h>
+
+namespace dpp {
+
+/**
+ * Order field tracks in the track list according to the Boustrophedon CPP
+ * algorithm. Track direction (reverse or not) will be set.
+ * @remark This sets the tracks to reversed in an alternating order.
+ * @param[in] tracks field track list to reorder
+ * @param[in] startAtLast whether to use the last track as the first
+ * @param[in] reverseStartTrack whether to start in the reverse direction
+ * 	on the first track (or last depending).
+ */
+void setFieldTrackOrder(FieldTrackList &tracks, bool startAtLast,
+	bool reverseStartTrack) {
+	if (startAtLast) {
+		tracks.reverse();
+	}
+
+	bool directionReversed = reverseStartTrack;
+ 	FieldTrackListIterator iter;
+ 	for (iter = tracks.begin(); iter != tracks.end(); iter++) {
+ 		(*iter).reverse(directionReversed);
+ 		directionReversed ^= 1; // flip direction
+ 	}
+}
+
+/** 
+ * Solves the CPP problem using the Boustrophedon algorithm.
+ * @param[in] field a coverage field to generate waypoints over
+ * @param[in] C initial configuration of the vehicle
+ * @param[in] turnRadius of the vehicle
+ * @param[in] returnToInitial whether to include return edge and cost
+ * @param[out] G a graph to populate with nodes for coverage
+ * @param[out] GA attributes of the graph
+ * @param[out] Tour an ordered list of nodes representing the path
+ * @param[out] Edges an ordered list of edges representing the path
+ * @param[out] Headings headings used along the path at each node
+ * @param[out] cost overall cost (path length) for covering the field
+ * @return SUCCESS or FAILURE of the algorithm
+ */
+int BoustrophedonCpp::run(const Field &field, VehicleConfiguration C, double turnRadius,
+	bool returnToInitial, Graph &G, GraphAttributes &GA, List<node> &Tour,
+	List<edge> &Edges, NodeArray<double> &Headings, double &cost) {
+
+    // Check arguments
+    if (Headings.graphOf() != &G) {
+        throw std::domain_error("Headings should be for G.");
+    }
+
+    // Generate field tracks
+    FieldTrackList tracks;
+    if (field.generateFieldTracks(tracks) < 1) {
+    	throw std::runtime_error("Failed to generate field tracks.");
+    }
+
+    // Find the closest endpoint among first or last track from initial config
+    bool startAtLast = false;
+    bool reverseStartTrack = false;
+
+    FieldTrack firstTrack = tracks.front();
+    FieldTrack lastTrack = tracks.back();
+    VehicleConfiguration
+    	CfirstStart(firstTrack.start().m_x, firstTrack.start().m_y, firstTrack.angle()),
+    	CfirstEnd(firstTrack.end().m_x, firstTrack.end().m_y, firstTrack.angle(true)),
+    	ClastStart(lastTrack.start().m_x, lastTrack.start().m_y, lastTrack.angle()),
+    	ClastEnd(lastTrack.end().m_x, lastTrack.end().m_y, lastTrack.angle(true));
+
+    double d_fs = dubinsPathLength(C, CfirstStart, turnRadius),
+    	d_fe = dubinsPathLength(C, CfirstEnd, turnRadius),
+    	d_ls = dubinsPathLength(C, ClastStart, turnRadius),
+    	d_le = dubinsPathLength(C, ClastEnd, turnRadius);
+    double d_min = d_fs;
+    Logger::logDebug(DPP_LOGGER_VERBOSE_2) << "Comparing distances: " << std::endl
+    	<< "First track: " << d_fs << " and " << d_fe << std::endl
+    	<< "Last track: " << d_ls << " and " << d_le << std::endl;
+
+    if (d_fe < d_min) {
+    	d_min = d_fe;
+    	reverseStartTrack = true;
+    	Logger::logDebug(DPP_LOGGER_VERBOSE_2) << "Chose first track end: " << firstTrack.end() << std::endl;
+    }
+    else if (d_ls < d_min) {
+    	d_min = d_ls;
+    	reverseStartTrack = false;
+    	startAtLast = true;
+    	Logger::logDebug(DPP_LOGGER_VERBOSE_2) << "Chose last track start: " << lastTrack.start() << std::endl;
+    }
+    else if (d_le < d_min) {
+    	d_min = d_le;
+    	reverseStartTrack = true;
+    	startAtLast = true;
+    	Logger::logDebug(DPP_LOGGER_VERBOSE_2) << "Chose last track end: " << lastTrack.end() << std::endl;
+    }
+    else {
+    	Logger::logDebug(DPP_LOGGER_VERBOSE_2) << "Chose first track start: " << firstTrack.start() << std::endl;
+    }
+
+    Logger::logDebug(DPP_LOGGER_VERBOSE_2) << "Decomposing " << tracks.size()
+    	<< " field tracks into nodes with coverage width:" << field.coverageWidth()
+    	<< std::endl;
+
+    setFieldTrackOrder(tracks, startAtLast, reverseStartTrack);
+    int n = tracks.addNodesToGraph(G, GA, field.coverageWidth(), Tour, Headings);
+
+	Logger::logDebug(DPP_LOGGER_VERBOSE_2) << "Added " << n
+		<< " nodes to cover entire field." << std::endl;
+
+	// Create edges
+    cost = createDubinsTourEdges(G, GA, Tour, Headings, turnRadius, Edges, returnToInitial);
+
+    return SUCCESS;
+}
+
+} // namespace dpp
\ No newline at end of file
diff --git a/code/train/C++/0036385_LongestValidParentheses.cpp b/code/train/C++/0036385_LongestValidParentheses.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d8e468e9b017f94dba0e4af566f5b464633b8b7b
--- /dev/null
+++ b/code/train/C++/0036385_LongestValidParentheses.cpp
@@ -0,0 +1,48 @@
+#include <iostream>
+#include <stack>
+#include <algorithm>
+#include <string>
+
+using namespace std;
+
+class Solution
+{
+public:
+	int longestValidParentheses(string s)
+	{
+		stack<int> parenthes;
+		int val = 0,count = 0;
+		unsigned int i;
+		for(i = 0; i < s.size(); i++)
+		{
+			if(s[i] == '(')
+			{
+				parenthes.push(count);
+				count = 0;
+			}
+			else if(!parenthes.empty())
+			{
+				count = count + 1 + parenthes.top();
+				parenthes.pop();
+				val = max(val,count);
+			}
+			else
+			{
+				count = 0;
+			}
+		}
+		return val * 2;
+	}
+};
+
+int main()
+{
+	Solution solution;
+	cout<<solution.longestValidParentheses("(()")<<endl;
+	cout<<solution.longestValidParentheses("()()")<<endl;
+   	cout<<solution.longestValidParentheses(")()()")<<endl;	
+	cout<<solution.longestValidParentheses("(())")<<endl;	
+	
+	return 0;
+}
+
diff --git a/code/train/C++/0037874_seq-u.cpp b/code/train/C++/0037874_seq-u.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..29000a72c01804a14f43f478323f3bd2ee5aec69
--- /dev/null
+++ b/code/train/C++/0037874_seq-u.cpp
@@ -0,0 +1,145 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2011-05-24 00:48:31 +1000 (Tue, 24 May 2011) $ by $Author: tack $
+ *     $Revision: 12018 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.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 <gecode/set/sequence.hh>
+
+namespace Gecode { namespace Set { namespace Sequence {
+
+  /*
+   * "Sequenced union" propagator
+   *
+   */
+
+  Actor*
+  SeqU::copy(Space& home, bool share) {
+    return new (home) SeqU(home,share,*this);
+  }
+
+  ExecStatus
+  SeqU::propagateSeqUnion(Space& home,
+                          bool& modified, ViewArray<SetView>& x,
+                          SetView& y) {
+    Region r(home);
+    GlbRanges<SetView>* XLBs = r.alloc<GlbRanges<SetView> >(x.size());
+    for (int i=x.size(); i--; ){
+      GlbRanges<SetView> lb(x[i]);
+      XLBs[i]=lb;
+    }
+    Iter::Ranges::NaryAppend<GlbRanges<SetView> > u(XLBs,x.size());
+    GECODE_ME_CHECK_MODIFIED(modified, y.includeI(home,u));
+
+    GLBndSet before(home);
+    for (int i=0; i<x.size(); i++) {
+      LubRanges<SetView> xiub(x[i]);
+      before.includeI(home, xiub);
+      BndSetRanges beforeR(before);
+      GlbRanges<SetView> ylb(y);
+      Iter::Ranges::Diff<GlbRanges<SetView>, BndSetRanges> diff(ylb, beforeR);
+      if (diff()) {
+        GECODE_ME_CHECK_MODIFIED(modified, x[i].exclude(home, diff.min(),
+                                                        Limits::max));
+      }
+    }
+    before.dispose(home);
+
+    GLBndSet after(home);
+    for (int i=x.size(); i--; ) {
+      LubRanges<SetView> xiub(x[i]);
+      after.includeI(home, xiub);
+      BndSetRanges afterR(after);
+      GlbRanges<SetView> ylb(y);
+      Iter::Ranges::Diff<GlbRanges<SetView>, BndSetRanges> diff(ylb, afterR);
+      if (diff()) {
+        int max = diff.max();
+        for (; diff(); ++diff)
+          max = diff.max();
+        GECODE_ME_CHECK_MODIFIED(modified, x[i].exclude(home,
+                                                        Limits::min,
+                                                        max));
+      }
+    }
+    after.dispose(home);
+
+    return ES_FIX;
+  }
+
+  //Enforces sequentiality and ensures y contains union of Xi lower bounds.
+  ExecStatus
+  SeqU::propagate(Space& home, const ModEventDelta& med) {
+    ModEvent me0 = SetView::me(med);
+    bool ubevent = Rel::testSetEventUB(me0);
+    bool anybevent = Rel::testSetEventAnyB(me0);
+    bool cardevent = Rel::testSetEventCard(me0);
+
+    bool modified = false;
+    bool assigned=false;
+    bool oldModified = false;
+
+    do {
+      oldModified = modified;
+      modified = false;
+
+      if (oldModified || modified || anybevent || cardevent)
+        GECODE_ES_CHECK(propagateSeq(home,modified,assigned,x));
+      if (oldModified || modified || anybevent)
+        GECODE_ES_CHECK(propagateSeqUnion(home,modified,x,y));
+      if (oldModified || modified || ubevent)
+        GECODE_ES_CHECK(RelOp::unionNXiUB(home,modified,x,y,unionOfDets));
+      if (oldModified || modified || ubevent)
+        GECODE_ES_CHECK(RelOp::partitionNYUB(home,modified,x,y,unionOfDets));
+      if (oldModified || modified || anybevent)
+        GECODE_ES_CHECK(RelOp::partitionNXiLB(home,modified,x,y,unionOfDets));
+      if (oldModified || modified || cardevent || ubevent)
+        GECODE_ES_CHECK(RelOp::partitionNCard(home,modified,x,y,unionOfDets));
+
+    } while (modified);
+
+    for (int i=x.size(); i--;)
+      if (!x[i].assigned())
+        return ES_FIX;
+    return home.ES_SUBSUMED(*this);
+  }
+
+}}}
+
+// STATISTICS: set-prop
diff --git a/code/train/C++/0038003_system.cpp b/code/train/C++/0038003_system.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..db6f1f922de5cc14acc7275661b601a72632f4ea
--- /dev/null
+++ b/code/train/C++/0038003_system.cpp
@@ -0,0 +1,233 @@
+#include "system.h"
+#include "Integrators/integrator.h"
+#include "Potentials/potential.h"
+#include "InitialConditions/initialcondition.h"
+#include "particle.h"
+
+#include "Potentials/newtoniangravity.h"
+#include "vec3.h"
+
+#include <iostream>
+#include <iomanip>
+#include <cmath>
+using std::cout;
+using std::endl;
+using std::setprecision;
+
+
+
+
+
+void System::computeForces() {
+    resetAllForces();
+    m_potential->resetPotentialEnergy();
+
+    for (int i=0; i < m_numberOfParticles; i++){
+        for (int j = i+1; j < m_numberOfParticles; j++){
+            m_potential->computeForces(*m_particles.at(i), *m_particles.at(j));
+        }
+    }
+}
+
+void System::resetAllForces() {
+    for (int i=0; i<m_numberOfParticles; i++) {
+        m_particles.at(i)->resetForces();
+    }
+}
+
+void System::setPotential(Potential* potential) {
+    m_potential = potential;
+}
+
+void System::setIntegrator(Integrator* integrator) {
+    m_integrator = integrator;
+}
+
+void System::setInitialCondition(InitialCondition* initialCondition) {
+    m_initialCondition = initialCondition;
+    m_initialCondition->setupParticles(*this);
+}
+
+void System::setDt(double dt) {
+    m_integrator->setDt(dt);
+}
+
+void System::integrate(int numberOfSteps) {
+    m_integrateSteps = numberOfSteps;
+    printIntegrateInfo(0);
+    for (int i=1; i<numberOfSteps+1; i++) {
+        m_integrator->integrateOneStep(m_particles);
+        printIntegrateInfo(i);
+        writePositionsToFile();
+    }
+    closeOutFile();
+}
+
+void System::addParticle(Particle* p) {
+    m_particles.push_back(p);
+    m_numberOfParticles += 1;
+}
+
+double System::computeKineticEnergy() {
+    /*
+     * Here, the kinetic energy of the entire system should be computed. Since
+     * this is independent of the potential in use, we place this method
+     * directly in the system class.
+     *
+     * Remember that you can access the mass and velocity of particle i by
+     *
+     *      m_particles.at(i)->getMass()
+     *      m_particles.at(i)->getVelocity()
+     *
+     * Remember also that the Particle class has a built in method
+     * Particle::velocitySquared which can be used here.
+     */
+
+    m_kineticEnergy = 0;
+    for (int i = 0; i < m_numberOfParticles; i++){
+        //addParticle(Particle* i);
+        Particle* p = m_particles.at(i);
+        double mass = p->getMass();
+//        vec3 v = p->getVelocity();
+        m_kineticEnergy += 0.5*mass*p->velocitySquared();
+    }
+
+    //m_kineticEnergy = 0;
+    return m_kineticEnergy;
+}
+
+void System::printIntegrateInfo(int stepNumber) {
+    if (stepNumber == 0) {
+        cout << endl
+             << " STARTING INTEGRATION "    << endl
+             << "-------------------------" << endl
+             << "  o Number of steps:     " << m_integrateSteps << endl
+             << "  o Time step, dt:       " << m_integrator->getDt() << endl
+             << "  o Initial condition:   " << m_initialCondition->getName() << endl
+             << "  o Number of particles: " << m_particles.size() << endl
+             << "  o Potential in use:    " << m_potential->getName() << endl
+             << "  o Integrator in use:   " << m_integrator->getName() << endl
+             << endl;
+    } else if (stepNumber % 1000 == 0) {
+        m_kineticEnergy     = computeKineticEnergy();
+        m_potentialEnergy   = m_potential->getPotentialEnergy();
+        m_totalEnergy       = m_kineticEnergy + m_potentialEnergy;
+        printf("Step: %5d    E =%10.5f   Ek =%10.5f    Ep =%10.5f\n",
+               stepNumber, m_totalEnergy, m_kineticEnergy, m_potentialEnergy);
+        fflush(stdout);
+    }
+}
+
+void System::removeLinearMomentum() {
+    /*
+     * Here you should remove the total momentum of the entire system, to
+     * ensure the entire system does not drift away during long integration
+     * times.
+     *
+     * Remember that you can access the mass and velocity of particle i by
+     *
+     *      m_particles.at(i)->getMass();
+     *      m_particles.at(i)->getVelocity();
+     *
+     * Remember also that the vec3-vector class supports the += and -=
+     * operators, so you can do
+     *
+     *      totalMomentum += p->getVelocity() * p->getMass();
+     */
+
+    vec3 totalMomentum = vec3(0,0,0);
+}
+
+void System::setFileWriting(bool writeToFile) {
+    m_writeToFile = writeToFile;
+}
+
+void System::writePositionsToFile() {
+    if (m_outFileOpen == false) {
+        m_outFile.open(m_filename, std::ios::out);
+        m_outFileOpen = true;
+    }
+    /*
+     * This is where you should print the positions of each particle to file.
+     * Note that the file, "positions.dat", is already open; it is opened in
+     * the above if-test the first time this method is called in
+     * System::Integrate.
+     *
+     * Which format you choose for the data file is up to you.
+     */
+
+    for (int i=0; i<m_numberOfParticles; i++){
+        Particle* p = m_particles.at(i);
+        vec3 position_p = p->getPosition();
+        double x = position_p.x();
+        double y = position_p.y();
+        //m_outFile << m_numberOfParticles << endl;
+        m_outFile << setprecision(15) << x << " " << y << endl;
+    }
+}
+
+void System::closeOutFile() {
+    if (m_writeToFile == true) {
+        m_outFile.close();
+        m_outFileOpen = false;
+    }
+}
+
+void System::perihelion(int numberOfTimeSteps){
+// Set some helper variables before we start the time integration.
+double thetaPrevious        = 0;	// The perihelion angle of the previous time step.
+double thetaCurrent 		= 0;	// The perihelion angle of the current time step.
+
+double rPreviousPrevious 	= 0;	// Mercury-Sun-distance two times steps ago.
+double rPrevious            = 0;	// Mercury-Sun-distance of the previous time step.
+double rCurrent             = 0;	// Mercury-Sun-distance of the current time step.
+
+m_outFile.open("perihelion_nonrel.dat");
+// This is the integration loop, in which you advance the solution (usually via a integrateOneStep()
+// function located in an integrator object, e.g. the Verlet class).
+
+int year = 0;
+
+for (int timeStep = 0; timeStep < numberOfTimeSteps; timeStep++) {
+
+    // Integrate the solution one step forward in time, using the GR corrected force calcuation
+    // and the Verlet algorithm.
+    m_integrator->integrateOneStep(m_particles);
+
+    // Compute the current perihelion angle, using the inverse tangent function from cmath.
+    // This assumes there is a vector of planets, called m_particles, available, in which the
+    // Sun is m_particles[0] and Mercury is m_particles[1].
+    double x = m_particles[1]->getPosition().x() - m_particles[0]->getPosition().x();
+    double y = m_particles[1]->getPosition().y() - m_particles[0]->getPosition().y();
+    thetaCurrent = atan2( y, x );
+
+    // Compute the current Mercury-Sun distance.
+    double rCurrent = (m_particles[1]->getPosition() - m_particles[0]->getPosition()).length();
+
+    // Check if the *previous* time step was a minimum for the Mercury-Sun distance. I.e. check
+    // if the previous distance is smaller than the current one *and* the previous previous one.
+    //cout << rCurrent << endl;
+    //cout << "Calculating angle... " << endl;
+
+    if ( rCurrent > rPrevious && rPrevious < rPreviousPrevious ) {
+        // If we are perihelion, print angle (in radians) to terminal.
+        cout << "Year " << year << endl;
+        m_outFile << thetaPrevious << endl;
+        year += 1;
+        //cout << thetaPrevious*3600*180/M_PI << endl;
+        // Here you should also probably write it to file for later plotting or something.
+    }
+
+    // Update the helper variables (current, previous, previousPrevious).
+    rPreviousPrevious 	= rPrevious;
+    rPrevious           = rCurrent;
+    thetaPrevious		= thetaCurrent;
+}
+m_outFile.close();
+}
+
+
+
+
+
+
diff --git a/code/train/C++/0038061_endgamerule.cpp b/code/train/C++/0038061_endgamerule.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0b8279fe9c171da2309340f4df7b16efc8b7d159
--- /dev/null
+++ b/code/train/C++/0038061_endgamerule.cpp
@@ -0,0 +1,156 @@
+/*
+  Copyright (C) 2014 Marcus Soll
+  All rights reserved.
+
+  You may use this file under the terms of 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 Jolla 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 HOLDERS 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.
+*/
+
+#include "endgamerule.h"
+#include "greedyrule.h"
+#include "rulehelper.h"
+
+using RuleHelper::opponent;
+
+const int EndgameRule::_borderDiscs;
+
+namespace {
+int amountDiscsCanGet(Gameboard board, int player, int x_orig, int y_orig)
+{
+    int count = 0;
+
+    for(int x = 0; x < 8; ++x)
+    {
+        for(int y = 0; y < 8; ++y)
+        {
+            if(board.owner(x,y) == player)
+            {
+                --count;
+            }
+        }
+    }
+
+    board.play(x_orig,y_orig,player);
+    for(int x = 0; x < 8; ++x)
+    {
+        for(int y = 0; y < 8; ++y)
+        {
+            if(board.owner(x,y) == player)
+            {
+                ++count;
+            }
+        }
+    }
+    return count;
+}
+}
+
+EndgameRule::EndgameRule(QObject *parent) :
+    Rule(parent)
+{
+}
+
+bool EndgameRule::applicable(Gameboard board, int player)
+{
+    return (board.points(player) + board.points(opponent(player))) >= _borderDiscs;
+}
+
+void EndgameRule::doTurn(Gameboard board, int player)
+{
+    // Find plays where the opponent can't do anything after that
+    for(int x = 0; x < 8; ++x)
+    {
+        for(int y = 0; y < 8; ++y)
+        {
+            Gameboard temp = board;
+            if(temp.play(x,y,player) && !temp.isTurnPossible(opponent(player)))
+            {
+                emit turn(x,y);
+                return;
+            }
+        }
+    }
+
+    //Get the most discs while letting the opponent get few discs
+    int max = -1000;
+    int x_turn = -1;
+    int y_turn = -1;
+    for(int x = 0; x < 8; ++x)
+    {
+        for(int y = 0; y < 8; ++y)
+        {
+            if(board.play(x,y,player,true))
+            {
+                int count = amountDiscsCanGet(board,player,x,y);
+                Gameboard testboard = board;
+                testboard.play(x,y,player,false);
+                int countOpponent = -1;
+                for(int xi = 0; xi < 8; ++xi)
+                {
+                    for(int yi = 0; yi < 8; ++yi)
+                    {
+                        if(testboard.play(xi,yi,opponent(player),true))
+                        {
+                            int temp = amountDiscsCanGet(testboard,opponent(player),xi,yi);
+                            if(temp > countOpponent)
+                            {
+                                countOpponent = temp;
+                            }
+                        }
+                    }
+                }
+                count -= countOpponent;
+                if(count > max)
+                {
+                    max = count;
+                    x_turn = x;
+                    y_turn = y;
+                }
+            }
+        }
+    }
+
+    if(!(max == -1000 || x_turn == -1 || y_turn == -1))
+    {
+        emit turn(x_turn,y_turn);
+        return;
+    }
+
+    //If everything fails do a greedy rule
+    GreedyRule fallback;
+    QObject::connect(&fallback,SIGNAL(turn(int,int)),this,SLOT(getTurn(int,int)));
+    fallback.doTurn(board,player);
+    QObject::disconnect(&fallback,SIGNAL(turn(int,int)),this,SLOT(getTurn(int,int)));
+
+}
+
+QString EndgameRule::name()
+{
+    return tr("Endgame Rule");
+}
+
+void EndgameRule::getTurn(int x, int y)
+{
+    emit turn(x,y);
+}
diff --git a/code/train/C++/0038247_bestTimeToBuyAndSellStock3.cpp b/code/train/C++/0038247_bestTimeToBuyAndSellStock3.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4f40ef86d08922d282a8d62746c99792d1c822f
--- /dev/null
+++ b/code/train/C++/0038247_bestTimeToBuyAndSellStock3.cpp
@@ -0,0 +1,36 @@
+/*
+ *Say you have an array for which the ith element is the price of a given stock on day i.
+
+Design an algorithm to find the maximum profit. You may complete at most two transactions.
+
+Note:
+You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
+ * */
+#include "header.h"
+
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        int hold1 = INT_MIN;
+        int hold2 = INT_MIN;
+        int release1 = 0;
+        int release2 = 0;
+        for (int i = 0; i < prices.size(); i++) {
+            release2 = max(release2, hold2 + prices[i]);
+            hold2 = max(hold2, release1 - prices[i]);
+            release1 = max(release1, hold1 + prices[i]);
+            hold1 = max(hold1, -prices[i]);
+        }
+        return release2;
+    }
+};
+
+int main(int argc, char **argv) {
+    vector<int> prices;
+    for (int i = 1; i < argc; i++) {
+        prices.push_back(atoi(argv[i]));
+    }
+    Solution s;
+    cout << s.maxProfit(prices) << endl;
+    return 0;
+}
diff --git a/code/train/C++/0039567_coverage_tree.cc b/code/train/C++/0039567_coverage_tree.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9be1739e32401274b7debfb27f369aa659031fd2
--- /dev/null
+++ b/code/train/C++/0039567_coverage_tree.cc
@@ -0,0 +1,183 @@
+/*
+ * fMBT, free Model Based Testing tool
+ * Copyright (c) 2011, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU Lesser General Public License,
+ * version 2.1, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ */
+#include "coverage_tree.hh"
+#include "model.hh"
+#include <cstdlib>
+
+Coverage_Tree::Coverage_Tree(Log& l, std::string params) :
+  Coverage(l), max_depth(2), push_depth(0)
+{ 
+  exec[0] = &root_node;
+  set_max_depth(params);
+  push();
+}
+
+void Coverage_Tree::push()
+{
+  push_depth++;
+  std::list<std::pair<struct node*, int> > a;
+  push_restore.push_front(a);
+  exec_restore.push_front(exec);
+}
+
+void Coverage_Tree::pop()
+{
+  std::list<std::pair<struct node*, int> >::iterator i
+    = push_restore.front().begin();
+
+  while(i!=push_restore.front().end()) {
+    node_count--;
+    int action=i->second;
+    struct node* current_node=i->first;
+    delete current_node->nodes[action];
+    current_node->nodes[action]=NULL;
+    current_node->nodes.erase(action);
+    i++;
+  }
+  push_restore.pop_front();
+
+  exec=exec_restore.front();
+  exec_restore.pop_front();
+  push_depth--;
+}
+
+void Coverage_Tree::precalc()
+{
+  if (model) {
+    node_count=1;
+    max_count=0;
+    int acount=model->getActionNames().size()-1;
+    long ccount=acount;
+    for(int i=1;i<=max_depth;i++) {
+      max_count+=ccount;
+      ccount*=acount;
+    }
+  }
+}
+
+void Coverage_Tree::set_model(Model* _model)
+{
+  Coverage::set_model(_model);
+  precalc();
+}
+
+void Coverage_Tree::history(int action,std::vector<int>& props,
+			    Verdict::Verdict verdict)
+{
+  if (action) {
+    execute(action);
+  } else {
+    // verdict. And now we should do ??
+    exec.clear();
+    exec[0] = &root_node;    
+  }
+}
+
+Coverage_Tree::~Coverage_Tree()
+{
+  if (push_depth) {
+    pop();
+  } else {
+    abort();
+  }
+}
+
+bool Coverage_Tree::execute(int action)
+{
+  struct node* current_node=&root_node;
+  struct node* next_node;
+  int depth=0;
+  while (current_node && depth<max_depth) {
+    if (current_node->nodes[action]==NULL) {
+      current_node->nodes[action]=new struct node;
+      current_node->nodes[action]->action=action;
+      node_count++;
+      if (push_depth) {
+	std::pair<struct node*, int> a(current_node,action);
+	push_restore.front().push_front(a);
+      }
+    }
+    depth++;
+    next_node=exec[depth];
+    exec[depth]=current_node->nodes[action];
+    current_node=next_node;
+  }
+
+  return true;
+}
+
+
+float Coverage_Tree::getCoverage()
+{
+  return (float)(node_count-1)/max_count;
+}
+
+void Coverage_Tree::print_tree(struct node* node,int depth)
+{
+  for(int j=0;j<32;j++) {
+    if (node->nodes[j]) {
+      for(int i=0;i<depth;i++) {
+	log.debug("|");
+      }
+      log.debug("%s\n",model->getActionName(node->nodes[j]->action).c_str());
+      print_tree(node->nodes[j],depth+1);
+    }
+  }
+}
+
+int Coverage_Tree::fitness(int* action,int n,float* fitness)
+{
+  int ret=0;
+  
+  if (log.is_debug()) {
+    log.debug("Tree\n");
+    print_tree(&root_node,0);
+  }
+
+  for(int pos=0;pos<n;pos++) {
+    float f=0;
+    struct node* no=exec[0];
+    for(int i=0;(i<max_depth)&& no;i++) {
+      if (no->nodes[action[pos]]==NULL) {
+	f+=1.0/(i+1.0);
+      }
+      no=exec[i+1];
+    }
+    fitness[pos]=f;
+    if (fitness[pos]>fitness[ret]) {
+      ret=pos;
+    }
+  }
+  
+  return ret;
+}
+
+void Coverage_Tree::set_max_depth(std::string&s)
+{
+  if (s!="") {
+    max_depth=std::atoi(s.c_str());
+    if (max_depth<1) {
+      max_depth=1;
+    }
+  }
+  precalc();
+  log.debug("%s(%s) -> %i\n",__PRETTY_FUNCTION__,s.c_str(),max_depth);
+}
+
+FACTORY_DEFAULT_CREATOR(Coverage, Coverage_Tree, "perm")
diff --git a/code/train/C++/0039642_stickychan.cpp b/code/train/C++/0039642_stickychan.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f57c9edfad03a04defc2d347ad79cb6759ae01d8
--- /dev/null
+++ b/code/train/C++/0039642_stickychan.cpp
@@ -0,0 +1,190 @@
+/*
+ * Copyright (C) 2004-2011  See the AUTHORS file for details.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation.
+ */
+
+#include "Chan.h"
+#include "User.h"
+
+class CStickyChan : public CModule
+{
+public:
+	MODCONSTRUCTOR(CStickyChan) {}
+	virtual ~CStickyChan()
+	{
+	}
+
+	virtual bool OnLoad(const CString& sArgs, CString& sMessage);
+
+	virtual EModRet OnUserPart(CString& sChannel, CString& sMessage)
+	{
+		for (MCString::iterator it = BeginNV(); it != EndNV(); ++it)
+		{
+			if (sChannel.Equals(it->first))
+			{
+				CChan* pChan = m_pUser->FindChan(sChannel);
+
+				if (pChan)
+				{
+					pChan->JoinUser(true, "", m_pClient);
+					return HALT;
+				}
+			}
+		}
+
+		return CONTINUE;
+	}
+
+	virtual void OnModCommand(const CString& sCommand)
+	{
+		CString sCmdName = sCommand.Token(0);
+		CString sChannel = sCommand.Token(1);
+		sChannel.MakeLower();
+		if ((sCmdName == "stick") && (!sChannel.empty()))
+		{
+			SetNV(sChannel, sCommand.Token(2));
+			PutModule("Stuck " + sChannel);
+		}
+		else if ((sCmdName == "unstick") && (!sChannel.empty()))
+		{
+			MCString::iterator it = FindNV(sChannel);
+			if (it != EndNV())
+				DelNV(it);
+
+			PutModule("UnStuck " + sChannel);
+		}
+		else if ((sCmdName == "list") && (sChannel.empty()))
+		{
+			int i = 1;
+			for (MCString::iterator it = BeginNV(); it != EndNV(); ++it, i++)
+			{
+				if (it->second.empty())
+					PutModule(CString(i) + ": " + it->first);
+				else
+					PutModule(CString(i) + ": " + it->first + " (" + it->second + ")");
+			}
+			PutModule(" -- End of List");
+		}
+		else
+		{
+			PutModule("USAGE: [un]stick #channel [key], list");
+		}
+	}
+
+	virtual void RunJob()
+	{
+		if (!m_pUser->GetIRCSock())
+			return;
+
+		for (MCString::iterator it = BeginNV(); it != EndNV(); ++it)
+		{
+			CChan *pChan = m_pUser->FindChan(it->first);
+			if (!pChan) {
+				pChan = new CChan(it->first, m_pUser, true);
+				if (!it->second.empty())
+					pChan->SetKey(it->second);
+				if (!m_pUser->AddChan(pChan)) {
+					/* AddChan() deleted that channel */
+					PutModule("Could not join [" + it->first
+							+ "] (# prefix missing?)");
+					continue;
+				}
+			}
+			if (!pChan->IsOn()) {
+				PutModule("Joining [" + pChan->GetName() + "]");
+				PutIRC("JOIN " + pChan->GetName() + (pChan->GetKey().empty()
+							? "" : " " + pChan->GetKey()));
+			}
+		}
+	}
+
+	virtual CString GetWebMenuTitle() { return "Sticky Chans"; }
+
+	virtual bool OnWebRequest(CWebSock& WebSock, const CString& sPageName, CTemplate& Tmpl) {
+		if (sPageName == "index") {
+			bool bSubmitted = (WebSock.GetParam("submitted").ToInt() != 0);
+
+			const vector<CChan*>& Channels = m_pUser->GetChans();
+			for (unsigned int c = 0; c < Channels.size(); c++) {
+				const CString sChan = Channels[c]->GetName();
+				bool bStick = FindNV(sChan) != EndNV();
+
+				if(bSubmitted) {
+					bool bNewStick = WebSock.GetParam("stick_" + sChan).ToBool();
+					if(bNewStick && !bStick)
+						SetNV(sChan, ""); // no password support for now unless chansaver is active too
+					else if(!bNewStick && bStick) {
+						MCString::iterator it = FindNV(sChan);
+						if(it != EndNV())
+							DelNV(it);
+					}
+					bStick = bNewStick;
+				}
+
+				CTemplate& Row = Tmpl.AddRow("ChannelLoop");
+				Row["Name"] = sChan;
+				Row["Sticky"] = CString(bStick);
+			}
+
+			if(bSubmitted) {
+				WebSock.GetSession()->AddSuccess("Changes have been saved!");
+			}
+
+			return true;
+		}
+
+		return false;
+	}
+
+	virtual bool OnEmbeddedWebRequest(CWebSock& WebSock, const CString& sPageName, CTemplate& Tmpl) {
+		if (sPageName == "webadmin/channel") {
+			CString sChan = Tmpl["ChanName"];
+			bool bStick = FindNV(sChan) != EndNV();
+			if (Tmpl["WebadminAction"].Equals("display")) {
+				Tmpl["Sticky"] = CString(bStick);
+			} else if (WebSock.GetParam("embed_stickychan_presented").ToBool()) {
+				bool bNewStick = WebSock.GetParam("embed_stickychan_sticky").ToBool();
+				if(bNewStick && !bStick) {
+					SetNV(sChan, ""); // no password support for now unless chansaver is active too
+					WebSock.GetSession()->AddSuccess("Channel become sticky!");
+				} else if(!bNewStick && bStick) {
+					DelNV(sChan);
+					WebSock.GetSession()->AddSuccess("Channel stopped being sticky!");
+				}
+			}
+			return true;
+		}
+		return false;
+	}
+
+};
+
+
+static void RunTimer(CModule * pModule, CFPTimer *pTimer)
+{
+	((CStickyChan *)pModule)->RunJob();
+}
+
+bool CStickyChan::OnLoad(const CString& sArgs, CString& sMessage)
+{
+	VCString vsChans;
+	VCString::iterator it;
+	sArgs.Split(",", vsChans, false);
+
+	for (it = vsChans.begin(); it != vsChans.end(); ++it) {
+		CString sChan = it->Token(0);
+		CString sKey = it->Token(1, true);
+		SetNV(sChan, sKey);
+	}
+
+	// Since we now have these channels added, clear the argument list
+	SetArgs("");
+
+	AddTimer(RunTimer, "StickyChanTimer", 15);
+	return(true);
+}
+
+MODULEDEFS(CStickyChan, "configless sticky chans, keeps you there very stickily even")
diff --git a/code/train/C++/0039868_main.cpp b/code/train/C++/0039868_main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e567b1aa9addde98da2ac5d1f830f7ee24ca96d3
--- /dev/null
+++ b/code/train/C++/0039868_main.cpp
@@ -0,0 +1,54 @@
+/*
+ Copyright (2016) Michael Baer, Daniel Bonrath, 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 <ifaddrs.h>
+
+#include "TupleFeeder.h"
+
+#include "boost/asio.hpp"
+
+int main(int argc, char ** argv) {
+	argc--;
+	argv++;
+	
+	if (argc != 5) {
+		std::cerr << "Five parameters expected: config file, rendezvous IP, rendezvous port, own port and node type" << std::endl;
+		return 1;
+	}
+	
+	struct ifaddrs * ifAddrStruct = nullptr;
+	struct ifaddrs * ifa = nullptr;
+	void * tmpAddrPtr = nullptr;
+	getifaddrs(&ifAddrStruct);
+	
+	std::string ownIP;
+
+	for (ifa = ifAddrStruct; ifa != nullptr; ifa = ifa->ifa_next) {
+		if (ifa ->ifa_addr->sa_family == AF_INET) { // check it is IP4
+			tmpAddrPtr = &(reinterpret_cast<struct sockaddr_in *>(ifa->ifa_addr))->sin_addr;
+			char addressBuffer[INET_ADDRSTRLEN];
+			inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, INET_ADDRSTRLEN);
+
+			if (std::strcmp(ifa->ifa_name , "eth0") == 0) {
+				ownIP = std::string(addressBuffer);
+				break;
+			}
+		}
+	}
+	
+	TupleFeeder tf(argv[0], argv[1], std::atoi(argv[2]), std::atoi(argv[4]), ownIP, std::atoi(argv[3]));
+	return 0;
+}
diff --git a/code/train/C++/0040568_Merge_Intervals.cpp b/code/train/C++/0040568_Merge_Intervals.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..db7a9e8df3cf9ebe83842568709d30a80a75f0a5
--- /dev/null
+++ b/code/train/C++/0040568_Merge_Intervals.cpp
@@ -0,0 +1,46 @@
+/**
+ * Definition of Interval:
+ * classs Interval {
+ *     int start, end;
+ *     Interval(int start, int end) {
+ *         this->start = start;
+ *         this->end = end;
+ *     }
+ */
+bool comp(const Interval &i1, const Interval &i2)
+{
+    if (i1.start != i2.start) 
+        return i1.start < i2.start;
+    else 
+        return i1.end < i2.end;
+}
+
+class Solution {
+public:
+    /**
+     * @param intervals: interval list.
+     * @return: A new interval list.
+     */
+    vector<Interval> merge(vector<Interval> &intervals) {
+        vector<Interval> &a = intervals;
+        sort(a.begin(), a.end(), comp);
+        
+        int n = a.size();
+        if (n == 0)   return vector<Interval>();
+        vector<Interval> ans;
+        
+        int j = 0;
+        ans.push_back(a[0]);
+        for (int i = 1; i < n; ++i) 
+        {
+            if (a[i].start > ans[j].end) 
+            {
+                ++j;
+                ans.push_back(a[i]);
+                continue;
+            }
+            else ans[j].end = max(ans[j].end, a[i].end);
+        }
+        return ans;
+    }
+};
diff --git a/code/train/C++/0040607_StyleElement.cpp b/code/train/C++/0040607_StyleElement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7bec24a0f6cd66e2a74ef1b729607c6b3231c396
--- /dev/null
+++ b/code/train/C++/0040607_StyleElement.cpp
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2006, 2007 Rob Buis
+ * Copyright (C) 2008 Apple, Inc. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "StyleElement.h"
+
+#include "Document.h"
+#include "Element.h"
+#include "MappedAttribute.h"
+#include "MediaList.h"
+#include "MediaQueryEvaluator.h"
+
+namespace WebCore {
+
+StyleElement::StyleElement()
+{
+}
+
+StyleSheet* StyleElement::sheet(Element* e)
+{
+    if (!m_sheet)
+        createSheet(e);
+    return m_sheet.get();
+}
+
+void StyleElement::insertedIntoDocument(Document*, Element* element)
+{
+    process(element);
+}
+
+void StyleElement::removedFromDocument(Document* document)
+{
+    // If we're in document teardown, then we don't need to do any notification of our sheet's removal.
+    if (!document->renderer())
+        return;
+
+    // FIXME: It's terrible to do a synchronous update of the style selector just because a <style> or <link> element got removed.
+    if (m_sheet)
+        document->updateStyleSelector();
+}
+
+void StyleElement::process(Element* e)
+{
+    if (!e || !e->inDocument())
+        return;
+
+    unsigned resultLength = 0;
+    for (Node* c = e->firstChild(); c; c = c->nextSibling()) {
+        Node::NodeType nodeType = c->nodeType();
+        if (nodeType == Node::TEXT_NODE || nodeType == Node::CDATA_SECTION_NODE || nodeType == Node::COMMENT_NODE) {
+            unsigned length = c->nodeValue().length();
+            if (length > std::numeric_limits<unsigned>::max() - resultLength)
+                CRASH();
+            resultLength += length;
+        }
+    }
+    UChar* text;
+    String sheetText = String::createUninitialized(resultLength, text);
+
+    UChar* p = text;
+    for (Node* c = e->firstChild(); c; c = c->nextSibling()) {
+        Node::NodeType nodeType = c->nodeType();
+        if (nodeType == Node::TEXT_NODE || nodeType == Node::CDATA_SECTION_NODE || nodeType == Node::COMMENT_NODE) {
+            String nodeValue = c->nodeValue();
+            unsigned nodeLength = nodeValue.length();
+            memcpy(p, nodeValue.characters(), nodeLength * sizeof(UChar));
+            p += nodeLength;
+        }
+    }
+    ASSERT(p == text + resultLength);
+
+    createSheet(e, sheetText);
+}
+
+void StyleElement::createSheet(Element* e, const String& text)
+{
+    Document* document = e->document();
+    if (m_sheet) {
+        if (static_cast<CSSStyleSheet*>(m_sheet.get())->isLoading())
+            document->removePendingSheet();
+        m_sheet = 0;
+    }
+
+    // If type is empty or CSS, this is a CSS style sheet.
+    const AtomicString& type = this->type();
+    if (type.isEmpty() || (e->isHTMLElement() ? equalIgnoringCase(type, "text/css") : (type == "text/css"))) {
+        RefPtr<MediaList> mediaList = MediaList::create(media(), e->isHTMLElement());
+        MediaQueryEvaluator screenEval("screen", true);
+        MediaQueryEvaluator printEval("print", true);
+        if (screenEval.eval(mediaList.get()) || printEval.eval(mediaList.get())) {
+            document->addPendingSheet();
+            setLoading(true);
+            m_sheet = CSSStyleSheet::create(e, String(), KURL(), document->inputEncoding());
+            m_sheet->parseString(text, !document->inCompatMode());
+            m_sheet->setMedia(mediaList.get());
+            m_sheet->setTitle(e->title());
+            setLoading(false);
+        }
+    }
+
+    if (m_sheet)
+        m_sheet->checkLoaded();
+}
+
+}
diff --git a/code/train/C++/0040643_pd_orders.cpp b/code/train/C++/0040643_pd_orders.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9047b39c6cafc27051fa14815175626a3a51190e
--- /dev/null
+++ b/code/train/C++/0040643_pd_orders.cpp
@@ -0,0 +1,203 @@
+/*PGR-GNU*****************************************************************
+
+FILE: solution.cpp
+
+Copyright (c) 2015 pgRouting developers
+Mail: project@pgrouting.org
+
+------
+
+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.
+
+ ********************************************************************PGR-GNU*/
+
+#include "vrp/pd_orders.h"
+
+#include <vector>
+#include <memory>
+#include <utility>
+
+#include "vrp/pgr_pickDeliver.h"
+#include "vrp/dnode.h"
+
+namespace pgrouting {
+namespace vrp {
+
+
+PD_Orders::PD_Orders(
+        const std::vector<PickDeliveryOrders_t> &pd_orders
+        ) {
+    build_orders(pd_orders);
+}
+
+
+void
+PD_Orders:: add_order(
+        const PickDeliveryOrders_t &order,
+        std::unique_ptr<Base_node> b_pick,
+        const Vehicle_node &pick,
+        std::unique_ptr<Base_node> b_drop,
+        const Vehicle_node &drop) {
+    problem->add_base_node(std::move(b_pick));
+    problem->add_base_node(std::move(b_drop));
+    problem->add_node(pick);
+    problem->add_node(drop);
+
+    /*
+     * add into an order
+     */
+    m_orders.push_back(
+            Order(m_orders.size(), order.id,
+                pick,
+                drop));
+}
+
+
+void
+PD_Orders::build_orders(
+        const std::vector<PickDeliveryOrders_t> &pd_orders
+        ) {
+    ENTERING();
+    for (const auto order : pd_orders) {
+        /*
+         * SAMPLE CORRECT INFORMATION
+         *
+         * id | demand | pick_x | pick_y | pick_open_t | pick_close_t | pick_service_t | deliver_x | deliver_y | deliver_open_t | deliver_open_t | deliver_close_t | deliver_service_t
+         * 1  | 10     |   35   |   69   |   448       |   505        |    90          |    45     |   68      |    912         |   967          |    90           |    35
+         */
+
+        if  (problem->m_cost_matrix.empty()) {
+            /*
+             * Euclidean version
+             */
+            auto b_pick = create_b_pick<Node>(order, problem->node_id());
+            Vehicle_node pickup(
+                    {problem->node_id()++, order, Tw_node::NodeType::kPickup});
+
+            auto b_drop = create_b_deliver<Node>(order, problem->node_id());
+            Vehicle_node delivery({
+                    problem->node_id()++,
+                    order,
+                    Tw_node::NodeType::kDelivery});
+
+
+            add_order(order,
+                    std::move(b_pick), pickup,
+                    std::move(b_drop), delivery);
+        } else {
+            /*
+             * matrix version
+             */
+            msg.log << "pickup \n"
+                << "pick_node_id: " << order.pick_node_id
+                << "\n";
+
+            msg.log << "pickup \n"
+                << "deliver_node_id: " << order.deliver_node_id
+                << "\n";
+            auto b_pick = create_b_pick<Dnode>(order, problem->node_id());
+            Vehicle_node pickup(
+                    {problem->node_id()++, order, Tw_node::NodeType::kPickup});
+
+            auto b_drop = create_b_deliver<Dnode>(order, problem->node_id());
+            Vehicle_node delivery({
+                    problem->node_id()++,
+                    order,
+                    Tw_node::NodeType::kDelivery});
+
+            add_order(order,
+                    std::move(b_pick), pickup,
+                    std::move(b_drop), delivery);
+        }
+    }  //  for (creating orders)
+
+    EXITING();
+}
+
+bool
+PD_Orders::is_valid(double speed) const {
+    for (const auto &o : m_orders) {
+        if (!o.is_valid(speed)) {
+            return false;
+        }
+        pgassert(o.pickup().is_pickup());
+        pgassert(o.delivery().is_delivery());
+        /* P -> D */
+        pgassert(o.delivery().is_compatible_IJ(o.pickup(), speed));
+    }
+    return true;
+}
+
+Order&
+PD_Orders::operator[](size_t i) {
+    pgassert(i < m_orders.size());
+    return m_orders[i];
+}
+
+const Order&
+PD_Orders::operator[](size_t i) const {
+    pgassert(i < m_orders.size());
+    return m_orders[i];
+}
+
+void
+PD_Orders::set_compatibles(double speed) {
+    for (auto &I : m_orders) {
+        for (const auto J : m_orders) {
+            I.set_compatibles(J, speed);
+        }
+    }
+}
+
+size_t
+PD_Orders::find_best_J(
+        Identifiers<size_t> &within_this_set) const {
+    pgassert(!within_this_set.empty());
+    auto best_order = within_this_set.front();
+    size_t max_size = 0;
+
+
+    for (auto o : within_this_set) {
+        auto size_J =  m_orders[o].subsetJ(within_this_set).size();
+        if (max_size < size_J) {
+            max_size = size_J;
+            best_order = o;
+        }
+    }
+    return best_order;
+}
+
+
+size_t
+PD_Orders::find_best_I(
+        Identifiers<size_t> &within_this_set) const {
+    pgassert(!within_this_set.empty());
+    auto best_order = within_this_set.front();
+    size_t max_size = 0;
+
+
+    for (auto o : within_this_set) {
+        auto size_I =  m_orders[o].subsetI(within_this_set).size();
+        if (max_size < size_I) {
+            max_size = size_I;
+            best_order = o;
+        }
+    }
+    return best_order;
+}
+
+
+}  //  namespace vrp
+}  //  namespace pgrouting
diff --git a/code/train/C++/0040732_ChanVese.cpp b/code/train/C++/0040732_ChanVese.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5291fe615662a59092bf039eb4e8cc74f7a5adea
--- /dev/null
+++ b/code/train/C++/0040732_ChanVese.cpp
@@ -0,0 +1,171 @@
+#include <ChanVese.h>
+
+using namespace dsc;
+
+chanVeseSim::chanVeseSim() {}
+
+MStringArray* chanVeseSim::getArguments() {
+    args = MStringArray();
+	args.append("Sphere-Interpolator_radius:");
+    args.append("Simulator_time_step:");
+	return &args;
+}
+
+void chanVeseSim::initialize(MString initFile, MDoubleArray params) {
+	
+    //cout << "ChanVese: Initializing simulator." << endl;
+    startFile = MString(initFile);
+    vertices = MFloatPointArray();
+    faceCounts = MIntArray();
+    faceConnects = MIntArray();
+    step_length = (params[1] > 0) ? params[1] : 0.01;
+
+    V origo = V(0, 0, 0);
+    V dimensions = V(1,1,1);
+
+	domain = ComputationalDomain<MT>();
+    dinput = DSCInput<MT>();
+    sphereinterpolator = SphereInterpolator<MT>();
+    sphereinterpolator.set_dimensions(dimensions);
+    sphereinterpolator.set_center(origo, dimensions);
+    sphereinterpolator.set_radius((params[0] > 0) ? params[0] : 0.25);
+
+    sampler = ImageSampler<MT>(sphereinterpolator);
+    segmentation = Segmentation<MT>(domain, sampler, dinput);
+
+	// TODO: Find proper way to handle the missing file at initialization.
+    if (startFile == "") {
+        //startFile = "D:/Dropbox/4th year/Blok 1 - BSc/dsc-repo/CODE/DSC_PROJECT/DSC/data/cube_coarse.dsc";
+		//startFile = "C:/Dropbox/4th year/Blok 1 - BSc/dsc-repo/CODE/DSC_PROJECT/DSC/data/cube_coarse.dsc";
+		cout << "Simulator cannot initialize without a file, please select one." << endl;
+		buildCube();
+		step = 0;
+		return;
+    }
+    cout << "ChanVese: Initializing with file : " << startFile << endl;
+    read_dsc_file(startFile.asUTF8(), segmentation.get_dsc());
+
+    //cout << "ChanVese: Checking validity of initialization." << endl;
+    check_validity(segmentation.get_dsc());
+    check_validity(segmentation.get_dsc());
+    
+    //DSC<MT>& mesh = segmentation.get_dsc();
+    storeMesh(segmentation.get_dsc());
+    step = 0;
+    
+    //DSC<MT>& mesh2 = segmentation.get_dsc(); //Meshen er broken her.
+	return;
+}
+
+void chanVeseSim::tick() {
+    // Simulation work
+    //FIXME: Hvorfor har segmentation ikke længere en mesh i sig?
+    if (step_length > 0) {
+        //cout << "ChanVese: Doing step with size: " << step_length << endl;
+        cout << "ChanVese: simulating frame number " << (step+1) << endl;
+        segmentation.time_step(step_length);
+        //cout << "ChanVese: Storing step." << endl;
+        storeMesh(segmentation.get_dsc());
+        //cout << "ChanVese: Increaing timestamp." << endl;
+        step += 1;
+    }
+    else {
+        cout << "ChanVese ERROR: Asked to step with 0 or negative stepsize. No step was made." << endl;
+    }
+}
+
+int chanVeseSim::getTime() {
+    return step;
+}
+
+MFloatPointArray chanVeseSim::getMeshVerts() {
+    return vertices;
+}
+
+MIntArray chanVeseSim::getMeshFaceCounts() {
+    return faceCounts;
+}
+
+MIntArray chanVeseSim::getMeshFaceConnects() {
+    return faceConnects;
+}
+
+void chanVeseSim::storeMesh(DSC<MT> & dsc) {
+
+    vertices.clear();
+    faceCounts.clear();
+    faceConnects.clear();
+
+    DSC<MT>::face_kernel_type::iterator fit = dsc.faces_begin();
+    DSC<MT>::face_kernel_type::iterator ff_it = dsc.faces_end();
+    while (fit != ff_it)
+    {
+        if (fit->is_interface()) {// || fit->is_boundary()) {
+            // This part is quite important, DSC doesn't maintain consistent orientation of the triangles on the interface
+            DSC<MT>::simplex_set_type st_f;
+            dsc.star(fit.key(), st_f);
+            int label = -100;
+            for (DSC<MT>::simplex_set_type::tetrahedron_set_iterator tit = st_f.tetrahedra_begin(); tit != st_f.tetrahedra_end(); tit++) {
+			    int tl = dsc.find_tetrahedron(*tit).label;
+                if (tl > label) {
+			        //std::cout << label << " " << tl << std::endl;
+                    dsc.orient_faces_consistently(*tit);
+			    }
+                label = tl;
+		    }
+
+            std::vector<typename DSC<MT>::node_key_type> verts(3);
+            dsc.vertices(fit.key(), verts);
+
+            V n = normal_direction<MT>(dsc.find_node(verts[0]).v,
+			                           dsc.find_node(verts[1]).v, 
+				                       dsc.find_node(verts[2]).v);
+            //dsc.normal_to_face(fit.key());
+
+            faceCounts.append(3);
+            for (int i = 0; i < 3; ++i) {
+                V v = dsc.find_node(verts[i]).v;
+                faceConnects.append(vertices.length());
+                vertices.append(MFloatPoint(v[0], v[1], v[2]));
+          }
+        }
+        ++fit;
+      }
+}
+
+void chanVeseSim::buildCube() {
+    float cubeSize = 1;
+    const int numFaces = 6;
+    const int numFaceConnects = 24;
+    int face_counts[numFaces] = { 4, 4, 4, 4, 4, 4 };
+    int face_connects[ numFaceConnects] = { 0, 1, 2, 3,
+										    4, 5, 6, 7,
+										    3, 2, 6, 5,
+										    0, 3, 5, 4,
+										    0, 4, 7, 1,
+										    1, 7, 6, 2	};
+
+    MFloatPoint vtx_1( -cubeSize, -cubeSize, -cubeSize );
+	MFloatPoint vtx_2(  cubeSize, -cubeSize, -cubeSize );
+	MFloatPoint vtx_3(  cubeSize, -cubeSize,  cubeSize );
+	MFloatPoint vtx_4( -cubeSize, -cubeSize,  cubeSize );
+	MFloatPoint vtx_5( -cubeSize,  cubeSize, -cubeSize );
+	MFloatPoint vtx_6( -cubeSize,  cubeSize,  cubeSize );
+	MFloatPoint vtx_7(  cubeSize,  cubeSize,  cubeSize );
+	MFloatPoint vtx_8(  cubeSize,  cubeSize, -cubeSize );
+	vertices.append( vtx_1 );
+	vertices.append( vtx_2 );
+	vertices.append( vtx_3 );
+	vertices.append( vtx_4 );
+	vertices.append( vtx_5 );
+	vertices.append( vtx_6 );
+	vertices.append( vtx_7 );
+	vertices.append( vtx_8 );
+
+    for (int i = 0 ; i < numFaces ; i++) {
+        faceCounts.append(face_counts[i]);
+    }
+    for (int i = 0 ; i < numFaceConnects ; i++) {
+        faceConnects.append(face_connects[i]);
+    }
+}
\ No newline at end of file
diff --git a/code/train/C++/0040780_main.cpp b/code/train/C++/0040780_main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b972881a320eccd242d9ac1407dcd458ec21022b
--- /dev/null
+++ b/code/train/C++/0040780_main.cpp
@@ -0,0 +1,70 @@
+#include <iostream>
+#include <map>
+
+using namespace std;
+
+class Solution {
+public:
+    typedef struct _State {
+        struct _State *addPath(char path, struct _State *next = NULL) {
+            if (next == NULL && pathes.count(path) == 0)
+                next = new struct _State();
+            else if (next == NULL)
+                next = pathes[path];
+            pathes[path] = next;
+            return next;
+        }
+
+        map<char, _State *> pathes;
+    } State;
+
+    bool isMatch(const char *s, const char *p) {
+        if (s == NULL && p == NULL ||
+            *s == 0 && *p == 0)
+            return true;
+        if (p == NULL || s == NULL || *p == 0 || *s == 0)
+            return false;
+
+        State start, *end;
+        State *curr_state = &start;
+        char last = *p++, curr = *p;
+        while (*p) {
+
+            if (curr == '*') {
+                if (last != '*')
+                    curr_state = curr_state->addPath(last, curr_state);
+            }
+            else {
+                if (last != '*')
+                    curr_state = curr_state->addPath(last);
+            }
+            ++p;
+            last = curr;
+            curr = *p;
+        }
+        if (last != '*')
+            curr_state = curr_state->addPath(last);
+        end = curr_state;
+
+        curr_state = &start;
+        while (*s) {
+            if (curr_state->pathes.count(*s)) {
+                curr_state = curr_state->pathes[*s];
+            }
+            else if (curr_state->pathes.count('.')) {
+                curr_state = curr_state->pathes['.'];
+            }
+            else
+                return false;
+            s++;
+        }
+        return curr_state == end;
+    }
+};
+
+int main()
+{
+    Solution s;
+    cout << s.isMatch("aaa", "a*a");
+    return 0;
+}
diff --git a/code/train/C++/0040850_sentence.cpp b/code/train/C++/0040850_sentence.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7d92d7366de3ee0b74a81266d93aec5ef7bd4c0f
--- /dev/null
+++ b/code/train/C++/0040850_sentence.cpp
@@ -0,0 +1,146 @@
+/** \file sentence.cpp
+ * \brief Sentence saves the results of Chinese morphological analysis.
+ * \author Jun Jiang
+ * \version 0.1
+ * \date Feb 17, 2009
+ */
+
+#include "icma/sentence.h"
+#include "icma/pos_table.h"
+
+#include <icma/util/StringArray.h>
+
+#include <algorithm>
+#include <cassert>
+
+namespace cma
+{
+
+Morpheme::Morpheme()
+    : posCode_(-1)
+{
+}
+
+Sentence::Sentence()
+    : incrementedWordOffsetB_(true)
+{
+    //do nothing
+}
+
+Sentence::Sentence(const char* pString)
+    : raw_( pString ),
+      incrementedWordOffsetB_(true)
+{
+}
+
+void Sentence::setString(const char* pString)
+{
+    raw_ = pString;
+    candidates_.clear();
+    segment_.clear();
+    pos_.clear();
+    candMetas_.clear();
+    wordOffset_.clear();
+}
+
+const char* Sentence::getString(void) const
+{
+    return raw_.c_str();
+}
+
+int Sentence::getListSize(void) const
+{
+    return candMetas_.size();
+}
+
+int Sentence::getCount(int nPos) const
+{
+    int listSize = candMetas_.size();
+    return ( nPos + 1 >= listSize ) ?
+           ( segment_.size() - candMetas_[ nPos ].segOffset_ ) :
+           ( candMetas_[ nPos + 1 ].segOffset_ - candMetas_[ nPos ].segOffset_ );
+}
+
+const char* Sentence::getLexicon(int nPos, int nIdx) const
+{
+    return segment_[ candMetas_[ nPos ].segOffset_ + nIdx ];
+}
+
+bool Sentence::isIndexWord(int nPos, int nIdx) const
+{
+    return candidates_[nPos][nIdx].isIndexed;
+}
+
+int Sentence::getPOS(int nPos, int nIdx) const
+{
+    return candidates_[nPos][nIdx].posCode_;
+}
+
+const char* Sentence::getStrPOS(int nPos, int nIdx) const
+{
+    return pos_[ candMetas_[ nPos ].posOffset_ + nIdx ];
+}
+
+size_t Sentence::getOffset(int nPos, int nIdx) const
+{
+    if( incrementedWordOffsetB_ == true )
+        return nIdx;
+    return wordOffset_[ candMetas_[ nPos ].wdOffset_ + nIdx ];
+}
+
+MorphemeList* Sentence::getMorphemeList(int nPos)
+{
+    return &candidates_[nPos];
+}
+
+double Sentence::getScore(int nPos) const
+{
+    return candMetas_[nPos].score_;
+}
+
+void Sentence::setScore(int nPos, double nScore)
+{
+    candMetas_[nPos].score_ = nScore;
+}
+
+int Sentence::getOneBestIndex(void) const
+{
+    if( candMetas_.empty() )
+        return -1;
+    int size = candMetas_.size();
+    if( size == 1 )
+        return 0;
+
+    double bestScore = candMetas_[0].score_;
+    int bestIdx = 0;
+
+    for( int i = 1; i < size; ++i )
+    {
+        double tmpScore = candMetas_[ i ].score_;
+        if( tmpScore > bestScore )
+        {
+            bestScore = tmpScore;
+            bestIdx = i;
+        }
+
+    }
+
+    return bestIdx;
+}
+
+void Sentence::addList( const MorphemeList& morphemeList )
+{
+    candidates_.push_back(morphemeList);
+}
+
+void Sentence::setIncrementedWordOffset( bool flag )
+{
+    incrementedWordOffsetB_ = flag;
+}
+
+bool Sentence::isIncrementedWordOffset()
+{
+    return incrementedWordOffsetB_;
+}
+
+} // namespace cma
diff --git a/code/train/C++/0041378_rp_float.cpp b/code/train/C++/0041378_rp_float.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..37ad3a71a7c22dda0f85011e7d4ff01dd38ffd75
--- /dev/null
+++ b/code/train/C++/0041378_rp_float.cpp
@@ -0,0 +1,177 @@
+/****************************************************************************
+ * RealPaver v. 1.0                                                         *
+ *--------------------------------------------------------------------------*
+ * Author: Laurent Granvilliers                                             *
+ * Copyright (c) 1999-2003 Institut de Recherche en Informatique de Nantes  *
+ * Copyright (c) 2004-2006 Laboratoire d'Informatique de Nantes Atlantique  *
+ *--------------------------------------------------------------------------*
+ * RealPaver is distributed WITHOUT ANY WARRANTY. Read the associated       *
+ * COPYRIGHT file for more details.                                         *
+ *--------------------------------------------------------------------------*
+ * rp_float.c                                                               *
+ ****************************************************************************/
+
+#include "rp_float.h"
+
+/*
+static double rp_pow_iter(double xx, int nn)
+{
+  double y = xx, z = 1.0;
+  for( ;; )
+  {
+    if( rp_odd(nn) )
+    {
+      z *= y;
+      nn >>= 1;
+      if( nn==0 ) return( z );
+    }
+    else nn >>= 1;
+    y *= y;
+  }
+}
+*/
+
+/* Returns x to the power of n with n>=1 */
+double rp_pow(double x, int n, int round)
+{
+  if (x==0.0)
+  {
+    return( 0.0 );
+  }
+  else if (x==1.0)
+  {
+    return( 1.0 );
+  }
+  else if (x>0.0)
+  {
+    /* rounddown(5^n) = round down and then return 5^n */
+    /* roundup  (5^n) = round up   and then return 5^n */
+
+    if (round==RP_ROUND_VALUE_DOWN)
+    {
+      RP_ROUND_DOWNWARD();
+    }
+    else
+    {
+      RP_ROUND_UPWARD();
+    }
+
+    /* return( rp_pow_iter(x,n) );*/
+    {
+      double y = x, z = 1.0;
+      int nn = n;
+      for( ;; )
+      {
+	if( rp_odd(nn) )
+	{
+	  z *= y;
+	  nn >>= 1;
+	  if( nn==0 ) return( z );
+	}
+	else nn >>= 1;
+	y *= y;
+      }
+    }
+  }
+  else  /* x<0.0 */
+  {
+    if (rp_even(n))
+    {
+      /* rounddown((-5)^n) = round down and then return 5^n */
+      /* roundup  ((-5)^n) = round up   and then return 5^n */
+      if (round==RP_ROUND_VALUE_DOWN)
+      {
+        RP_ROUND_DOWNWARD();
+      }
+      else
+      {
+        RP_ROUND_UPWARD();
+      }
+      /* return( rp_pow_iter((-x),n) ); */
+      {
+	double y = -x, z = 1.0;
+	int nn = n;
+	for( ;; )
+	{
+	  if( rp_odd(nn) )
+	  {
+	    z *= y;
+	    nn >>= 1;
+	    if( nn==0 ) return( z );
+	  }
+	  else nn >>= 1;
+	  y *= y;
+	}
+      }
+    }
+    else  /* rp_odd(n) */
+    {
+      /* rounddown((-5)^n) = round up   and then return -(5^n) */
+      /* roundup  ((-5)^n) = round down and then return -(5^n) */
+      if (round==RP_ROUND_VALUE_DOWN)
+      {
+        RP_ROUND_UPWARD();
+      }
+      else
+      {
+        RP_ROUND_DOWNWARD();
+      }
+      /* return( -(rp_pow_iter((-x),n)) ); */
+      {
+	double y = -x, z = 1.0;
+	int nn = n;
+	for( ;; )
+	{
+	  if( rp_odd(nn) )
+	  {
+	    z *= y;
+	    nn >>= 1;
+	    if( nn==0 ) return( -z );
+	  }
+	  else nn >>= 1;
+	  y *= y;
+	}
+      }
+    }
+  }
+}
+
+/* Returns p := x+(n/h)(y-x) in (x,y) if [x,y] is not empty and not canonical */
+double rp_split_point(double x, double y, int h, int n)
+{
+  double a = rp_max_num(x,RP_MIN_DOUBLE),
+         b = rp_min_num(y,RP_MAX_DOUBLE);
+
+  if (a==b)   /* [r,r] || [-oo,MinReal] || [MaxReal,+oo] */
+  {    
+    return a;
+  }
+  else if (b==rp_next_double(a))   /* [r,r+] || [-oo,succ MinReal] */
+  {                                       /* || [pred MaxReal,+oo] */
+    if (x==(-RP_INFINITY))
+    {
+      return RP_MIN_DOUBLE;
+    }
+    else if (y==RP_INFINITY)
+    {
+      return RP_MAX_DOUBLE;
+    }
+    else
+    {
+      return a;
+    }
+  }
+  else                             /* [r,s] with s > r+ */
+  {
+    double div = ((double)n)/((double)h);
+    double c = a*(1.0-div) + b*div;
+    if ((c>a) && (c<b))
+    {
+      return c;
+    }
+    else
+    {
+      return rp_next_double(a);
+    }
+  }
+}
diff --git a/code/train/C++/0041911_converter.cpp b/code/train/C++/0041911_converter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..416847f5e563919d6f8342e09c0fa54eb982aaf7
--- /dev/null
+++ b/code/train/C++/0041911_converter.cpp
@@ -0,0 +1,273 @@
+/*
+* This file is part of Converseen, an open-source batch image converter
+* and resizer.
+*
+* (C) Francesco Mondello 2009 - 2022
+*
+* 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/>.
+*
+* Contact e-mail: Francesco Mondello <faster3ck@gmail.com>
+*
+*/
+
+#include <QMessageBox>
+#include <QInputDialog>
+#include <QFileInfo>
+#include "converter.h"
+
+Converter::Converter(QObject *parent)
+    : QThread(parent)
+{
+    reset();
+    connect(this, SIGNAL(finished()), this, SLOT(conversionCompleted()));
+}
+
+void Converter::conversionCompleted()
+{
+    emit nextConversion(m_conv_status);
+}
+
+void Converter::reset()
+{
+    m_zoom = false;
+    m_density = false;
+    m_rotation = false;
+    m_flip = false;
+}
+
+Converter::~Converter()
+{
+
+}
+
+void Converter::run()
+{
+    m_process_stopped = 0;
+    m_conv_status = 2;  // Jumped
+
+    Image my_image;
+    QFileInfo fi(m_fileNameIn);
+
+    QString out = m_fileNameOut;
+
+    if (!m_overwrite)   // modalità sovrascrittura
+        out = overwriteOldFileName(out);
+
+    if (!m_process_stopped) {
+        try {
+            my_image.quiet(true);
+            my_image.read(m_fileNameIn.toStdString());
+
+            if (m_zoom)
+                resize(my_image);
+            if (m_density)
+                changeDensity(my_image);
+            if (m_rotation)
+                rotate(my_image);
+            if (m_flip)
+                flip(my_image);
+
+            if (writeImage(my_image, m_format, m_quality, out))
+                m_conv_status = 1;
+        }
+        catch (Error& my_error) {
+            m_conv_status = -1;
+
+            QString err_status = tr("Error: %1").arg(QString::fromStdString(my_error.what()));
+            emit errorMessage(err_status);
+        }
+        catch( Magick::WarningCoder &warning )
+        {
+            m_conv_status = -1;
+
+            QString err_status = tr("Error: %1").arg(QString::fromStdString(warning.what()));
+            emit errorMessage(err_status);
+        }
+        catch( Magick::Warning &warning )
+        {
+            m_conv_status = -1;
+
+            QString err_status = tr("Error: %1").arg(QString::fromStdString(warning.what()));
+            emit errorMessage(err_status);
+        }
+    }
+}
+
+void Converter::setInputPicture(QString fileName)   //Name
+{
+    m_fileNameIn = fileName;
+}
+
+void Converter::setOutputPictureName(QString fileName)
+{
+    m_fileNameOut = fileName;
+}
+
+void Converter::setFormat(QString format)
+{
+    m_format = format;
+}
+
+void Converter::setQuality(int quality)
+{
+    m_quality = quality;
+}
+
+void Converter::setOutputDir(QString outputDir)
+{
+    m_outputDir = outputDir;
+}
+
+void Converter::setResize(QString resizingStr)
+{
+    resizingString = resizingStr;
+    m_zoom = true;
+}
+
+void Converter::setRotation(double deg)
+{
+    m_rotation = true;
+    m_rotation_deg = deg;
+}
+
+void Converter::rotate(Image &my_image)
+{
+    my_image.rotate(m_rotation_deg);
+}
+
+void Converter::setFlip(FlipOrientation orientation)
+{
+    m_flip = true;
+    m_orientation = orientation;
+}
+
+void Converter::flip(Image &my_image)
+{
+    if (m_orientation == VERTICAL)
+        my_image.flip();
+    if (m_orientation == HORIZONTAL)
+        my_image.flop();
+}
+
+void Converter::resize(Image &my_image)
+{
+    my_image.filterType(m_resamplingFilter);
+    my_image.resize(resizingString.toStdString());
+}
+
+void Converter::setDensity(QString densityStr)
+{
+    m_densityString = densityStr;
+    m_density = true;
+}
+
+void Converter::changeDensity(Image &my_image)
+{
+    QString n_den = QString(m_densityString);
+    my_image.resolutionUnits(PixelsPerInchResolution);
+    my_image.density(n_den.toStdString());
+}
+
+void Converter::setBackgroundColor(QString bg_color, bool changeBg_color)
+{
+    m_bg_color = bg_color;
+    m_changeBg_color = changeBg_color;
+}
+
+void Converter::setOverwrite(bool overwrite)
+{
+    m_overwrite = overwrite;
+}
+
+QString Converter::overwriteOldFileName(QString out)
+{
+    QFileInfo fi(out);
+    m_newBaseName = fi.baseName();
+
+    if (fi.exists()) {
+        if (!m_overwrite) {
+            emit requestOverwrite(m_newBaseName);
+
+            mutex.lock();
+            imageCondition.wait(&mutex);
+            mutex.unlock();
+        }
+        return QString("%1/%2.%3").arg(fi.path()).arg(m_newBaseName).arg(fi.suffix());
+    }
+    else
+        return out;
+}
+
+void Converter::setNewBasename(QString newBaseName, bool ok)
+{
+    if (ok)
+        m_newBaseName = newBaseName;
+
+    imageCondition.wakeAll();
+}
+
+void Converter::setResamplingFilter(IMFilterType resamplingFilter)
+{
+    m_resamplingFilter = resamplingFilter;
+}
+
+bool Converter::writeImage(Image &my_image, QString format, int quality, QString out)
+{
+    my_image.magick(format.toUpper().toStdString());
+
+    QStringList excludedFormats;
+    excludedFormats << "jpg" << "jpeg" << "bmp";
+
+    bool hasTransparency = false;
+
+#if MagickLibVersion < 0x700
+    hasTransparency = my_image.matte();
+#else
+    hasTransparency = my_image.alpha();
+#endif
+
+    if (m_changeBg_color || (excludedFormats.contains(format, Qt::CaseInsensitive) && hasTransparency)) {
+        Image bgImg;
+        bgImg.size(Magick::Geometry(my_image.columns(), my_image.rows()));
+
+        bgImg.read("xc:" + m_bg_color.toStdString());
+        bgImg.label("bgImg");
+        bgImg.depth(my_image.depth());
+
+        bgImg.composite(my_image, Magick::Geometry(bgImg.columns(),bgImg.rows()), Magick::DissolveCompositeOp );
+
+        my_image = bgImg;
+    }
+
+    bool converted = false;
+
+    if (quality != -1)
+        my_image.quality(quality);
+
+    try {
+        my_image.write(out.toStdString());
+
+        converted = true;
+    }
+    catch (Error& my_error) {
+        converted = false;
+    }
+
+    return converted;
+}
+
+void Converter::stopProcess()
+{
+    m_process_stopped = 1;
+}
diff --git a/code/train/C++/0042517_sceneDetecter.cpp b/code/train/C++/0042517_sceneDetecter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..73f5042289e02c15f66291c3621196feb97910ab
--- /dev/null
+++ b/code/train/C++/0042517_sceneDetecter.cpp
@@ -0,0 +1,42 @@
+#include "sceneDetecter.hpp"
+#include "../grayscaleHistogram.hpp"
+#include <iostream>
+using namespace cv;
+using namespace std;
+
+SceneDetecter::SceneDetecter()
+{
+	scenes.insert(map<Scenes, Scene>::value_type(CharacterSelect, Scene("characterSelect")));
+	scenes.insert(map<Scenes, Scene>::value_type(CustomRules, Scene("customRules")));
+	scenes.insert(map<Scenes, Scene>::value_type(AdditionalRules, Scene("additionalRules")));
+	scenes.insert(map<Scenes, Scene>::value_type(StageSetting, Scene("stageSetting")));
+	scenes.insert(map< Scenes, Scene > ::value_type(StageSelect, Scene("stageSelect")));
+	scenes.insert(map<Scenes, Scene>::value_type(GameReady, Scene("gameReady")));
+	scenes.insert(map<Scenes, Scene>::value_type(GameOver, Scene("gameOver")));
+	cout << "done" << endl;
+}
+
+SceneDetecter::Scenes SceneDetecter::detectScene(Mat grayImage)
+{
+	GrayscaleHistogram grayHist;
+	MatND hist1 = grayHist.getHistogram(grayImage);
+	double maxSim = 0;
+	Scenes currentScene = (Scenes)0;
+
+	for (map<Scenes, Scene>::iterator it = scenes.begin(); it != scenes.end(); ++it) {
+		MatND hist2 = grayHist.getHistogram(it->second.gray());
+		double similarity = compareHist(hist1, hist2, CV_COMP_INTERSECT);
+		if (similarity > maxSim) {
+			maxSim = similarity;
+			currentScene = it->first;
+		}
+		cout << " " << it->first << " " << similarity;
+	}
+	cout << endl;
+
+	return currentScene;
+}
+
+SceneDetecter::~SceneDetecter()
+{
+}
\ No newline at end of file
diff --git a/code/train/C++/0042778_1266.cpp b/code/train/C++/0042778_1266.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..caf351e88345bcf377eb3b38ed6b94d3ecb027f7
--- /dev/null
+++ b/code/train/C++/0042778_1266.cpp
@@ -0,0 +1,77 @@
+#include <iostream>
+#include <fstream>
+using namespace std;
+#define SIZE 100
+
+int n,m, mas[SIZE];
+int stack[SIZE], i_paste, Sum, answer, stack_len, II;
+
+bool check_paste()
+{
+	for (int j = stack[stack_len-1]+1; j<m; j++)
+		if (Sum + mas[j] <= n) 
+		{
+			i_paste = j;
+			return true;
+		}
+	return false;
+}
+void paste()
+{
+	stack_len++;
+	stack[stack_len] = i_paste;
+	Sum += mas[i_paste];
+}
+void del()
+{
+	stack[stack_len] = 0;
+	Sum -= mas[stack[stack_len-1]];
+	stack_len--;
+}
+void cut()
+{
+	del();
+	paste();
+}
+int main()
+{
+	ifstream in("input.txt");
+	ofstream out("output.txt");
+
+	while (in)
+	{
+		in >> n >> m;
+		for (int i = 0; i<m; i++) in >> mas[i];
+		Sum = 0;
+		answer = 0;
+
+		stack_len = 1;
+		stack[stack_len-1] = 0;
+		Sum += mas[stack[stack_len-1]];
+		
+		while (stack_len != 0)
+		{
+			if (Sum > n)
+			{
+				if (check_paste()) paste();
+				else 
+				{
+
+				}
+			}
+			if (Sum > answer) answer = Sum;
+			if (check_paste())
+			{
+
+			}
+			else
+			{
+				
+			}
+		}
+
+		if (in) out << "sum:" << answer << endl;
+	}
+	in.close();
+	out.close();
+}
\ No newline at end of file
diff --git a/code/train/C++/0043257_main_body.cpp b/code/train/C++/0043257_main_body.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0a7a66cd5f925a7df1ccf507b903841435b58385
--- /dev/null
+++ b/code/train/C++/0043257_main_body.cpp
@@ -0,0 +1,137 @@
+
+
+
+#include "siglouvain.h"
+
+#include <sstream>
+
+template <class T>
+inline string to_string (const T & t) {
+	stringstream ss;
+	ss<<t;
+	return ss.str();
+}
+
+double qtot_higher_level(siglouvain & luca, int_matrix & P, int_matrix & short_tp, int_matrix & newP) {
+	
+	
+	short_tp.clear();
+	
+	
+	map<int, map<int, double > > UPnet;
+	luca.set_upper_network(UPnet, P);
+	siglouvain luca2;
+	luca2.set_graph(UPnet);
+	luca2.collect_raw_groups(short_tp);
+	
+	newP.clear();
+	RANGE_loop(i, short_tp) {
+		set<int> s;
+		RANGE_loop(j, short_tp[i]) {
+			deque_to_set_app(P[short_tp[i][j]], s);
+		}
+		DI pp;
+		set_to_deque(s, pp);
+		newP.push_back(pp);
+	}
+	
+	
+	return luca.newman_modularity(newP);
+
+}
+
+
+
+
+int main(int argc, char * argv[]) {
+		
+		
+	if(argc<2) {
+		program_statement(argv[0]);
+		return -1;
+	}
+
+	
+	if(paras._set_(argc, argv)==false)
+		return -1;
+
+	paras.print();
+	
+	string netfile=paras.file1;
+	
+	
+	{	/* check if file_name exists */
+		char b[netfile.size()+1];
+		cast_string_to_char(netfile, b);
+		ifstream inb(b);
+		if(inb.is_open()==false) {
+			
+			cout<<"File "<<netfile<<" not found"<<endl;
+			return -1;
+		
+		}	
+	}	/* check if file_name exists */
+
+	
+	
+	siglouvain luca;
+	luca.set_graph(netfile);
+	
+	
+	if(luca.size()==0 || luca.edges()==0) {
+		cerr<<"network empty"<<endl;
+		return -1;
+	}
+	
+	
+	cout<<"network of "<<luca.size()<<" nodes, average degree: "<<2*luca.edges()/luca.size()<<endl;
+	int sy=system(("rm "+paras.folder+"tp").c_str());
+	sy=system(("rm "+paras.folder+"short_tp*").c_str());
+	
+	int_matrix P;
+	double qtot=luca.collect_raw_groups(P);
+	cout<<"qtot: "<<qtot<<endl;
+	ofstream pout((paras.folder+"tp").c_str());
+	luca.print_id(P, pout);
+	
+	int level=0;
+	
+	while (true) {
+		
+		cout<<"level "<<level<<" qtot: "<<qtot<<" modules: "<<P.size()<<endl;
+
+		int_matrix short_tp;
+		int_matrix newP;
+		double q2=qtot_higher_level(luca, P, short_tp, newP);
+		if(q2<qtot)
+			break;
+		else {
+			
+			++level;
+			qtot=q2;
+			P=newP;
+			ofstream poo((paras.folder+"short_tp"+to_string(level)).c_str());
+			RANGE_loop(i, short_tp) {
+				prints(short_tp[i], poo);
+			}
+			
+			ofstream pout2((paras.folder+"tp"+to_string(level)).c_str());
+			luca.print_id(P, pout2);
+
+			
+			
+		}
+	}
+	
+		
+	return 0;
+    
+    
+   	
+	
+	
+	
+
+}
+
+
diff --git a/code/train/C++/0043400_Longest_Substring_with_At_Most_Two_Distinct_Characters.cpp b/code/train/C++/0043400_Longest_Substring_with_At_Most_Two_Distinct_Characters.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..edc36b4bb85499bc04fbdf99e991e7cac1207f42
--- /dev/null
+++ b/code/train/C++/0043400_Longest_Substring_with_At_Most_Two_Distinct_Characters.cpp
@@ -0,0 +1,48 @@
+/*
+Solution _1: two pointers
+*/
+class Solution {
+public:
+    int lengthOfLongestSubstringTwoDistinct(string s) {
+        int result = 0;
+        unordered_map<char, int> map;
+        int i = 0;
+        int start = 0;
+        while (i < s.size()) {
+            if (map.find(s[i]) != map.end()) {
+                map[s[i]] = i;
+                result = max(result, i - start + 1);
+                i++;
+            } else if (map.size() <= 1) {
+                map[s[i]] = i;
+            } else {
+                char c;
+                int tmp = s.size();
+                for (auto it = map.begin(); it != map.end(); it++) {
+                    if (it->second < tmp) {
+                        c = it->first;
+                        tmp = it->second;
+                    }
+                }
+                map.erase(c);
+                map[s[i]] = i;
+                start = tmp + 1;
+            }
+        }
+        return result;
+    }
+    
+    int lengthOfLongestSubstringTwoDistinct_1(string s) {
+        int start = 0, cnt = 0;
+        int char_set[256] = {0};
+        int ans = 0;
+        for (int i = 0; i < s.size(); i++) {
+            if (char_set[s[i]]++ == 0) cnt++;
+            while (cnt > 2) {
+                char_set[s[start]]--;
+                if (char_set[s[start++]] == 0) cnt--;
+            }
+            ans = max(i - start + 1, ans);
+        }
+    }
+};
diff --git a/code/train/C++/0043518_ref_coverage.cpp b/code/train/C++/0043518_ref_coverage.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..36988accbd2ad546a1a5ad1709f857c65c2bfc0a
--- /dev/null
+++ b/code/train/C++/0043518_ref_coverage.cpp
@@ -0,0 +1,102 @@
+/*
+ *  MEGAHIT
+ *  Copyright (C) 2014 The University of Hong Kong
+ *
+ *  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 <map>
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <vector>
+#include <string>
+
+using namespace std;
+
+int main(int argc, char** argv) {
+    if (argc < 3) {
+        fprintf(stderr, "Usage: %s [ref-id_start_end_file] [ref-len_file]\n", argv[0]);
+        exit(1);
+    }
+
+    ifstream align_file(argv[1]);
+    ifstream len_file(argv[2]);
+    map<string, vector<pair<long long, long long> > > cov_map;
+    map<string, long long> len_map;
+    string id;
+    long long start, end, len;
+    long long total_align_len = 0;
+
+    while (align_file >> id) {
+        align_file >> start >> end;
+        if (start > end) {
+            swap(start, end);
+        }
+        cov_map[id].push_back(make_pair(start, end));
+        total_align_len += end - start + 1;
+    }
+
+    cout << "Total number of segments: " << cov_map.size() << endl;
+    cout << "Total aligned length: " << total_align_len << endl;
+
+    while (len_file >> id) {
+        len_file >> len;
+        len_map[id] = len;
+    }
+
+    cout << "Total number of ref_seqs: " << len_map.size() << endl;
+
+    long long total_cov_len = 0;
+    vector<int> cov_level_count(100);
+    for (auto it = cov_map.begin(); it != cov_map.end(); ++it) {
+        sort(it->second.begin(), it->second.end());
+        long long cur_end = 0;
+        long long cov_len = 0;
+        long long rep_len = 0;
+
+        for (auto jt = it->second.begin(); jt != it->second.end(); ++jt) {
+            if (cur_end >= jt->first) {
+                if (cur_end <= jt->second) {
+                    rep_len += cur_end - jt->first + 1;
+                } else {
+                    rep_len += jt->second - jt->first + 1;
+                }
+                jt->first = cur_end + 1;
+            }
+            if (jt->second >= jt->first) {
+                cov_len += jt->second - jt->first + 1;
+            }
+
+            cur_end = max(cur_end, jt->second);
+        }
+        int cov_level = cov_len * 1.0 / len_map[it->first] * 100;
+        total_cov_len += cov_len;
+        cov_level_count[cov_level]++;
+        if (cov_level >= 5) {
+            cout << "ref_id " << it->first << " coverage >= 50%, ref length " << len_map[it->first] << endl;
+        }
+        if (true || rep_len > cov_len) {
+            // cerr << "ref_id " << it->first << " coverage by many redundant contigs (" <<  rep_len << "/" << cov_len << "/" << len_map[it->first] << ")" << endl;
+        }
+    }
+
+    for (int i = 0; i <= 100; ++i) {
+        cout << "Refs with cov no less than " << i * 1.0 / 100 << " " << cov_level_count[i] << endl;
+    }
+
+    cout << "Total covered length: " << total_cov_len << endl;
+
+    return 0;
+}
\ No newline at end of file
diff --git a/code/train/C++/0043616_Utils.cpp b/code/train/C++/0043616_Utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8c8efa23060926674998b8de0c496aef4eb3c1d5
--- /dev/null
+++ b/code/train/C++/0043616_Utils.cpp
@@ -0,0 +1,77 @@
+#include "Utils.h"
+#include <iostream>
+#include <cmath>
+#include <algorithm>
+
+using namespace std;
+
+double mod(double y, double x)
+{
+	if(x <= 0)
+		cerr<<"Warning in mod(double, double) (Utils.cpp)"<<endl;
+	return (y/x - floor(y/x))*x;
+}
+
+void wrap(double& x, double min, double max)
+{
+	x = mod(x - min, max - min) + min;
+}
+
+int mod(int y, int x)
+{
+	if(x <= 0)
+		cerr<<"Warning in mod(int, int) (Utils.cpp)"<<endl;
+	if(y >= 0)
+		return y - (y/x)*x;
+	else
+		return (x-1) - mod(-y-1, x);
+}
+
+double logsumexp(double* logv, int n)
+{
+	if(n<=1)
+		cerr<<"Warning in logsumexp"<<endl;
+	double max = logv[0];
+	for(int i=1; i<n; i++)
+		if(logv[i] > max)
+			max = logv[i];
+	double answer = 0;
+	// log(sum(exp(logf)) 	= log(sum(exp(logf - max(logf) + max(logf)))
+	//			= max(logf) + log(sum(exp(logf - max(logf)))
+	for(int i=0; i<n; i++)
+		answer += exp(logv[i] - max);
+	answer = max + log(answer);
+	return answer;
+}
+
+double logsumexp(const vector<double>& logv)
+{
+	int n = static_cast<int>(logv.size());
+	//if(n<=1)
+	//	cout<<"Warning in logsumexp"<<endl;
+	double max = *max_element(logv.begin(), logv.end());
+	double answer = 0;
+	// log(sum(exp(logf)) 	= log(sum(exp(logf - max(logf) + max(logf)))
+	//			= max(logf) + log(sum(exp(logf - max(logf)))
+	for(int i=0; i<n; i++)
+		answer += exp(logv[i] - max);
+	answer = max + log(answer);
+	return answer;
+}
+
+double logsumexp(double a, double b)
+{
+	double x[2] = {a,b};
+	return logsumexp(x, 2);
+}
+
+double logdiffexp(double a, double b)
+{
+	if(a <= b)
+		cerr<<"# Error in logdiffexp."<<endl;
+	double biggest = a;
+	a -= biggest;
+	b -= biggest;
+	return log(exp(a) - exp(b)) + biggest;
+}
+
diff --git a/code/train/C++/0044099_Solution.cpp b/code/train/C++/0044099_Solution.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6b464d5a96d4113cb296782623e2d2deb64b7013
--- /dev/null
+++ b/code/train/C++/0044099_Solution.cpp
@@ -0,0 +1,46 @@
+/*************************************************************************
+    > File Name: Solution.cpp
+    > Author: Duke-wei
+    > Mail: 13540639584@163.com 
+    > Created Time: 2017年05月02日 星期二 20时38分38秒
+ ************************************************************************/
+//仔细考了，对于A[i]来说，能够在该位置上累计的最多水量取决于i的左右两边的最大值中的最小值，即min(left,right)-A[i]。
+#include<iostream>
+#include<vector>
+using namespace std;
+class Solution{
+	public:
+		int trap(vector<int>& height){
+			if((int)height.size()<2) return 0;
+			int sz = height.size();
+			vector<int> left(sz,0);
+			vector<int> right(sz,0);
+			for(int i=0;i<sz;++i){
+				//记录i的左边最大值，i的右边最大值。
+				left[i] = max(left[i-1],height[i-1]);
+				right[sz-i-1] = max(right[sz-i],height[sz-i]);
+			}
+			int water = 0;
+			for(int i=1;i<sz;++i){
+				int minh = min(left[i],right[i]);
+				water += minh>height[i]?minh-height[i]:0;
+			}
+			return water;
+		}
+};
+
+//上述代码的更加巧妙的简化
+class Solution2{
+public:
+    int trap(vector<int>& height) {
+		int l = 0, r = height.size()-1, level = 0, water = 0;
+    	while (l < r) {
+    	    int lower = height[height[l] < height[r] ? l++ : r--];
+			//这里的level含义：上次的最小边界。
+			//lower是当前最小边界,注意这里也是迭代的有动态规划的思路。
+    	    level = max(level, lower);
+    	    water += level - lower;
+    	}
+    	return water;
+	}
+};
diff --git a/code/train/C++/0044429_K_Kth_Largest_Element.cpp b/code/train/C++/0044429_K_Kth_Largest_Element.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eb3add9911d8ba0c09cbbf8ac2edb2a7ffdbc2eb
--- /dev/null
+++ b/code/train/C++/0044429_K_Kth_Largest_Element.cpp
@@ -0,0 +1,37 @@
+class Solution {
+public:
+    /*
+     * param k : description of k
+     * param nums : description of array and index 0 ~ n-1
+     * return: description of return
+     */
+    int kthLargestElement(int k, vector<int> nums) {
+        // write your code here
+        //if(nums.size() < k)    return -1;
+        int length = nums.size();
+        return quickSelect(nums, 0, length - 1, length - k);
+    }
+private:
+    int quickSelect(vector<int> &a, int l, int r, int k)
+    {
+        if(l == r)  return a[k];
+        
+        int pivot = a[l];
+        int i = l + 1;
+        int j = r;
+        
+        while(i <= j)
+        {
+            while(i <= j && a[i] < pivot)   ++i;
+            while(i <= j && a[j] > pivot)   --j;
+            if(i < j)
+            {
+                swap(a[i++], a[j--]);
+            }
+        }
+        swap(a[j], a[l]);
+        if(j == k)  return a[k];
+        else if(j < k)  return quickSelect(a, j + 1, r, k);
+        else    return quickSelect(a, l, j - 1, k);
+    }
+};
diff --git a/code/train/C++/0044528_12621.cc b/code/train/C++/0044528_12621.cc
new file mode 100644
index 0000000000000000000000000000000000000000..682f672141918e9dba8c223b0bdd322c981c3f01
--- /dev/null
+++ b/code/train/C++/0044528_12621.cc
@@ -0,0 +1,53 @@
+/*=============================================================================
+#  Author:          Teerapat Jenrungrot - https://github.com/mjenrungrot/
+#  FileName:        12621.cc
+#  Description:     UVa Online Judge - 12621
+=============================================================================*/
+#include <bits/stdc++.h>
+using namespace std;
+
+const int MAXVAL = 505;
+const int INF = 1e9 + 7;
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(0);
+
+    int T;
+    cin >> T;
+    while (T--) {
+        int requirement;
+        cin >> requirement;
+        requirement /= 10;
+
+        int N;
+        cin >> N;
+
+        vector<bool> possible(MAXVAL);
+        possible[0] = true;
+
+        int ans = INF;
+        for (int i = 0; i < N; i++) {
+            int weight;
+            cin >> weight;
+            weight /= 10;
+
+            for (int j = MAXVAL - 1; j >= 0; j--) {
+                if (not possible[j]) continue;
+                if (j + weight < MAXVAL) {
+                    possible[j + weight] = true;
+                    if (j + weight >= requirement) {
+                        ans = min(ans, j + weight);
+                    }
+                }
+            }
+        }
+
+        if (ans == INF)
+            cout << "NO SOLUTION" << endl;
+        else
+            cout << ans * 10 << endl;
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/code/train/C++/0044982_main.cpp b/code/train/C++/0044982_main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ae7d55835c1762b07c2397179a39ad392b2718b2
--- /dev/null
+++ b/code/train/C++/0044982_main.cpp
@@ -0,0 +1,75 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+
+using namespace std;
+
+int _n; // input num
+const int SIZE_ = 20;
+double _distance [SIZE_][SIZE_]; // distance
+double _memory [SIZE_][1<<SIZE_]; // for memoization
+
+int getIndex(int flag) {
+    int i;
+    for (i = 0; i < _n; i++) {
+        if (flag & (1 << i)) break;
+    }
+    return i;
+}
+
+double tsp(int from, int toFlag, int size) {
+    if (_memory[from][toFlag] > 0) {
+        return _memory[from][toFlag];
+    }
+    if (size == 1) {
+        int to = getIndex(toFlag);
+        return _distance[from][to];
+    }
+
+    double m = 1500000.0;
+    for (int i = 0; i < _n; i++) {
+        if (!(toFlag & (1 << i))) continue;
+
+        double v = _distance[from][i] + tsp(i, (toFlag & ~(1<<i)), size-1);
+        m = min(m, v);
+    }
+
+    _memory[from][toFlag] = m;
+    return m;
+}
+
+double findMin() {
+    double m = 150000.0;
+    for (int i = 0; i < _n; i++) {
+        double v = tsp(i, ~(1<<i), _n-1) + _distance[i][i];
+        m = min(m, v);
+    }
+
+    return m;
+}
+
+
+void solve() {
+    cin >> _n;
+
+    for (int i = 0; i < _n; i++) {
+        for (int j = 0; j < _n; j++) {
+            cin >> _distance[i][j];
+        }
+    }
+
+    memset(_memory, 0, sizeof(double)*SIZE_*(1<<SIZE_));
+    double minValue = findMin();
+    printf("%.10lf\n", minValue);
+}
+
+int main() {
+    int num;
+    cin >> num;
+
+    for (int i = 0; i < num; i++) {
+        solve();
+    }
+
+    return 0;
+}
diff --git a/code/train/C++/0045373_1077.cpp b/code/train/C++/0045373_1077.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4e08b1e4249fc08e819ee2f9a472bde52094bdbd
--- /dev/null
+++ b/code/train/C++/0045373_1077.cpp
@@ -0,0 +1,51 @@
+#include <iostream>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <cstdio>
+using namespace std;
+
+int main()
+{
+	int n = 0;
+	scanf("%d\n", &n);
+
+	vector<string> v(n);
+	size_t minLen = 1000000;
+	for (int i = 0; i < n; ++i)
+	{
+		getline(cin, v[i]);
+		minLen = min(minLen, v[i].length());
+	}
+
+	string ans;
+	int ansLen = 0;
+	for (int k = 1; k <= minLen; ++k)
+	{
+		string suffix = v[0].substr(int(v[0].size())-k);
+		bool iscommon = true;
+		for (int i = 1; i < n; ++i)
+		{
+			if (v[i].substr(int(v[i].size())-k) != suffix)
+			{
+				iscommon = false;
+				break;
+			}
+		}
+
+		if (iscommon)
+		{
+			ans = suffix;
+			ansLen = k;
+		}
+		else
+		{
+			break;
+		}
+	}
+
+	if (ans == "") cout << "nai" << endl;
+	else cout << ans << endl;
+
+	return 0;
+}
diff --git a/code/train/C++/0045465_MasterAI.cpp b/code/train/C++/0045465_MasterAI.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f8354a77c4cb232c8fb2593dd07a45ec152bfd1c
--- /dev/null
+++ b/code/train/C++/0045465_MasterAI.cpp
@@ -0,0 +1,233 @@
+#include "masterAI.h"
+#include "strategyMap.h"
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+//								MASTERAI													//
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+MASTERAI::MASTERAI(PLAYER *_player, TERRAIN *_terrain) : m_unitPool(NULL)
+{
+	m_pPlayer = _player;
+	m_pTerrain = _terrain;
+	m_nextGroupUpdate = 1.0f;
+	m_nextUpdate = 5.0f + m_pPlayer->m_teamNo;
+	m_unitPool.m_pMaster = this;
+
+	INTPOINT center = m_pPlayer->GetCenter();
+	RECT r = {center.x - 10, center.y - 10, center.x + 10, center.y + 10};
+	m_base = r;
+
+	//Create influence map
+	m_pStrategyMap = new STRATEGY_MAP(m_pTerrain, m_pPlayer, INTPOINT(10, 10));
+}
+
+MASTERAI::~MASTERAI()
+{
+	//Delete all groups
+	for(int i=0;i<(int)m_groups.size();i++)
+		if(m_groups[i] != NULL)
+			delete m_groups[i];
+	m_groups.clear();
+
+	//Release strategy map
+	if(m_pStrategyMap != NULL)
+		delete m_pStrategyMap;
+}
+
+void MASTERAI::Update(float deltaTime)
+{
+	if(m_pPlayer == NULL || m_pTerrain == NULL)return;
+
+	//Group AI update
+	m_nextGroupUpdate -= deltaTime;
+	if(m_nextGroupUpdate < 0.0f)
+	{
+		m_nextGroupUpdate = 3.0f;
+		HandleGroups();
+	}
+
+	//Master AI Update
+	m_nextUpdate -= deltaTime;
+	if(m_nextUpdate < 0.0f)
+	{
+		m_nextUpdate = 10.0f;		
+		MasterAI();
+	}
+}
+
+void MASTERAI::HandleGroups()
+{
+	//Add unassigned units/buildings to the unit pool
+	for(int m=0;m<(int)m_pPlayer->m_mapObjects.size();m++)
+		if(m_pPlayer->m_mapObjects[m] != NULL && !m_pPlayer->m_mapObjects[m]->m_dead)
+			if(m_pPlayer->m_mapObjects[m]->m_pGroup == NULL)
+				m_unitPool.AddMember(m_pPlayer->m_mapObjects[m]);
+
+	//Update unit Pool
+	m_base = m_pPlayer->GetBaseArea();
+	m_unitPool.SetTask(TASK_DEFEND_LOCATION, &m_base);
+	m_unitPool.GroupAI();
+
+	//Update other groups
+	for(int i=0; i<(int)m_groups.size(); i++)
+	{
+		m_groups[i]->GroupAI();
+	}
+
+	//Remove dead groups
+	for(int i=0; i<(int)m_groups.size(); i++)
+	{
+		if(m_groups[i]->isDead())
+		{
+			delete m_groups[i];
+			m_groups.erase(m_groups.begin() + i);
+			break;
+		}
+	}
+}
+
+void MASTERAI::MasterAI()
+{
+	//Update Influence map
+	if(m_pStrategyMap != NULL)
+		m_pStrategyMap->Update(m_visibleEnemies);
+
+	m_visibleEnemies.clear();
+
+	//Build buildings and train units
+	BuildManager();
+
+	//Command units
+	StrategicManager();
+}
+
+void MASTERAI::BuildManager()
+{
+	//Count number of buildings and units
+	int totNumUnits = 0;
+	int numUnits[3] = {0, 0, 0};
+	int numBuildings[3] = {0, 0, 0};
+
+	for(int i=0;i<(int)m_pPlayer->m_mapObjects.size();i++)
+		if(m_pPlayer->m_mapObjects[i] != NULL)
+		{
+			if(m_pPlayer->m_mapObjects[i]->m_isBuilding)
+				numBuildings[m_pPlayer->m_mapObjects[i]->m_type]++;
+			else 
+			{
+				numUnits[m_pPlayer->m_mapObjects[i]->m_type]++;
+				totNumUnits++;
+			}
+		}
+
+	//Cant train more units than the unit limit
+	if(totNumUnits >= m_pPlayer->unitLimit)
+		return;
+
+	//Unit Ratio to maintain
+	float unitRatio[] = {0.1f, 0.5f, 0.4f};
+
+	float greatestDifference = -1.0f;
+	int nextUnitToBuild = -1;
+
+	//Calculate unit difference
+	for(int i=0;i<3;i++)
+	{
+		int aim = (int)(unitRatio[i] * totNumUnits);
+		float diff = (aim - numUnits[i]) / (float)totNumUnits;
+
+		if(diff > greatestDifference)
+		{
+			greatestDifference = diff;
+			nextUnitToBuild = i;
+		}
+	}
+
+	//Get Proper action
+	AI_ACTION *action = new TRAIN_UNIT(nextUnitToBuild);
+	AI_ACTION *preAction = NULL;
+
+	do
+	{
+		preAction = action->RequiresAction(m_pPlayer);		
+		if(preAction != NULL)
+		{
+			delete action;
+			action = preAction;
+		}
+	}
+	while(preAction != NULL);
+
+	//Perform action
+	if(action != NULL)
+	{
+		action->PerformAction(m_pPlayer);
+		delete action;
+	}
+}
+
+void MASTERAI::StrategicManager()
+{
+	int numScoutGroups = 0;
+	int numAttackGroups = 0;
+
+	for(int i=0;i<(int)m_groups.size();i++)
+	{
+		if(m_groups[i]->m_task == TASK_SCOUT)
+			numScoutGroups++;
+		else if(m_groups[i]->m_task == TASK_ATTACK_LOCATION)
+			numAttackGroups++;
+	}
+
+	//Create Scout Group
+	if(m_unitPool.m_members.size() > 4 && numScoutGroups < 2)
+	{
+		AREA* area = m_pStrategyMap->GetScoutArea(m_pPlayer->m_teamStartLocation);
+
+		if(area != NULL)
+		{
+			std::vector<int> unit;
+			unit.push_back(WARRIOR);
+			GROUPAI *newGroup = m_unitPool.SplitGroup(unit);
+
+			if(newGroup != NULL)
+			{				
+				newGroup->SetTask(TASK_SCOUT, &area->m_mapArea);
+				m_groups.push_back(newGroup);
+			}
+		}
+	}
+
+	//Small attack
+	if(m_unitPool.m_members.size() > 8 && numAttackGroups == 0)
+	{
+		AREA *attackArea = m_pStrategyMap->GetAttackArea(m_pPlayer->m_teamStartLocation);
+		int numWarriors = 3 + rand()%4;
+
+		std::vector<int> units;
+		for(int i=0;i<numWarriors;i++)
+			units.push_back(WARRIOR);
+
+		//Create attack group
+		GROUPAI *newGroup = m_unitPool.SplitGroup(units);
+
+		if(attackArea->Connected(m_pTerrain, newGroup->GetCenter()))
+		{
+			newGroup->SetTask(TASK_ATTACK_LOCATION, &attackArea->m_mapArea);
+			m_groups.push_back(newGroup);
+		}
+		else
+		{
+			newGroup->DisbandGroup();
+			delete newGroup;
+		}
+	}
+}
+
+void MASTERAI::EnemiesSpotted(std::vector<MAPOBJECT*> &manyEnemies)
+{
+	if(m_visibleEnemies.size() >= 30)return;
+
+	for(int i=0;i<(int)manyEnemies.size();i++)
+		m_visibleEnemies.insert(manyEnemies[i]);
+}
\ No newline at end of file
diff --git a/code/train/C++/0046375_code.cpp b/code/train/C++/0046375_code.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a0700a4641fb0e1d6b09152be079f699e6c87934
--- /dev/null
+++ b/code/train/C++/0046375_code.cpp
@@ -0,0 +1,19 @@
+class Solution {
+private:
+    vector<vector<int>> ans;
+public:
+    vector<vector<int>> subsets(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        vector<int> myans;
+        dfs(nums, myans, 0);
+        return ans;
+    }
+    void dfs(vector<int>& nums, vector<int>& myans, int pos) {
+        ans.push_back(myans);
+        for (int i = pos; i < nums.size(); i++) {
+            myans.push_back(nums[i]);
+            dfs(nums, myans, i + 1);
+            myans.pop_back();
+        }
+    }
+};
diff --git a/code/train/C++/0046602_graminfo.cc b/code/train/C++/0046602_graminfo.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ffc0eefc5fa1da2f42c086b8b8a68cb86fe1b4f4
--- /dev/null
+++ b/code/train/C++/0046602_graminfo.cc
@@ -0,0 +1,172 @@
+//////////////////////////////////////////////////////////////////////////////
+// NOTICE:
+//
+// ADLib, Prop and their related set of tools and documentation are in the
+// public domain.   The author(s) of this software reserve no copyrights on
+// the source code and any code generated using the tools.  You are encouraged
+// to use ADLib and Prop to develop software, in both academic and commercial
+// settings, and are free to incorporate any part of ADLib and Prop into
+// your programs.
+//
+// Although you are under no obligation to do so, we strongly recommend that
+// you give away all software developed using our tools.
+//
+// We also ask that credit be given to us when ADLib and/or Prop are used in
+// your programs, and that this notice be preserved intact in all the source
+// code.
+//
+// This software is still under development and we welcome any suggestions
+// and help from the users.
+//
+// Allen Leung
+// 1994
+//////////////////////////////////////////////////////////////////////////////
+
+#include <cstring>
+#include <AD/automata/graminfo.h>
+#include <AD/sort/shellsrt.h>  // Shell sort
+
+Bool add_set( register int i, register Byte * a_set, register Byte * b_set)
+{
+  register Byte changed;
+  for (changed = 0; i > 0; i--, a_set++, b_set++)
+  {
+    changed |= ~ *a_set & *b_set;
+    *a_set |= *b_set;
+  }
+  return changed;
+}
+
+void GrammarInfo::compute_info( const Grammar& G)
+{
+  register Production P;
+  register Symbol X;
+  register int i;
+
+  clear_info();
+
+  min_non_terminal  = 32767;
+  max_non_terminal  = -32768;
+
+  //
+  // Preprocess the grammar; compute the following information:
+  //
+  //   max_non_terminal  -- maximal value of a non-terminal
+  //   min_non_terminal  -- minimal value of a non-terminal
+  //   productions[i]    -- an array of productions terminated by
+  //                           Grammar::END_PRODUCTION
+  //
+
+  productions = new Production [ G.size() ];
+
+  for (i = 0; i < G.size(); i++)
+  {
+    P = productions[i] = G[i];
+    while ( (X = *P++) != Grammar::END_PRODUCTION)
+    {
+      if (G.isNonTerminal(X))
+      {
+        if (X > max_non_terminal)
+          max_non_terminal = X;
+        if (X < min_non_terminal)
+          min_non_terminal = X;
+      }
+    }
+  }
+  production_size = i;
+
+  //
+  // Sort by left hand side non-terminal
+  //
+  shellSort(Production, productions, G.size(),
+            key[0] < productions[i][0] );
+
+  //
+  // compute the amount of storage needed to store the tables:
+  //
+  number_of_non_terminals = max_non_terminal - min_non_terminal + 1;
+  nullable = new Bool [ number_of_non_terminals ];
+  std::memset(nullable,0,number_of_non_terminals * sizeof(Bool));
+  nullable -= min_non_terminal;
+
+  first.create(min_non_terminal,max_non_terminal,G.min_terminal(),G.max_terminal());
+  follow.create(min_non_terminal,max_non_terminal,G.min_terminal(),G.max_terminal());
+
+  //
+  // Iterate and compute the fix points of first and follow and nullable:
+  //
+  //   For each A -> X_1 X_2 ... X_n
+  //
+  //   nullable(A) = /\_i nullable(X_i)
+  //   Let first(c)    = { c }
+  //   first(A)    <- first(X_i) if nullable(X_1 X_2 ... X_{i-1} c)
+  //   follow(X_i) <- first(X_{i+1})
+  //
+  //
+  Bool changed;
+  do
+  {
+    changed = false;
+    for (i = G.size() - 1; i >= 0; i--)
+    {
+      register NonTerminal A;
+      register Symbol Y = max_non_terminal + 1;  // Last symbol
+      Bool epsilon = true;
+      for ( P = productions[i], A = *P++; (X = *P) != END_PRODUCTION; P++)
+      {
+        if (G.isAction(X))
+        {           // X is an action symbol; skip it
+        }
+        else if (G.isTerminal(X))
+        {  // X is a terminal
+          if (G.isNonTerminal(Y) && ! follow.has(Y,X))
+          {
+            follow.insert(Y,X);
+            changed = true;
+          }
+          if (epsilon && ! first.has(A,X))
+          {
+            first.insert(A,X);
+            changed = true;
+          }
+          epsilon = false;
+          Y = X;
+        }
+        else
+        {                       // X is a nonterminal
+          if (G.isNonTerminal(Y) &&
+              add_set(first.set_size(),follow(X),first(Y)))
+            changed = true;
+          if (epsilon && add_set(first.set_size(),first(A),first(X)))
+            changed = true;
+          if (! nullable[X])
+            epsilon = false;
+          Y = X;
+        }
+      }
+      if (epsilon && ! nullable[A])
+      {
+        nullable[A] = true;
+        changed = true;
+      }
+    }
+  }
+  while (changed);
+}
+
+void GrammarInfo::clear_info()
+{
+  if (nullable)
+  {
+    delete [] productions;
+    delete [] (nullable + min_non_terminal);
+    first.destroy();
+    follow.destroy();
+    nullable = 0;
+  }
+}
+
+GrammarInfo::~GrammarInfo()
+{
+  clear_info();
+}
diff --git a/code/train/C++/0049217_genheightfield.cc b/code/train/C++/0049217_genheightfield.cc
new file mode 100644
index 0000000000000000000000000000000000000000..79b10cca269927974353dd500b062add7f2caa05
--- /dev/null
+++ b/code/train/C++/0049217_genheightfield.cc
@@ -0,0 +1,80 @@
+//
+// Heightfield generator for program 3
+// The heightfield for the test scene was generated by this program
+// at a resolution of 200x200 (201x201 data points)
+//
+// Note: because this makes a binary file, you must generate the data
+// on a machine with the same endianness as your renderer.  The easiest
+// way to ensure this is to use the same machine.
+// Note 2: I know that windows handles binary files strangely, so be
+// careful
+// 
+
+// I used the following code to read the data in:
+//   ifstream in(filename.c_str());
+//   if(!in){
+//     cerr << "Error opening " << filename << "\n";
+//     exit(1);
+//   double minz, maxz;
+//   in >> nx >> ny >> minz >> maxz;
+//   if(!in){
+//     cerr << "Error reading hader from " << filename << "\n";
+//     exit(1);
+//   }
+//   in.get();
+//   float** data = new float*[nx+1];
+//   float* p = new float[(nx+1)*(ny+1)];
+//   for(int i=0;i<=nx;i++)
+//     data[i] = p+i*(ny+1);
+//   in.read(data[0], sizeof(float)*(nx+1)*(ny+1));
+//   if(!in){
+//     cerr << "Error reading data from " << filename << "\n";
+//     exit(1);
+//   }
+
+
+#include <float.h>
+#include <fstream>
+#include <iostream>
+using namespace std;
+
+static float f(double x, double y)
+{
+  // return 3;
+  // return y+2;
+  double r2 = (x*x+y*y)*16;
+  if(r2 > -1.e-12 && r2 < 1.e-12)
+    return 4;
+  else
+    return sin(r2)/r2+3;
+}
+
+int main(int argc, char* argv[])
+{
+  if(argc != 4){
+    cerr << "Usage: " << argv[0] << " nx ny filename\n";
+    exit(1);
+  }
+  int nx=atoi(argv[1]);
+  int ny=atoi(argv[2]);
+  float** data = new float*[nx+1];
+  float* p = new float[(nx+1)*(ny+1)];
+  for(int i=0;i<=nx;i++)
+    data[i] = p+i*(ny+1);
+  float maxz = -FLT_MAX;
+  float minz = FLT_MAX;
+  for(int i=0;i<=nx;i++){
+    double x = double(i)/nx*2-1;
+    for(int j=0;j<=ny;j++){
+      double y = double(j)/ny*2-1;
+      data[i][j] = f(x, y);
+      if(data[i][j] < minz)
+        minz = data[i][j];
+      if(data[i][j] > maxz)
+        maxz = data[i][j];
+    }
+  }
+  ofstream out(argv[3]);
+  out << nx << " " << ny << " " << minz << " " << maxz << " ";
+  out.write(reinterpret_cast<char*>(data[0]), sizeof(float)*(nx+1)*(ny+1));
+}
diff --git a/code/train/C++/0051265_AI_Player.cpp b/code/train/C++/0051265_AI_Player.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a29ca0c9e6af1eba883e50a58022f025581fddcc
--- /dev/null
+++ b/code/train/C++/0051265_AI_Player.cpp
@@ -0,0 +1,113 @@
+#include "AI_Player.hpp"
+
+AI_Player::AI_Player() :GameEntity(Tag::AI), _islandMap(NULL), Actor(Tag::AI_SHIP), _guiText(NULL)
+{
+	this->ai_islands = IslandsMap::Islands();
+	this->target_islands = IslandsMap::Islands();
+	myUnits = 0;
+	lastAttackTime = 0.0f;
+	lastIslandAttacking = NULL;
+}
+
+void AI_Player::load()
+{
+	_guiText = new GUIText();
+	_guiText->init(10, 10, ResourcesPaths::kTextAtlas);
+	_guiText->setPosition(glm::vec3(-133, -93, 0));
+	_guiText->setScale(glm::vec3(9.f, 3.4f, 1.f));
+	_guiText->setText("AI Ships: 1");
+}
+
+
+void AI_Player::update()
+{
+	//update ships information:
+	ai_islands.clear();
+	target_islands.clear();
+	_islandMap->getIslandsByOwnerTags(target_islands, 2, (int)Tag::NEUTRAL, (int)Tag::PLAYER);
+	myUnits = 0;
+	this->_islandMap->getIslandsByOwnerTag(ai_islands, Tag::AI);
+	
+	//update attack time
+	lastAttackTime -= Time::getDeltatime();
+	/* @TODO: Add logic to choose the best neighbour based on balanced trees or redblacktree */
+	//Do we have islands to move to?
+	if (ai_islands.size() > 0 && target_islands.size() > 0)
+	{
+		float min_distance = 9999;
+		int max_units = 0;
+		Island *best_attacker_island = NULL;
+		int withUnits = 0;
+		glm::vec3 p = getPosition();
+		myUnits = 0;
+		for (Island* ai_island : ai_islands)
+		{
+			int nUnits = ai_island->getUnits();
+			myUnits += nUnits;
+
+			/*if (ai_island != lastIslandAttacking && ai_island->isTimeForLaunch() && lastAttackTime <= 0 && nUnits > 0)
+			{
+				lastIslandAttacking = ai_island;
+			}
+			else {
+				break;
+			}*/
+			//consider this island as next island attacker neighbours?
+			if (
+				((ai_islands.size()>1 && ai_island != lastIslandAttacking ) || ai_islands.size()==1) && 
+				ai_island->isTimeForAILaunch() && nUnits > 0)
+			{
+				const glm::vec3 dest = ai_island->getPosition();
+				float d = std::sqrt( //get distance to this target island from the ai island
+					((dest.x - p.x)*(dest.x - p.x)) +
+					((dest.y - p.y)*(dest.y - p.y))
+					);
+				if (d < min_distance && nUnits > max_units){
+					min_distance = d;
+					best_attacker_island = ai_island;
+					withUnits = nUnits;
+				}
+			}
+		}
+		
+		if (lastAttackTime <= 0 && best_attacker_island != NULL){
+			lastIslandAttacking = best_attacker_island;
+			target_islands.clear();
+			_islandMap->getIslandsByOwnerTags(target_islands, 2, (int)Tag::NEUTRAL, (int)Tag::PLAYER);
+			lastAttackTime = timeBetweenAttacks;
+
+			if (target_islands.size() > 0){
+				best_attacker_island->launchShipUnits(withUnits, target_islands[
+					(int)MathUtils::rand(0, (int) target_islands.size())
+				], this);
+				//std::cout << "AI:: Sending " << nUnits << "\n";
+			}
+		}
+		
+	}
+	//std::cout << ai_islands.size() << " : " << target_islands.size() << "\n";
+	//update AI units count
+	std::stringstream s;
+	s << "AI Units: " << myUnits;
+	_guiText->setText(s.str());
+}
+
+
+void AI_Player::render(){
+	//render ai units objects:
+	glm::mat4 textLocalToWorld = _guiText->getModel();
+	glLoadMatrixf(&textLocalToWorld[0][0]);
+	_guiText->render();
+}
+
+void AI_Player::setIslandMap(IslandsMap& islandMap){
+	this->_islandMap = &islandMap;
+}
+
+AI_Player::~AI_Player()
+{
+	//delete ai_islands;
+	if (_guiText){
+		delete _guiText;
+	}
+}
diff --git a/code/train/C++/0051280_gal_combine.cpp b/code/train/C++/0051280_gal_combine.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..21aae3115367c0a1db7b25af9a49df418049675c
--- /dev/null
+++ b/code/train/C++/0051280_gal_combine.cpp
@@ -0,0 +1,129 @@
+/******************************************************************************
+ * gal_combine.cpp 
+ *
+ * Source of KaHIP -- Karlsruhe High Quality Partitioning.
+ *
+ ******************************************************************************
+ * Copyright (C) 2013-2015 Christian Schulz <christian.schulz@kit.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 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, see <http://www.gnu.org/licenses/>.
+ *****************************************************************************/
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+
+#include "construct_partition.h"
+#include "gal_combine.h"
+#include "graph_partitioner.h"
+#include "random_functions.h"
+#include "uncoarsening/refinement/cycle_improvements/cycle_refinement.h"
+#include "uncoarsening/refinement/mixed_refinement.h"
+#include "uncoarsening/refinement/refinement.h"
+#include "uncoarsening/refinement/tabu_search/tabu_search.h"
+
+gal_combine::gal_combine() {
+                
+}
+
+gal_combine::~gal_combine() {
+                
+}
+
+
+// implements our version of gal combine
+// compute a matching between blocks (greedily) 
+// extend to partition
+// apply our refinements and tabu search
+void gal_combine::perform_gal_combine( PartitionConfig & config, graph_access & G) {
+        //first greedily compute a matching of the partitions
+        std::vector< std::unordered_map<PartitionID, unsigned> > counters(config.k);
+        forall_nodes(G, node) {
+                //boundary_pair bp;
+                if(counters[G.getPartitionIndex(node)].find(G.getSecondPartitionIndex(node)) != counters[G.getPartitionIndex(node)].end()) {
+                        counters[G.getPartitionIndex(node)][G.getSecondPartitionIndex(node)] += 1;
+                } else {
+                        counters[G.getPartitionIndex(node)][G.getSecondPartitionIndex(node)] = 1;
+                }
+        } endfor
+
+        std::vector< PartitionID > permutation(config.k);
+        for( unsigned i = 0; i < permutation.size(); i++) {
+                permutation[i] = i;
+        }
+
+        random_functions::permutate_vector_good_small(permutation); 
+        std::vector<bool> rhs_matched(config.k, false);
+        std::vector<PartitionID> bipartite_matching(config.k);
+        for( unsigned i = 0; i < permutation.size(); i++) {
+                PartitionID cur_partition   = permutation[i];
+                PartitionID best_unassigned = config.k;
+                NodeWeight  best_value      = 0;
+
+                for( std::unordered_map<PartitionID, unsigned>::iterator it = counters[cur_partition].begin(); 
+                     it != counters[cur_partition].end(); ++it) {
+                        if( rhs_matched[it->first] == false && it->second > best_value ) {
+                                best_unassigned = it->first; 
+                                best_value = it->second;
+                        }
+                }
+
+                bipartite_matching[cur_partition] = best_unassigned;
+                if( best_unassigned != config.k ) {
+                        rhs_matched[best_unassigned] = true;
+                }
+        }
+
+        std::vector<bool> blocked_vertices(G.number_of_nodes(), false);
+        forall_nodes(G, node) {
+                if( bipartite_matching[G.getPartitionIndex(node)] == G.getSecondPartitionIndex(node) ){
+                        blocked_vertices[node] = true;
+                } else {
+                        // we will reassign this vertex since the partitions do not agree on it
+                        G.setPartitionIndex(node, config.k); 
+                }
+        } endfor
+
+        construct_partition cp;
+        cp.construct_starting_from_partition( config, G );
+
+        refinement* refine = new mixed_refinement();
+
+        double real_epsilon = config.imbalance/100.0;
+        double epsilon = random_functions::nextDouble(real_epsilon+0.005,real_epsilon+config.kabaE_internal_bal); 
+        PartitionConfig copy = config;
+        copy.upper_bound_partition = (1+epsilon)*ceil(config.work_load/(double)config.k);
+
+        complete_boundary boundary(&G);
+        boundary.build();
+
+        tabu_search ts;
+        ts.perform_refinement( copy, G, boundary);
+        
+        //now obtain the quotient graph
+        complete_boundary boundary2(&G);
+        boundary2.build();
+
+        copy = config;
+        copy.upper_bound_partition = (1+epsilon)*ceil(config.work_load/(double)config.k);
+
+        refine->perform_refinement( copy, G, boundary2);
+
+        copy = config;
+        cycle_refinement cr;
+        cr.perform_refinement(config, G, boundary2);
+        delete refine;
+
+        
+}
diff --git a/code/train/C++/0051337_HexagonVExtract.cpp b/code/train/C++/0051337_HexagonVExtract.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b7d6dbe21c7433aa148d27e2afcacd3d9e0f0339
--- /dev/null
+++ b/code/train/C++/0051337_HexagonVExtract.cpp
@@ -0,0 +1,195 @@
+//===- HexagonVExtract.cpp ------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// This pass will replace multiple occurrences of V6_extractw from the same
+// vector register with a combination of a vector store and scalar loads.
+//===----------------------------------------------------------------------===//
+
+#include "Hexagon.h"
+#include "HexagonInstrInfo.h"
+#include "HexagonMachineFunctionInfo.h"
+#include "HexagonRegisterInfo.h"
+#include "HexagonSubtarget.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/PassSupport.h"
+#include "llvm/CodeGen/MachineBasicBlock.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/MachineInstrBuilder.h"
+#include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/Support/CommandLine.h"
+
+#include <map>
+
+using namespace llvm;
+
+static cl::opt<unsigned> VExtractThreshold("hexagon-vextract-threshold",
+  cl::Hidden, cl::ZeroOrMore, cl::init(1),
+  cl::desc("Threshold for triggering vextract replacement"));
+
+namespace llvm {
+  void initializeHexagonVExtractPass(PassRegistry& Registry);
+  FunctionPass *createHexagonVExtract();
+}
+
+namespace {
+  class HexagonVExtract : public MachineFunctionPass {
+  public:
+    static char ID;
+    HexagonVExtract() : MachineFunctionPass(ID) {}
+
+    StringRef getPassName() const override {
+      return "Hexagon optimize vextract";
+    }
+    void getAnalysisUsage(AnalysisUsage &AU) const override {
+      MachineFunctionPass::getAnalysisUsage(AU);
+    }
+    bool runOnMachineFunction(MachineFunction &MF) override;
+
+  private:
+    const HexagonSubtarget *HST = nullptr;
+    const HexagonInstrInfo *HII = nullptr;
+
+    unsigned genElemLoad(MachineInstr *ExtI, unsigned BaseR,
+                         MachineRegisterInfo &MRI);
+  };
+
+  char HexagonVExtract::ID = 0;
+}
+
+INITIALIZE_PASS(HexagonVExtract, "hexagon-vextract",
+  "Hexagon optimize vextract", false, false)
+
+unsigned HexagonVExtract::genElemLoad(MachineInstr *ExtI, unsigned BaseR,
+                                      MachineRegisterInfo &MRI) {
+  MachineBasicBlock &ExtB = *ExtI->getParent();
+  DebugLoc DL = ExtI->getDebugLoc();
+  Register ElemR = MRI.createVirtualRegister(&Hexagon::IntRegsRegClass);
+
+  Register ExtIdxR = ExtI->getOperand(2).getReg();
+  unsigned ExtIdxS = ExtI->getOperand(2).getSubReg();
+
+  // Simplified check for a compile-time constant value of ExtIdxR.
+  if (ExtIdxS == 0) {
+    MachineInstr *DI = MRI.getVRegDef(ExtIdxR);
+    if (DI->getOpcode() == Hexagon::A2_tfrsi) {
+      unsigned V = DI->getOperand(1).getImm();
+      V &= (HST->getVectorLength()-1) & -4u;
+
+      BuildMI(ExtB, ExtI, DL, HII->get(Hexagon::L2_loadri_io), ElemR)
+        .addReg(BaseR)
+        .addImm(V);
+      return ElemR;
+    }
+  }
+
+  Register IdxR = MRI.createVirtualRegister(&Hexagon::IntRegsRegClass);
+  BuildMI(ExtB, ExtI, DL, HII->get(Hexagon::A2_andir), IdxR)
+    .add(ExtI->getOperand(2))
+    .addImm(-4);
+  BuildMI(ExtB, ExtI, DL, HII->get(Hexagon::L4_loadri_rr), ElemR)
+    .addReg(BaseR)
+    .addReg(IdxR)
+    .addImm(0);
+  return ElemR;
+}
+
+bool HexagonVExtract::runOnMachineFunction(MachineFunction &MF) {
+  HST = &MF.getSubtarget<HexagonSubtarget>();
+  HII = HST->getInstrInfo();
+  const auto &HRI = *HST->getRegisterInfo();
+  MachineRegisterInfo &MRI = MF.getRegInfo();
+  MachineFrameInfo &MFI = MF.getFrameInfo();
+  Register AR =
+      MF.getInfo<HexagonMachineFunctionInfo>()->getStackAlignBaseVReg();
+  std::map<unsigned, SmallVector<MachineInstr*,4>> VExtractMap;
+  unsigned MaxAlign = 0;
+  bool Changed = false;
+
+  for (MachineBasicBlock &MBB : MF) {
+    for (MachineInstr &MI : MBB) {
+      unsigned Opc = MI.getOpcode();
+      if (Opc != Hexagon::V6_extractw)
+        continue;
+      Register VecR = MI.getOperand(1).getReg();
+      VExtractMap[VecR].push_back(&MI);
+    }
+  }
+
+  auto EmitAddr = [&] (MachineBasicBlock &BB, MachineBasicBlock::iterator At,
+                       DebugLoc dl, int FI, unsigned Offset) {
+    Register AddrR = MRI.createVirtualRegister(&Hexagon::IntRegsRegClass);
+    unsigned FiOpc = AR != 0 ? Hexagon::PS_fia : Hexagon::PS_fi;
+    auto MIB = BuildMI(BB, At, dl, HII->get(FiOpc), AddrR);
+    if (AR)
+      MIB.addReg(AR);
+    MIB.addFrameIndex(FI).addImm(Offset);
+    return AddrR;
+  };
+
+  for (auto &P : VExtractMap) {
+    unsigned VecR = P.first;
+    if (P.second.size() <= VExtractThreshold)
+      continue;
+
+    const auto &VecRC = *MRI.getRegClass(VecR);
+    unsigned Align = HRI.getSpillAlignment(VecRC);
+    MaxAlign = std::max(MaxAlign, Align);
+    // Make sure this is not a spill slot: spill slots cannot be aligned
+    // if there are variable-sized objects on the stack. They must be
+    // accessible via FP (which is not aligned), because SP is unknown,
+    // and AP may not be available at the location of the load/store.
+    int FI = MFI.CreateStackObject(HRI.getSpillSize(VecRC), Align,
+                                   /*isSpillSlot*/false);
+
+    MachineInstr *DefI = MRI.getVRegDef(VecR);
+    MachineBasicBlock::iterator At = std::next(DefI->getIterator());
+    MachineBasicBlock &DefB = *DefI->getParent();
+    unsigned StoreOpc = VecRC.getID() == Hexagon::HvxVRRegClassID
+                          ? Hexagon::V6_vS32b_ai
+                          : Hexagon::PS_vstorerw_ai;
+    Register AddrR = EmitAddr(DefB, At, DefI->getDebugLoc(), FI, 0);
+    BuildMI(DefB, At, DefI->getDebugLoc(), HII->get(StoreOpc))
+      .addReg(AddrR)
+      .addImm(0)
+      .addReg(VecR);
+
+    unsigned VecSize = HRI.getRegSizeInBits(VecRC) / 8;
+
+    for (MachineInstr *ExtI : P.second) {
+      assert(ExtI->getOpcode() == Hexagon::V6_extractw);
+      unsigned SR = ExtI->getOperand(1).getSubReg();
+      assert(ExtI->getOperand(1).getReg() == VecR);
+
+      MachineBasicBlock &ExtB = *ExtI->getParent();
+      DebugLoc DL = ExtI->getDebugLoc();
+      Register BaseR = EmitAddr(ExtB, ExtI, ExtI->getDebugLoc(), FI,
+                                SR == 0 ? 0 : VecSize/2);
+
+      unsigned ElemR = genElemLoad(ExtI, BaseR, MRI);
+      Register ExtR = ExtI->getOperand(0).getReg();
+      MRI.replaceRegWith(ExtR, ElemR);
+      ExtB.erase(ExtI);
+      Changed = true;
+    }
+  }
+
+  if (AR) {
+    // Update the required stack alignment.
+    MachineInstr *AlignaI = MRI.getVRegDef(AR);
+    assert(AlignaI->getOpcode() == Hexagon::PS_aligna);
+    MachineOperand &Op = AlignaI->getOperand(1);
+    if (MaxAlign > Op.getImm())
+      Op.setImm(MaxAlign);
+  }
+
+  return Changed;
+}
+
+FunctionPass *llvm::createHexagonVExtract() {
+  return new HexagonVExtract();
+}
diff --git a/code/train/C++/0051824_259_3Sum_Smaller.cpp b/code/train/C++/0051824_259_3Sum_Smaller.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e83d11081901ded19825c2dda173bfd07ae88932
--- /dev/null
+++ b/code/train/C++/0051824_259_3Sum_Smaller.cpp
@@ -0,0 +1,50 @@
+class Solution {
+public:
+    int threeSumSmaller(vector<int>& nums, int target) {
+        int sum = 0;
+        sort(nums.begin(), nums.end());
+        for (int i = 0; i < (long)nums.size() - 2; i++) {
+            sum += twoSumSmaller(nums, i + 1, target - nums[i]);
+        }
+        return sum;
+    }
+    int twoSumSmaller(vector<int>& nums, int start, int target) {
+        int sum = 0;
+        /*
+        for (int i = start; i < (long)nums.size() - 1; i++) {
+            vector<int>::iterator find = lower_bound(nums.begin() + i + 1, nums.end(), target - nums[i]);
+                sum += find - nums.begin() - i - 1;
+        }
+        */
+        /*
+        for (int i = start; i < (long)nums.size() - 1; i++) {
+            int find = binarySearchLB(nums, i + 1, target - nums[i]);
+            sum += find - i - 1;
+        }
+        */
+        // other than using binary search we can apply two pointers
+        int left = start;
+        int right = nums.size() - 1;
+        while (left < right) {
+            if (nums[left] + nums[right] < target) {
+                sum += right - left;
+                left++;
+            } else {
+                right--;
+            }
+        }
+        return sum;
+    }
+    int binarySearchLB(vector<int>& nums, int start, int target) {
+        int end = nums.size() - 1;
+        while (start <= end) {
+            int mid = (start + end) / 2;
+            if (nums[mid] < target) {
+                start = mid + 1;
+            } else {
+                end = mid - 1;
+            }
+        }
+        return start;
+    }
+};
\ No newline at end of file
diff --git a/code/train/C++/0051968_sort_array_by_parity_II.better.cpp b/code/train/C++/0051968_sort_array_by_parity_II.better.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f191a69686696ebec13a26b7b86e3c340fcb16d5
--- /dev/null
+++ b/code/train/C++/0051968_sort_array_by_parity_II.better.cpp
@@ -0,0 +1,47 @@
+/*******************************************************************************
+ *      file name: sort_array_by_parity_II.cpp                                               
+ *         author: Hui Chen. (c) 2019                             
+ *           mail: chenhui13@baidu.com                                        
+ *   created time: 2019/01/23-14:03:53                              
+ *  modified time: 2019/01/23-14:03:53                              
+ *******************************************************************************/
+#include <iostream>
+#include <vector>
+using namespace std;
+class Solution {
+public:
+    vector<int> sortArrayByParityII(vector<int>& A) {
+		int size = A.size();
+		int even = 0, odd = 1;
+		for (int i =0; i < size; i++)
+		{
+			if (A[i] % 2 == 0) 
+			{
+                if (i % 2 == 0)
+                    continue;
+                while (A[even] % 2 == 0)
+                    even += 2;
+				swap(A[even], A[i]);
+				even += 2;
+			}
+			else
+			{
+                if (i % 2 == 1)
+                    continue;
+                while (A[odd] % 2 == 1)
+                    odd += 2;
+			    swap(A[odd], A[i]);
+                odd += 2;           
+			}
+            /*
+            cout<<i;
+            for (int j = 0; j < size; j++)
+                cout<<"  A["<<j<<"]"<<A[j]<<" ";       
+            cout<<endl;
+            */
+		}
+		return A;
+    }
+};
+int main()
+{}
diff --git a/code/train/C++/0052253_elkan_kmeans.cpp b/code/train/C++/0052253_elkan_kmeans.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1e45d364f0b5963ce70477fd9b5b196de26cafef
--- /dev/null
+++ b/code/train/C++/0052253_elkan_kmeans.cpp
@@ -0,0 +1,121 @@
+/* Authors: Greg Hamerly and Jonathan Drake
+ * Feedback: hamerly@cs.baylor.edu
+ * See: http://cs.baylor.edu/~hamerly/software/kmeans.php
+ * Copyright 2014
+ */
+
+#include "elkan_kmeans.h"
+#include "general_functions.h"
+#include <cmath>
+
+void ElkanKmeans::update_center_dists(int threadId) {
+    // find the inter-center distances
+    for (int c1 = 0; c1 < k; ++c1) {
+        if (c1 % numThreads == threadId) {
+            s[c1] = std::numeric_limits<double>::max();
+
+            for (int c2 = 0; c2 < k; ++c2) {
+                // we do not need to consider the case when c1 == c2 as centerCenterDistDiv2[c1*k+c1]
+                // is equal to zero from initialization, also this distance should not be used for s[c1]
+                if (c1 != c2) {
+                    // divide by 2 here since we always use the inter-center
+                    // distances divided by 2
+                    centerCenterDistDiv2[c1 * k + c2] = sqrt(centerCenterDist2(c1, c2)) / 2.0;
+
+                    if (centerCenterDistDiv2[c1 * k + c2] < s[c1]) {
+                        s[c1] = centerCenterDistDiv2[c1 * k + c2];
+                    }
+                }
+            }
+        }
+    }
+}
+
+int ElkanKmeans::runThread(int threadId, int maxIterations) {
+    int iterations = 0;
+
+    int startNdx = start(threadId);
+    int endNdx = end(threadId);
+
+    while ((iterations < maxIterations) && ! converged) {
+        ++iterations;
+
+        update_center_dists(threadId);
+        synchronizeAllThreads();
+
+        for (int i = startNdx; i < endNdx; ++i) {
+            unsigned short closest = assignment[i];
+            bool r = true;
+
+            if (upper[i] <= s[closest]) {
+                continue;
+            }
+
+            for (int j = 0; j < k; ++j) {
+                if (j == closest) { continue; }
+                if (upper[i] <= lower[i * k + j]) { continue; }
+                if (upper[i] <= centerCenterDistDiv2[closest * k + j]) { continue; }
+
+                // ELKAN 3(a)
+                if (r) {
+                    upper[i] = sqrt(pointCenterDist2(i, closest));
+                    lower[i * k + closest] = upper[i];
+                    r = false;
+                    if ((upper[i] <= lower[i * k + j]) || (upper[i] <= centerCenterDistDiv2[closest * k + j])) {
+                        continue;
+                    }
+                }
+
+                // ELKAN 3(b)
+                lower[i * k + j] = sqrt(pointCenterDist2(i, j));
+                if (lower[i * k + j] < upper[i]) {
+                    closest = j;
+                    upper[i] = lower[i * k + j];
+                }
+            }
+            if (assignment[i] != closest) {
+                changeAssignment(i, closest, threadId);
+            }
+        }
+
+        verifyAssignment(iterations, startNdx, endNdx);
+
+        // ELKAN 4, 5, AND 6
+        synchronizeAllThreads();
+        if (threadId == 0) {
+            int furthestMovingCenter = move_centers();
+            converged = (0.0 == centerMovement[furthestMovingCenter]);
+        }
+
+        synchronizeAllThreads();
+        if (! converged) {
+            update_bounds(startNdx, endNdx);
+        }
+        synchronizeAllThreads();
+    }
+
+    return iterations;
+}
+
+void ElkanKmeans::update_bounds(int startNdx, int endNdx) {
+    for (int i = startNdx; i < endNdx; ++i) {
+        upper[i] += centerMovement[assignment[i]];
+        for (int j = 0; j < k; ++j) {
+            lower[i * numLowerBounds + j] -= centerMovement[j];
+        }
+    }
+}
+
+void ElkanKmeans::initialize(Dataset const *aX, unsigned short aK, unsigned short *initialAssignment, int aNumThreads) {
+    numLowerBounds = aK;
+    TriangleInequalityBaseKmeans::initialize(aX, aK, initialAssignment, aNumThreads);
+    centerCenterDistDiv2 = new double[k * k];
+    std::fill(centerCenterDistDiv2, centerCenterDistDiv2 + k * k, 0.0);
+}
+
+void ElkanKmeans::free() {
+    TriangleInequalityBaseKmeans::free();
+    delete [] centerCenterDistDiv2;
+    centerCenterDistDiv2 = NULL;
+}
+
diff --git a/code/train/C++/0053113_AMFImporter_Geometry.cpp b/code/train/C++/0053113_AMFImporter_Geometry.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..afba3f2bc7403fba841ae8a7372f65dadd37b474
--- /dev/null
+++ b/code/train/C++/0053113_AMFImporter_Geometry.cpp
@@ -0,0 +1,356 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2017, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software 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 assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+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.
+---------------------------------------------------------------------------
+*/
+
+/// \file AMFImporter_Geometry.cpp
+/// \brief Parsing data from geometry nodes.
+/// \date 2016
+/// \author smal.root@gmail.com
+
+#ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
+
+#include "AMFImporter.hpp"
+#include "AMFImporter_Macro.hpp"
+
+namespace Assimp
+{
+
+// <mesh>
+// </mesh>
+// A 3D mesh hull.
+// Multi elements - Yes.
+// Parent element - <object>.
+void AMFImporter::ParseNode_Mesh()
+{
+CAMFImporter_NodeElement* ne;
+
+	// create new mesh object.
+	ne = new CAMFImporter_NodeElement_Mesh(mNodeElement_Cur);
+	// Check for child nodes
+	if(!mReader->isEmptyElement())
+	{
+		bool vert_read = false;
+
+		ParseHelper_Node_Enter(ne);
+		MACRO_NODECHECK_LOOPBEGIN("mesh");
+			if(XML_CheckNode_NameEqual("vertices"))
+			{
+				// Check if data already defined.
+				if(vert_read) Throw_MoreThanOnceDefined("vertices", "Only one vertices set can be defined for <mesh>.");
+				// read data and set flag about it
+				ParseNode_Vertices();
+				vert_read = true;
+
+				continue;
+			}
+
+			if(XML_CheckNode_NameEqual("volume")) { ParseNode_Volume(); continue; }
+		MACRO_NODECHECK_LOOPEND("mesh");
+		ParseHelper_Node_Exit();
+	}// if(!mReader->isEmptyElement())
+	else
+	{
+		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
+	}// if(!mReader->isEmptyElement()) else
+
+	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
+}
+
+// <vertices>
+// </vertices>
+// The list of vertices to be used in defining triangles.
+// Multi elements - No.
+// Parent element - <mesh>.
+void AMFImporter::ParseNode_Vertices()
+{
+CAMFImporter_NodeElement* ne;
+
+	// create new mesh object.
+	ne = new CAMFImporter_NodeElement_Vertices(mNodeElement_Cur);
+	// Check for child nodes
+	if(!mReader->isEmptyElement())
+	{
+		ParseHelper_Node_Enter(ne);
+		MACRO_NODECHECK_LOOPBEGIN("vertices");
+			if(XML_CheckNode_NameEqual("vertex")) { ParseNode_Vertex(); continue; }
+		MACRO_NODECHECK_LOOPEND("vertices");
+		ParseHelper_Node_Exit();
+	}// if(!mReader->isEmptyElement())
+	else
+	{
+		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
+	}// if(!mReader->isEmptyElement()) else
+
+	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
+}
+
+// <vertex>
+// </vertex>
+// A vertex to be referenced in triangles.
+// Multi elements - Yes.
+// Parent element - <vertices>.
+void AMFImporter::ParseNode_Vertex()
+{
+CAMFImporter_NodeElement* ne;
+
+	// create new mesh object.
+	ne = new CAMFImporter_NodeElement_Vertex(mNodeElement_Cur);
+	// Check for child nodes
+	if(!mReader->isEmptyElement())
+	{
+		bool col_read = false;
+		bool coord_read = false;
+
+		ParseHelper_Node_Enter(ne);
+		MACRO_NODECHECK_LOOPBEGIN("vertex");
+			if(XML_CheckNode_NameEqual("color"))
+			{
+				// Check if data already defined.
+				if(col_read) Throw_MoreThanOnceDefined("color", "Only one color can be defined for <vertex>.");
+				// read data and set flag about it
+				ParseNode_Color();
+				col_read = true;
+
+				continue;
+			}
+
+			if(XML_CheckNode_NameEqual("coordinates"))
+			{
+				// Check if data already defined.
+				if(coord_read) Throw_MoreThanOnceDefined("coordinates", "Only one coordinates set can be defined for <vertex>.");
+				// read data and set flag about it
+				ParseNode_Coordinates();
+				coord_read = true;
+
+				continue;
+			}
+
+			if(XML_CheckNode_NameEqual("metadata")) { ParseNode_Metadata(); continue; }
+		MACRO_NODECHECK_LOOPEND("vertex");
+		ParseHelper_Node_Exit();
+	}// if(!mReader->isEmptyElement())
+	else
+	{
+		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
+	}// if(!mReader->isEmptyElement()) else
+
+	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
+}
+
+// <coordinates>
+// </coordinates>
+// Specifies the 3D location of this vertex.
+// Multi elements - No.
+// Parent element - <vertex>.
+//
+// Children elements:
+//   <x>, <y>, <z>
+//   Multi elements - No.
+//   X, Y, or Z coordinate, respectively, of a vertex position in space.
+void AMFImporter::ParseNode_Coordinates()
+{
+CAMFImporter_NodeElement* ne;
+
+	// create new color object.
+	ne = new CAMFImporter_NodeElement_Coordinates(mNodeElement_Cur);
+
+	CAMFImporter_NodeElement_Coordinates& als = *((CAMFImporter_NodeElement_Coordinates*)ne);// alias for convenience
+
+	// Check for child nodes
+	if(!mReader->isEmptyElement())
+	{
+		bool read_flag[3] = { false, false, false };
+
+		ParseHelper_Node_Enter(ne);
+		MACRO_NODECHECK_LOOPBEGIN("coordinates");
+			MACRO_NODECHECK_READCOMP_F("x", read_flag[0], als.Coordinate.x);
+			MACRO_NODECHECK_READCOMP_F("y", read_flag[1], als.Coordinate.y);
+			MACRO_NODECHECK_READCOMP_F("z", read_flag[2], als.Coordinate.z);
+		MACRO_NODECHECK_LOOPEND("coordinates");
+		ParseHelper_Node_Exit();
+		// check that all components was defined
+		if((read_flag[0] && read_flag[1] && read_flag[2]) == 0) throw DeadlyImportError("Not all coordinate's components are defined.");
+
+	}// if(!mReader->isEmptyElement())
+	else
+	{
+		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
+	}// if(!mReader->isEmptyElement()) else
+
+	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
+}
+
+// <volume
+// materialid="" - Which material to use.
+// type=""       - What this volume describes can be “region” or “support”. If none specified, “object” is assumed. If support, then the geometric
+//                 requirements 1-8 listed in section 5 do not need to be maintained.
+// >
+// </volume>
+// Defines a volume from the established vertex list.
+// Multi elements - Yes.
+// Parent element - <mesh>.
+void AMFImporter::ParseNode_Volume()
+{
+std::string materialid;
+std::string type;
+CAMFImporter_NodeElement* ne;
+
+	// Read attributes for node <color>.
+	MACRO_ATTRREAD_LOOPBEG;
+		MACRO_ATTRREAD_CHECK_RET("materialid", materialid, mReader->getAttributeValue);
+		MACRO_ATTRREAD_CHECK_RET("type", type, mReader->getAttributeValue);
+	MACRO_ATTRREAD_LOOPEND;
+
+	// create new object.
+	ne = new CAMFImporter_NodeElement_Volume(mNodeElement_Cur);
+	// and assign read data
+	((CAMFImporter_NodeElement_Volume*)ne)->MaterialID = materialid;
+	((CAMFImporter_NodeElement_Volume*)ne)->Type = type;
+	// Check for child nodes
+	if(!mReader->isEmptyElement())
+	{
+		bool col_read = false;
+
+		ParseHelper_Node_Enter(ne);
+		MACRO_NODECHECK_LOOPBEGIN("volume");
+			if(XML_CheckNode_NameEqual("color"))
+			{
+				// Check if data already defined.
+				if(col_read) Throw_MoreThanOnceDefined("color", "Only one color can be defined for <volume>.");
+				// read data and set flag about it
+				ParseNode_Color();
+				col_read = true;
+
+				continue;
+			}
+
+			if(XML_CheckNode_NameEqual("triangle")) { ParseNode_Triangle(); continue; }
+			if(XML_CheckNode_NameEqual("metadata")) { ParseNode_Metadata(); continue; }
+		MACRO_NODECHECK_LOOPEND("volume");
+		ParseHelper_Node_Exit();
+	}// if(!mReader->isEmptyElement())
+	else
+	{
+		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
+	}// if(!mReader->isEmptyElement()) else
+
+	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
+}
+
+// <triangle>
+// </triangle>
+// Defines a 3D triangle from three vertices, according to the right-hand rule (counter-clockwise when looking from the outside).
+// Multi elements - Yes.
+// Parent element - <volume>.
+//
+// Children elements:
+//   <v1>, <v2>, <v3>
+//   Multi elements - No.
+//   Index of the desired vertices in a triangle or edge.
+void AMFImporter::ParseNode_Triangle()
+{
+CAMFImporter_NodeElement* ne;
+
+	// create new color object.
+	ne = new CAMFImporter_NodeElement_Triangle(mNodeElement_Cur);
+
+	CAMFImporter_NodeElement_Triangle& als = *((CAMFImporter_NodeElement_Triangle*)ne);// alias for convenience
+
+	// Check for child nodes
+	if(!mReader->isEmptyElement())
+	{
+		bool col_read = false, tex_read = false;
+		bool read_flag[3] = { false, false, false };
+
+		ParseHelper_Node_Enter(ne);
+		MACRO_NODECHECK_LOOPBEGIN("triangle");
+			if(XML_CheckNode_NameEqual("color"))
+			{
+				// Check if data already defined.
+				if(col_read) Throw_MoreThanOnceDefined("color", "Only one color can be defined for <triangle>.");
+				// read data and set flag about it
+				ParseNode_Color();
+				col_read = true;
+
+				continue;
+			}
+
+			if(XML_CheckNode_NameEqual("texmap"))// new name of node: "texmap".
+			{
+				// Check if data already defined.
+				if(tex_read) Throw_MoreThanOnceDefined("texmap", "Only one texture coordinate can be defined for <triangle>.");
+				// read data and set flag about it
+				ParseNode_TexMap();
+				tex_read = true;
+
+				continue;
+			}
+			else if(XML_CheckNode_NameEqual("map"))// old name of node: "map".
+			{
+				// Check if data already defined.
+				if(tex_read) Throw_MoreThanOnceDefined("map", "Only one texture coordinate can be defined for <triangle>.");
+				// read data and set flag about it
+				ParseNode_TexMap(true);
+				tex_read = true;
+
+				continue;
+			}
+
+			MACRO_NODECHECK_READCOMP_U32("v1", read_flag[0], als.V[0]);
+			MACRO_NODECHECK_READCOMP_U32("v2", read_flag[1], als.V[1]);
+			MACRO_NODECHECK_READCOMP_U32("v3", read_flag[2], als.V[2]);
+		MACRO_NODECHECK_LOOPEND("triangle");
+		ParseHelper_Node_Exit();
+		// check that all components was defined
+		if((read_flag[0] && read_flag[1] && read_flag[2]) == 0) throw DeadlyImportError("Not all vertices of the triangle are defined.");
+
+	}// if(!mReader->isEmptyElement())
+	else
+	{
+		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
+	}// if(!mReader->isEmptyElement()) else
+
+	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
+}
+
+}// namespace Assimp
+
+#endif // !ASSIMP_BUILD_NO_AMF_IMPORTER
diff --git a/code/train/C++/0053337_parabolicsar.cpp b/code/train/C++/0053337_parabolicsar.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..83ee070f18d1d6e0cdb1ce135ba4864456064ac0
--- /dev/null
+++ b/code/train/C++/0053337_parabolicsar.cpp
@@ -0,0 +1,184 @@
+#include "parabolicsar.h"
+
+ParabolicSAR::ParabolicSAR(double SARStep, double SARMaximum, QObject *parent) :
+    MQL5Indicator(3, parent),
+    InpSARStep(SARStep),
+    InpSARMaximum(SARMaximum)
+{
+}
+
+//+------------------------------------------------------------------+
+//| Custom indicator initialization function                         |
+//+------------------------------------------------------------------+
+void ParabolicSAR::OnInit()
+  {
+//--- checking input data
+   if(InpSARStep<0.0)
+     {
+      ExtSarStep=0.02;
+      Print("Input parametr InpSARStep has incorrect value. Indicator will use value",
+            ExtSarStep,"for calculations.");
+     }
+   else ExtSarStep=InpSARStep;
+   if(InpSARMaximum<0.0)
+     {
+      ExtSarMaximum=0.2;
+      Print("Input parametr InpSARMaximum has incorrect value. Indicator will use value",
+            ExtSarMaximum,"for calculations.");
+     }
+   else ExtSarMaximum=InpSARMaximum;
+//---- indicator buffers
+   SetIndexBuffer(0,ExtSARBuffer);
+   SetIndexBuffer(1,ExtEPBuffer,INDICATOR_CALCULATIONS);
+   SetIndexBuffer(2,ExtAFBuffer,INDICATOR_CALCULATIONS);
+//--- set arrow symbol
+   PlotIndexSetInteger(0,PLOT_ARROW,159);
+//--- set indicator digits
+   IndicatorSetInteger(INDICATOR_DIGITS,_Digits);
+//--- set label name
+   PlotIndexSetString(0,PLOT_LABEL,"SAR("+
+                      DoubleToString(ExtSarStep,2)+","+
+                      DoubleToString(ExtSarMaximum,2)+")");
+//--- set global variables
+   ExtLastRevPos=0;
+   ExtDirectionLong=false;
+//----
+  }
+//+------------------------------------------------------------------+
+//| Custom indicator iteration function                              |
+//+------------------------------------------------------------------+
+int ParabolicSAR::OnCalculate (const int rates_total,                     // size of input time series
+                               const int prev_calculated,                 // bars handled in previous call
+                               const _TimeSeries<qint64>& time,           // Time
+                               const _TimeSeries<double>& open,           // Open
+                               const _TimeSeries<double>& high,           // High
+                               const _TimeSeries<double>& low,            // Low
+                               const _TimeSeries<double>& close,          // Close
+                               const _TimeSeries<qint64>& tick_volume,    // Tick Volume
+                               const _TimeSeries<qint64>& volume,         // Real Volume
+                               const _TimeSeries<int>& spread             // Spread
+                               )
+  {
+//--- check for minimum rates count
+   if(rates_total<3)
+      return(0);
+//--- detect current position
+   int pos=prev_calculated-1;
+//--- correct position
+   if(pos<1)
+     {
+      //--- first pass, set as SHORT
+      pos=1;
+      ExtAFBuffer[0]=ExtSarStep;
+      ExtAFBuffer[1]=ExtSarStep;
+      ExtSARBuffer[0]=high[0];
+      ExtLastRevPos=0;
+      ExtDirectionLong=false;
+      ExtSARBuffer[1]=GetHigh(pos,ExtLastRevPos,high);
+      ExtEPBuffer[0]=low[pos];
+      ExtEPBuffer[1]=low[pos];
+     }
+//---main cycle
+   for(int i=pos;i<rates_total-1 && !IsStopped();i++)
+     {
+      //--- check for reverse
+      if(ExtDirectionLong)
+        {
+         if(ExtSARBuffer[i]>low[i])
+           {
+            //--- switch to SHORT
+            ExtDirectionLong=false;
+            ExtSARBuffer[i]=GetHigh(i,ExtLastRevPos,high);
+            ExtEPBuffer[i]=low[i];
+            ExtLastRevPos=i;
+            ExtAFBuffer[i]=ExtSarStep;
+           }
+        }
+      else
+        {
+         if(ExtSARBuffer[i]<high[i])
+           {
+            //--- switch to LONG
+            ExtDirectionLong=true;
+            ExtSARBuffer[i]=GetLow(i,ExtLastRevPos,low);
+            ExtEPBuffer[i]=high[i];
+            ExtLastRevPos=i;
+            ExtAFBuffer[i]=ExtSarStep;
+           }
+        }
+      //--- continue calculations
+      if(ExtDirectionLong)
+        {
+         //--- check for new High
+         if(high[i]>ExtEPBuffer[i-1] && i!=ExtLastRevPos)
+           {
+            ExtEPBuffer[i]=high[i];
+            ExtAFBuffer[i]=ExtAFBuffer[i-1]+ExtSarStep;
+            if(ExtAFBuffer[i]>ExtSarMaximum)
+               ExtAFBuffer[i]=ExtSarMaximum;
+           }
+         else
+           {
+            //--- when we haven't reversed
+            if(i!=ExtLastRevPos)
+              {
+               ExtAFBuffer[i]=ExtAFBuffer[i-1];
+               ExtEPBuffer[i]=ExtEPBuffer[i-1];
+              }
+           }
+         //--- calculate SAR for tomorrow
+         ExtSARBuffer[i+1]=ExtSARBuffer[i]+ExtAFBuffer[i]*(ExtEPBuffer[i]-ExtSARBuffer[i]);
+         //--- check for SAR
+         if(ExtSARBuffer[i+1]>low[i] || ExtSARBuffer[i+1]>low[i-1])
+            ExtSARBuffer[i+1]=MathMin(low[i],low[i-1]);
+        }
+      else
+        {
+         //--- check for new Low
+         if(low[i]<ExtEPBuffer[i-1] && i!=ExtLastRevPos)
+           {
+            ExtEPBuffer[i]=low[i];
+            ExtAFBuffer[i]=ExtAFBuffer[i-1]+ExtSarStep;
+            if(ExtAFBuffer[i]>ExtSarMaximum)
+               ExtAFBuffer[i]=ExtSarMaximum;
+           }
+         else
+           {
+            //--- when we haven't reversed
+            if(i!=ExtLastRevPos)
+              {
+               ExtAFBuffer[i]=ExtAFBuffer[i-1];
+               ExtEPBuffer[i]=ExtEPBuffer[i-1];
+              }
+           }
+         //--- calculate SAR for tomorrow
+         ExtSARBuffer[i+1]=ExtSARBuffer[i]+ExtAFBuffer[i]*(ExtEPBuffer[i]-ExtSARBuffer[i]);
+         //--- check for SAR
+         if(ExtSARBuffer[i+1]<high[i] || ExtSARBuffer[i+1]<high[i-1])
+            ExtSARBuffer[i+1]=MathMax(high[i],high[i-1]);
+        }
+     }
+//---- OnCalculate done. Return new prev_calculated.
+   return(rates_total);
+  }
+//+------------------------------------------------------------------+
+//| Find highest price from start to current position                |
+//+------------------------------------------------------------------+
+double ParabolicSAR::GetHigh(int nPosition,int nStartPeriod,const _TimeSeries<double> &HiData)
+  {
+//--- calculate
+   double result=HiData[nStartPeriod];
+   for(int i=nStartPeriod;i<=nPosition;i++) if(result<HiData[i]) result=HiData[i];
+   return(result);
+  }
+//+------------------------------------------------------------------+
+//| Find lowest price from start to current position                 |
+//+------------------------------------------------------------------+
+double ParabolicSAR::GetLow(int nPosition,int nStartPeriod,const _TimeSeries<double> &LoData)
+  {
+//--- calculate
+   double result=LoData[nStartPeriod];
+   for(int i=nStartPeriod;i<=nPosition;i++) if(result>LoData[i]) result=LoData[i];
+   return(result);
+  }
+//+------------------------------------------------------------------+
diff --git a/code/train/C++/0053693_refinevert.cpp b/code/train/C++/0053693_refinevert.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..72d2fa6b14ec411064105760232e509d66097dc2
--- /dev/null
+++ b/code/train/C++/0053693_refinevert.cpp
@@ -0,0 +1,167 @@
+#include "muscle.h"
+#include "profile.h"
+#include "msa.h"
+#include "pwpath.h"
+#include "seqvect.h"
+#include "clust.h"
+#include "tree.h"
+#include "muscle_context.h"
+
+#define TRACE 0
+
+struct Range
+	{
+	unsigned m_uBestColLeft;
+	unsigned m_uBestColRight;
+	};
+
+static void ListVertSavings(unsigned uColCount, unsigned uAnchorColCount,
+  const Range *Ranges, unsigned uRangeCount)
+	{
+    MuscleContext *ctx = getMuscleContext();
+	if (!ctx->params.g_bVerbose || !ctx->params.g_bAnchors)
+		return;
+	double dTotalArea = uColCount*uColCount;
+	double dArea = 0.0;
+	for (unsigned i = 0; i < uRangeCount; ++i)
+		{
+		unsigned uLength = Ranges[i].m_uBestColRight - Ranges[i].m_uBestColLeft;
+		dArea += uLength*uLength;
+		}
+	double dPct = (dTotalArea - dArea)*100.0/dTotalArea;
+	Log("Anchor columns found       %u\n", uAnchorColCount);
+	Log("DP area saved by anchors   %-4.1f%%\n", dPct);
+	}
+
+static void ColsToRanges(const unsigned BestCols[], unsigned uBestColCount,
+  unsigned uColCount, Range Ranges[])
+	{
+// N best columns produces N+1 vertical blocks.
+	const unsigned uRangeCount = uBestColCount + 1;
+	for (unsigned uIndex = 0; uIndex < uRangeCount ; ++uIndex)
+		{
+		unsigned uBestColLeft = 0;
+		if (uIndex > 0)
+			uBestColLeft = BestCols[uIndex-1];
+		
+		unsigned uBestColRight = uColCount;
+		if (uIndex < uBestColCount)
+			uBestColRight = BestCols[uIndex];
+
+		Ranges[uIndex].m_uBestColLeft = uBestColLeft;
+		Ranges[uIndex].m_uBestColRight = uBestColRight;
+		}
+	}
+
+// Return true if any changes made
+bool RefineVert(MSA &msaIn, const Tree &tree, unsigned uIters)
+	{
+	bool bAnyChanges = false;
+
+	const unsigned uColCountIn = msaIn.GetColCount();
+	const unsigned uSeqCountIn = msaIn.GetSeqCount();
+
+	if (uColCountIn < 3 || uSeqCountIn < 3)
+		return false;
+
+	unsigned *AnchorCols = new unsigned[uColCountIn];
+	unsigned uAnchorColCount;
+	SetMSAWeightsMuscle(msaIn);
+	FindAnchorCols(msaIn, AnchorCols, &uAnchorColCount);
+
+	const unsigned uRangeCount = uAnchorColCount + 1;
+	Range *Ranges = new Range[uRangeCount];
+
+#if	TRACE
+	Log("%u ranges\n", uRangeCount);
+#endif
+
+	ColsToRanges(AnchorCols, uAnchorColCount, uColCountIn, Ranges);
+	ListVertSavings(uColCountIn, uAnchorColCount, Ranges, uRangeCount);
+
+#if	TRACE
+	{
+	Log("Anchor cols: ");
+	for (unsigned i = 0; i < uAnchorColCount; ++i)
+		Log(" %u", AnchorCols[i]);
+	Log("\n");
+
+	Log("Ranges:\n");
+	for (unsigned i = 0; i < uRangeCount; ++i)
+		Log("%4u - %4u\n", Ranges[i].m_uBestColLeft, Ranges[i].m_uBestColRight);
+	}
+#endif
+
+	delete[] AnchorCols;
+
+	MSA msaOut;
+	msaOut.SetSize(uSeqCountIn, 0);
+    
+	for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCountIn ; ++uSeqIndex)
+		{
+		const char *ptrName = msaIn.GetSeqName(uSeqIndex);
+		unsigned uId = msaIn.GetSeqId(uSeqIndex);
+		msaOut.SetSeqName(uSeqIndex, ptrName);
+		msaOut.SetSeqId(uSeqIndex, uId);
+		}
+
+    MuscleContext* ctx = getMuscleContext();
+
+	for (unsigned uRangeIndex = 0; uRangeIndex < uRangeCount && !ctx->isCanceled(); ++uRangeIndex)
+		{
+		MSA msaRange;
+
+		const Range &r = Ranges[uRangeIndex];
+
+		const unsigned uFromColIndex = r.m_uBestColLeft;
+		const unsigned uRangeColCount = r.m_uBestColRight - uFromColIndex;
+
+		if (0 == uRangeColCount)
+			continue;
+		else if (1 == uRangeColCount)
+			{
+			MSAFromColRange(msaIn, uFromColIndex, 1, msaRange);
+			MSAAppend(msaOut, msaRange);
+			continue;
+			}
+		MSAFromColRange(msaIn, uFromColIndex, uRangeColCount, msaRange);
+
+#if	TRACE
+		Log("\n-------------\n");
+		Log("Range %u - %u count=%u\n", r.m_uBestColLeft, r.m_uBestColRight, uRangeColCount);
+		Log("Before:\n");
+		msaRange.LogMe();
+#endif
+
+		bool bLockLeft = (0 != uRangeIndex);
+		bool bLockRight = (uRangeCount - 1 != uRangeIndex);
+		bool bAnyChangesThisBlock = RefineHoriz(msaRange, tree, uIters, bLockLeft, bLockRight);
+		bAnyChanges = (bAnyChanges || bAnyChangesThisBlock);
+
+#if	TRACE
+		Log("After:\n");
+		msaRange.LogMe();
+#endif
+
+		MSAAppend(msaOut, msaRange);
+
+#if	TRACE
+		Log("msaOut after Cat:\n");
+		msaOut.LogMe();
+#endif
+		}
+
+    delete[] Ranges;
+    if (ctx->isCanceled()) {
+        throw MuscleException("Canceled");
+    }
+
+#if	DEBUG
+// Sanity check
+	AssertMSAEqIgnoreCaseAndGaps(msaIn, msaOut);
+#endif
+
+	if (bAnyChanges)
+		msaIn.Copy(msaOut);
+	return bAnyChanges;
+	}
diff --git a/code/train/C++/0053877_sol.cpp b/code/train/C++/0053877_sol.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bc46c38231640b21ec040e5d394946ef2187dcd1
--- /dev/null
+++ b/code/train/C++/0053877_sol.cpp
@@ -0,0 +1,37 @@
+/*=============================================================================
+#     FileName: sol.cpp
+#         Desc: program detail for leetcode Permutations
+#       Author: huicpc0215
+#        Email: huicpc0215@gmail.com
+#     HomePage: http://huicpc0215.uni.me
+#      Version: 0.0.1
+#   LastChange: 2015-01-01 12:32:31
+#      History:
+=============================================================================*/
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<vector>
+#include<cmath>
+#include<algorithm>
+using namespace std;
+class Solution{
+public:
+    vector<vector<int> > permute(vector<int> &num){
+        int sz=num.size();
+        vector<vector<int> >res;
+        sort(num.begin(),num.end());
+        do{
+            res.push_back(num);
+        }while(next_permutation(num.begin(),num.end()));
+        return res;
+    }
+};
+int main(){
+    vector<int> a;
+    a.push_back(1);
+    a.push_back(2);
+    a.push_back(3);
+
+    return 0;
+}
diff --git a/code/train/C++/0054043_RealTimeStereo.cpp b/code/train/C++/0054043_RealTimeStereo.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c7ba7e2479d2cc0ed7d1e551b1b900bbe081d180
--- /dev/null
+++ b/code/train/C++/0054043_RealTimeStereo.cpp
@@ -0,0 +1,290 @@
+/* 
+ * Copyright (c) 2005 Clemson University.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+//#pragma warning(disable: 4786)
+#include "Image.h"
+#include "ImageOperations.h"
+#include "Quick/Quick.h"
+#include "Utilities/Math.h"  // Clamp
+#include "Figure/Figure.h"  // debugging
+
+// -------------------- all includes must go before these lines ------------------
+#if defined(DEBUG) && defined(WIN32) && !defined(NO_MFC)
+#include <afxwin.h>
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+// -------------------- all code must go after these lines -----------------------
+
+using namespace blepo;
+
+// ================> begin local functions (available only to this translation unit)
+namespace
+{
+
+
+};
+// ================< end local functions
+
+namespace blepo
+{
+
+/**
+
+  @author Stan Birchfield (STB)
+*/
+
+void RealTimeStereo(const ImgGray& img_left, const ImgGray& img_right, ImgGray* disparity_map, int max_disp, int winsize)
+{
+//  {
+//    //    Testing ConvolveBox5x5
+//    ImgGray img(7, 7);
+//    unsigned char* p;
+//    int i;
+//    for (p = img.Begin(), i = 0 ; p != img.End() ; )  *p++ = i++;
+//    ConvolveBox5x5(img, &img);
+////    Verify(img(2,2)==25);
+//  }
+
+//  static Figure fig("dispmap left"), fig2("dispmap right"), fig3("dispmap after check");
+//  static Figure fig, fig3;
+  if (!IsSameSize(img_left, img_right))  BLEPO_ERROR("Images must be the same size for stereo correspondence");
+  int i;
+
+  disparity_map->Reset(img_left.Width(), img_left.Height());
+
+  // compute difference images (one for each disparity)
+  std::vector<ImgGray> abs_diff_left(max_disp + 1);
+  for (i = 0 ; i <= max_disp ; i++)
+  {
+    const unsigned char* p1 = img_left.Begin(i);
+    const unsigned char* p2 = img_right.Begin();
+    abs_diff_left[i].Reset(img_left.Width(), img_left.Height());
+    unsigned char* po = abs_diff_left[i].Begin(i);
+    const int nbytes = img_left.NBytes() - i;
+//      int n_quadwords = nbytes / 8;
+//      mmx_absdiff(p1, p2, po, n_quadwords);
+    int n_doublequadwords = nbytes / 16;
+    xmm_absdiff(p1, p2, po, n_doublequadwords);
+
+//    fig2.Draw(abs_diff_left[i]);
+	if(winsize==5)
+		ConvolveBox5x5(abs_diff_left[i], &abs_diff_left[i]);
+	else ConvolveBoxNxN(abs_diff_left[i], &abs_diff_left[i], winsize);
+//    fig.Draw(abs_diff_left[i]);
+//    fig.GrabMouseClick();
+  }
+
+  // grab best disparity
+  {
+    std::vector<unsigned char*> p(max_disp + 1);
+    for (i = 0 ; i <= max_disp ; i++)  p[i] = abs_diff_left[i].Begin();
+    unsigned char* po = disparity_map->Begin();
+    unsigned char* pe = abs_diff_left[0].End();
+    int disp, minval;
+    while (p[0] != pe)
+    {
+      minval = 9999;
+      for (i = 0 ; i <= max_disp ; i++)  
+      {
+        int val = *(p[i])++;
+        if (val < minval)
+        {
+          minval = val;
+          disp = i;
+        }
+      }
+      *po++ = disp;
+    }
+  }
+
+  ImgInt foo;
+  Convert(*disparity_map, &foo);
+//  fig.Draw(foo); //*disparity_map);
+
+  // grab best disparity for right image
+  ImgGray right_disparity_map;
+  right_disparity_map.Reset(img_left.Width(), img_left.Height());
+  {
+    std::vector<unsigned char*> p(max_disp + 1);
+    for (i = 0 ; i <= max_disp ; i++)  p[i] = abs_diff_left[i].Begin(i);
+    unsigned char* po = right_disparity_map.Begin();
+    unsigned char* pe = abs_diff_left[0].End() - max_disp;
+    int disp, minval;
+    while (p[0] != pe)
+    {
+      minval = 9999;
+      for (i = 0 ; i <= max_disp ; i++)  
+      {
+        int val = *(p[i])++;
+        if (val < minval)
+        {
+          minval = val;
+          disp = i;
+        }
+      }
+      *po++ = disp;
+    }
+    while (po != right_disparity_map.End())  *po++ = 0;
+  }  
+
+  Convert(right_disparity_map, &foo);
+//  fig2.Draw(foo); //*disparity_map);
+
+  // left-right consistency check
+  {
+    unsigned char* pl = disparity_map->Begin();
+    unsigned char* pr = right_disparity_map.Begin();
+    while (pl != disparity_map->End())
+    {
+      unsigned char *p = pr - *pl;
+      if (p < right_disparity_map.Begin() || *p != *pl)  *pl = 0;
+      pl++;
+      pr++;
+    }
+  }
+
+//  {
+//    ImgGray display = *disparity_map;
+//    for (unsigned char* p = display.Begin() ; p != display.End() ; p++)  *p <<= 4;
+////    fig3.Draw(display);
+//    *disparity_map = display;
+//  }
+  Convert(*disparity_map, &foo);
+//  fig3.Draw(foo); //*disparity_map);
+
+}
+
+
+
+
+//void RealTimeStereo(const ImgGray& img_left, const ImgGray& img_right, ImgGray* disparity_map, int max_disp)
+//{
+////  {
+////    //    Testing ConvolveBox5x5
+////    ImgGray img(7, 7);
+////    unsigned char* p;
+////    int i;
+////    for (p = img.Begin(), i = 0 ; p != img.End() ; )  *p++ = i++;
+//    ConvolveBox5x5(img, &img);
+//////    Verify(img(2,2)==25);
+////  }
+//
+//  static Figure fig, fig2, fig3;
+//  if (!IsSameSize(img_left, img_right))  BLEPO_ERROR("Images must be the same size for stereo correspondence");
+//  int i;
+//
+//  disparity_map->Reset(img_left.Width(), img_left.Height());
+//
+//  // compute difference images (one for each disparity)
+//  std::vector<ImgGray> abs_diff_left(max_disp + 1);
+//  for (i = 0 ; i <= max_disp ; i++)
+//  {
+//    const unsigned char* p1 = img_left.Begin(i);
+//    const unsigned char* p2 = img_right.Begin();
+//    abs_diff_left[i].Reset(img_left.Width(), img_left.Height());
+//    unsigned char* po = abs_diff_left[i].Begin(i);
+//    const int nbytes = img_left.NBytes() - i;
+//    int n_quadwords = nbytes / 8;
+//    mmx_diff(p1, p2, po, n_quadwords);
+//
+////    fig2.Draw(abs_diff_left[i]);
+////    ConvolveBox5x5(abs_diff_left[i], &abs_diff_left[i]);
+////    fig.Draw(abs_diff_left[i]);
+////    fig.GrabMouseClick();
+//  }
+//
+//  // grab best disparity
+//  {
+//    std::vector<unsigned char*> p(max_disp + 1);
+//    for (i = 0 ; i <= max_disp ; i++)  p[i] = abs_diff_left[i].Begin();
+//    unsigned char* po = disparity_map->Begin();
+//    unsigned char* pe = abs_diff_left[0].End();
+//    int disp, minval;
+//    while (p[0] != pe)
+//    {
+//      minval = 9999;
+//      for (i = 0 ; i <= max_disp ; i++)  
+//      {
+//        int val = *(p[i])++;
+//        if (val < minval)
+//        {
+//          minval = val;
+//          disp = i;
+//        }
+//      }
+//      *po++ = disp;
+//    }
+//  }
+//
+//  ImgInt foo;
+//  Convert(*disparity_map, &foo);
+//  fig.Draw(foo); //*disparity_map);
+//
+//  // grab best disparity for right image
+//  ImgGray right_disparity_map;
+//  right_disparity_map.Reset(img_left.Width(), img_left.Height());
+//  {
+//    std::vector<unsigned char*> p(max_disp + 1);
+//    for (i = 0 ; i <= max_disp ; i++)  p[i] = abs_diff_left[i].Begin(i);
+//    unsigned char* po = right_disparity_map.Begin();
+//    unsigned char* pe = abs_diff_left[0].End() - max_disp;
+//    int disp, minval;
+//    while (p[0] != pe)
+//    {
+//      minval = 9999;
+//      for (i = 0 ; i <= max_disp ; i++)  
+//      {
+//        int val = *(p[i])++;
+//        if (val < minval)
+//        {
+//          minval = val;
+//          disp = i;
+//        }
+//      }
+//      *po++ = disp;
+//    }
+//    while (po != right_disparity_map.End())  *po++ = 0;
+//  }  
+//
+//  Convert(right_disparity_map, &foo);
+//  fig2.Draw(foo); //*disparity_map);
+//
+//  // left-right consistency check
+//  {
+//    unsigned char* pl = disparity_map->Begin();
+//    unsigned char* pr = right_disparity_map.Begin();
+//    while (pl != disparity_map->End())
+//    {
+//      if ( *(pr + *pl) != *pl )  *pl = 0;
+//      pl++;
+//      pr++;
+//    }
+//  }
+//
+//  Convert(*disparity_map, &foo);
+//  fig3.Draw(foo); //*disparity_map);
+//
+//}
+
+};  // end namespace blepo
+
+
+
+
diff --git a/code/train/C++/0054378_FileEncryptor.cpp b/code/train/C++/0054378_FileEncryptor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8cfac5507b198ec30a83e68b791adf3865a04c3c
--- /dev/null
+++ b/code/train/C++/0054378_FileEncryptor.cpp
@@ -0,0 +1,151 @@
+//
+//  FileEncryptor.cpp
+//  ResourceEncryptor
+//
+//  Created by takegawa on 12/02/02.
+//  Copyright (c) 2012 ZYYX Inc. All rights reserved.
+//
+
+#include "FileEncryptor.h"
+#include "md5.h"
+#include "random.h"
+
+FileEncryptor::FileEncryptor(void)
+{
+}
+
+FileEncryptor::~FileEncryptor(void)
+{
+    
+}
+
+bool FileEncryptor::Encrypt(const char *szFileName)
+{
+    bool ret = false;
+    char *pNewFileName = NULL;
+    unsigned char *pEncrypt = NULL;
+    long size;
+    
+    if(!execEncryptAndDecrypt(szFileName, &pEncrypt, &size)) {
+        goto EXIT;
+    }
+    
+    if(!pEncrypt) {
+        goto EXIT;
+    }
+    
+    {
+        //FileLen + ".pkg" + NULL
+    	long filenameSize = strlen(szFileName) + 4 + 1;
+    
+        pNewFileName = new char[filenameSize];
+        memset(pNewFileName, NULL, filenameSize);
+    
+        strcpy(pNewFileName, szFileName);
+        strcat(pNewFileName, ".pkg");
+
+        printf("%s¥n", pNewFileName);
+        if(!Open(pNewFileName, vFile::modeWrite | vFile::modeCreate)) {
+            goto EXIT;
+        }
+  
+        if(!Write(pEncrypt, size)) {
+            goto EXIT;
+        }
+        
+        Close();
+        
+        ret = true;
+    }
+    
+EXIT:
+	FREEARRAY(pEncrypt)
+	FREEARRAY(pNewFileName)
+
+    return ret;
+}
+
+bool FileEncryptor::Decrypt(const char *szFileName, unsigned char **pDecrypt, long *size)
+{
+    bool ret = false;
+    
+    if(!execEncryptAndDecrypt(szFileName, pDecrypt, &(*size))) {
+        goto EXIT;
+    }
+ 
+    ret = true;
+
+EXIT:    
+    return ret;
+}
+
+bool FileEncryptor::execEncryptAndDecrypt(const char *szFileName, unsigned char **encrypted, long *size) 
+{
+    if(!Open(szFileName, vFile::modeRead)) {
+        return false;
+    }
+    
+    long fileLen = Length();
+
+    if(!Read()) {
+        return false;
+    }
+    
+    unsigned char *pBuf = new unsigned char[fileLen];
+    memcpy(pBuf, m_pDataBuf, fileLen);
+    
+    Close();
+    
+    char * pFileName;
+    
+#ifdef __WIN32__
+    pFileName = (char *)strrchr(szFileName, '\\');
+#else
+    pFileName = strrchr(szFileName, '/');
+#endif
+    
+    if(pFileName)
+        ++pFileName;
+    else
+        pFileName = (char *)szFileName;
+
+    char *p = NULL;
+    if((p = strstr(pFileName, ".pkg"))) {
+        *p = 0x00;
+    }
+    
+    md5_state_t state;
+	md5_byte_t digest[16];
+    
+    md5_init(&state);
+	md5_append(&state, (const md5_byte_t *)pFileName, (int)strlen(pFileName));
+	md5_finish(&state, digest);
+
+    unsigned int var[4];
+    for(int i=0; i<4; i++) {
+        var[i] = 0;
+        for(int j=0; j<4; j++) {
+            var[i] += (digest[15 - (4*i+j)] << 8*(3-j));
+        }
+    }
+    unsigned int seed = 0;
+    for(int i=0; i<4; i++) {
+        seed += var[i];
+    }
+    dynamicApp_srand(seed);
+    
+    unsigned char *encryptArray = new unsigned char[1024];
+    for(int i=0; i<1024; i++) {
+		encryptArray[i] = (unsigned char)dynamicApp_rand();
+    }
+
+    for(int i=0; i<fileLen; i++){
+        pBuf[i] ^= encryptArray[i%1024];
+    }
+
+    *encrypted = pBuf;
+    *size = fileLen;
+    
+    FREEARRAY(encryptArray);
+    return true;
+}
diff --git a/code/train/C++/0054514_PartitionByPivot.cpp b/code/train/C++/0054514_PartitionByPivot.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..44c05b735458d7e84b89ff19990f6741e20d0f29
--- /dev/null
+++ b/code/train/C++/0054514_PartitionByPivot.cpp
@@ -0,0 +1,62 @@
+void swap(int& a, int& b)
+{
+    register int tmp;
+    tmp = a;
+    a=b;
+    b=tmp;
+}
+ 
+int partition(int* arr, int start, int end)
+{
+    /* 
+      1. decide a pivot element, let it be arr[end]
+      2. categorize arr the remainting start -> end-1 
+      3. consider 2 indeces = i,j: initially i=start-1, j=start
+      4. make sure that i+1 to j-1 always contains element > pivot
+      5. the above means, i marks end of smaller elements array
+      6. j marks the end of larger elements array
+     */
+ 
+    /*
+    Example:
+      start=0                                           end=12
+  i=-1   j=0                                            
+        3    6    2    1    9    4    12    19    13    10    8    5    11
+        
+        After you do this partition,
+        start                            i            j       end
+        3    6    2    1    9    4    10    8    5    [11]    12    19    13    
+    The important point here is, after 4, we see 8 which is < 11.
+    So, it needs to be inserted.
+    Because of the above point we need 2 indeces.
+    */
+ 
+    int i,j, pivot;
+    pivot = arr[end];
+    i=start-1;
+    for(j=start; j<=end-1; j++)
+    {
+        if(arr[j] <= pivot) {
+            i=i+1;
+            swap(arr[i], arr[j]);
+        }
+    }
+    swap(arr[i+1], arr[end]);
+    return i+1;
+}
+ 
+ 
+ 
+void main()
+{
+    int A[]={3,    6,    2,    1,    9,    4,    12,    19,    13,    10,    8,    5,    11};
+    int B[]={6,10,2};
+    partition(A,0,12);
+ 
+    //sorting 3 elements
+    int div = partition(B,0,2);
+    //small list= 0->div-1
+    //large list = div->3
+    int l1 = partition(B,div+1,2);
+    int l2 = partition(B,l1+1,2);
+}
diff --git a/code/train/C++/0055144_bar_code_reader.cpp b/code/train/C++/0055144_bar_code_reader.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..130c0a83eb7de8c3570e982b3f72c6258bc3e080
--- /dev/null
+++ b/code/train/C++/0055144_bar_code_reader.cpp
@@ -0,0 +1,125 @@
+/// HEADER
+#include "bar_code_reader.h"
+
+/// COMPONENT
+#include <csapex/msg/generic_vector_message.hpp>
+#include <csapex_opencv/roi_message.h>
+
+/// PROJECT
+#include <csapex/model/node.h>
+#include <csapex/model/node_modifier.h>
+#include <csapex/msg/generic_value_message.hpp>
+#include <csapex/msg/io.h>
+#include <csapex/param/parameter_factory.h>
+#include <csapex/utility/register_apex_plugin.h>
+#include <csapex_opencv/cv_mat_message.h>
+
+/// SYSTEM
+#include <zbar.h>
+
+CSAPEX_REGISTER_CLASS(csapex::BarCodeReader, csapex::Node)
+
+using namespace csapex;
+using namespace connection_types;
+
+BarCodeReader::BarCodeReader()
+{
+}
+
+void BarCodeReader::setupParameters(Parameterizable& params)
+{
+    params.addParameter(csapex::param::factory::declareBool("republish", false)
+                            .description("Publish the last detected code again, "
+                                         "if no new code has been detected."));
+}
+
+void BarCodeReader::process()
+{
+    CvMatMessage::ConstPtr msg = msg::getMessage<CvMatMessage>(in_img);
+
+    if (msg->value.channels() != 1) {
+        throw std::runtime_error("Input must be 1-channel image!");
+    }
+
+    bool republish = readParameter<bool>("republish");
+    bool published = false;
+
+    zbar::ImageScanner scanner;
+    // configure the reader
+    scanner.set_config(zbar::ZBAR_NONE, zbar::ZBAR_CFG_ENABLE, 1);
+
+    // wrap image data
+    int w = msg->value.cols;
+    int h = msg->value.rows;
+    zbar::Image image(w, h, "Y800", msg->value.data, w * h);
+
+    // scan the image for barcodes
+    scanner.scan(image);
+
+    std::shared_ptr<std::vector<RoiMessage>> out(new std::vector<RoiMessage>);
+
+    // extract results
+    for (zbar::Image::SymbolIterator symbol = image.symbol_begin(); symbol != image.symbol_end(); ++symbol) {
+        const zbar::Symbol& sym = *symbol;
+        std::string data = sym.get_data();
+
+        {
+            int x = std::numeric_limits<int>::max();
+            int y = std::numeric_limits<int>::max();
+            int X = std::numeric_limits<int>::min();
+            int Y = std::numeric_limits<int>::min();
+
+            for (int i = 0; i < sym.get_location_size(); ++i) {
+                int px = sym.get_location_x(i);
+                int py = sym.get_location_y(i);
+                x = std::min(x, px);
+                X = std::max(X, px);
+                y = std::min(y, py);
+                Y = std::max(Y, py);
+            }
+
+            RoiMessage msg;
+            cv::Rect rect(x, y, X - x, Y - y);
+            if (rect.x >= 0 && rect.y >= 0) {
+                msg.value = Roi(rect, cv::Scalar(0, 0, 0));
+                out->push_back(msg);
+            }
+        }
+
+        //        if(data == data_) {
+        //            if(lost) {
+        //                lost = false;
+        //            }
+
+        //            if(!republish) {
+        //                continue;
+        //            }
+        //        }
+
+        msg::publish(out_str, data);
+        published = true;
+
+        data_ = data;
+    }
+
+    if (!published) {
+        if (republish) {
+            msg::publish(out_str, data_);
+        } else {
+            msg::publish(out_str, std::string(""));
+        }
+    }
+
+    msg::publish<GenericVectorMessage, RoiMessage>(out_roi, out);
+
+    // clean up
+    image.set_data(nullptr, 0);
+}
+
+void BarCodeReader::setup(NodeModifier& node_modifier)
+{
+    in_img = node_modifier.addInput<CvMatMessage>("Image");
+
+    out_str = node_modifier.addOutput<std::string>("String");
+    out_roi = node_modifier.addOutput<GenericVectorMessage, RoiMessage>("ROIs");
+}
diff --git a/code/train/C++/0055888_DouglasPeuckerLineSimplifier.cpp b/code/train/C++/0055888_DouglasPeuckerLineSimplifier.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2a3af89da2e9530baad2b519af1ecc6e504c05c0
--- /dev/null
+++ b/code/train/C++/0055888_DouglasPeuckerLineSimplifier.cpp
@@ -0,0 +1,117 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006 Refractions Research Inc.
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Licence as published
+ * by the Free Software Foundation. 
+ * See the COPYING file for more information.
+ *
+ **********************************************************************
+ *
+ * Last port: simplify/DouglasPeuckerLineSimplifier.java rev. 1.4
+ *
+ **********************************************************************/
+
+#include <geos/simplify/DouglasPeuckerLineSimplifier.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/LineSegment.h>
+
+#include <vector>
+#include <memory> // for auto_ptr
+
+namespace geos {
+
+/// Line simplification algorithms
+namespace simplify { // geos::simplify
+
+/*public static*/
+DouglasPeuckerLineSimplifier::CoordsVectAutoPtr
+DouglasPeuckerLineSimplifier::simplify(
+		const DouglasPeuckerLineSimplifier::CoordsVect& nPts,
+		double distanceTolerance)
+{
+	DouglasPeuckerLineSimplifier simp(nPts);
+	simp.setDistanceTolerance(distanceTolerance);
+	return simp.simplify();
+}
+
+/*public*/
+DouglasPeuckerLineSimplifier::DouglasPeuckerLineSimplifier(
+		const DouglasPeuckerLineSimplifier::CoordsVect& nPts)
+	:
+	pts(nPts)
+{
+}
+
+/*public*/
+void
+DouglasPeuckerLineSimplifier::setDistanceTolerance(
+		double nDistanceTolerance)
+{
+	distanceTolerance=nDistanceTolerance;
+}
+
+/*public*/
+DouglasPeuckerLineSimplifier::CoordsVectAutoPtr
+DouglasPeuckerLineSimplifier::simplify()
+{
+	CoordsVectAutoPtr coordList(new CoordsVect());
+
+	// empty coordlist is the simplest, won't simplify further
+	if ( ! pts.size() ) return coordList;
+
+	usePt = BoolVectAutoPtr(new BoolVect(pts.size(), true));
+	simplifySection(0, pts.size() - 1);
+
+	for (std::size_t i=0, n=pts.size(); i<n; ++i)
+	{
+		if ( usePt->operator[](i) )
+		{
+			coordList->push_back(pts[i]);
+		}
+	}
+
+	// auto_ptr transfer ownership to its
+	// returned copy
+	return coordList;
+}
+
+/*private*/
+void
+DouglasPeuckerLineSimplifier::simplifySection(
+		std::size_t i,
+		std::size_t j)
+{
+	if ( (i+1) == j ) return;
+
+	geos::geom::LineSegment seg(pts[i], pts[j]);
+	double maxDistance = -1.0;
+
+	std::size_t maxIndex = i;
+
+	for (std::size_t k=i+1; k<j; k++)
+	{
+		double distance = seg.distance(pts[k]);
+		if (distance > maxDistance) {
+			maxDistance = distance;
+			maxIndex = k;
+		}
+	}
+	if (maxDistance <= distanceTolerance) {
+		for(std::size_t k =i+1; k<j; k++)
+		{
+			usePt->operator[](k) = false;
+		}
+	}
+	else {
+		simplifySection(i, maxIndex);
+		simplifySection(maxIndex, j);
+	}
+}
+
+} // namespace geos::simplify
+} // namespace geos
diff --git a/code/train/C++/0056094_ListOfPositions.cpp b/code/train/C++/0056094_ListOfPositions.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a47b173c8a055c87ff82196e304601b7237c0080
--- /dev/null
+++ b/code/train/C++/0056094_ListOfPositions.cpp
@@ -0,0 +1,47 @@
+#include "ListOfPositions.h"
+
+ListOfPositions::ListOfPositions(list<int>* listOfPositions,int term) {
+	this->listOfPositions = listOfPositions;
+	this->term = term;
+}
+
+int ListOfPositions::minDistance(list<int>* listToCompare)
+{
+	list<int>::iterator it;
+	list<int>::iterator localIt;
+	int min = 1000000000;
+	int distance;
+	for(it = listToCompare->begin();it != listToCompare->end();++it)
+	{
+		for(localIt = this->listOfPositions->begin();localIt != this->listOfPositions->end();++localIt)
+		{
+			distance = (*localIt - *it);
+			if((distance < min) && (distance >= 0)) min = distance;
+		}
+	}
+	return min;
+}
+
+list<int> *ListOfPositions::getListOfPositions()
+{
+    return listOfPositions;
+}
+
+int ListOfPositions::getTerm()
+{
+    return term;
+}
+
+void ListOfPositions::setTerm(int term)
+{
+    this->term = term;
+}
+
+void ListOfPositions::setListOfPositions(list<int> *listOfPositions)
+{
+    this->listOfPositions = listOfPositions;
+}
+
+ListOfPositions::~ListOfPositions() {
+	// TODO Auto-generated destructor stub
+}
diff --git a/code/train/C++/0056191_LinkedList.cpp b/code/train/C++/0056191_LinkedList.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..28819162889d3e6234abffce142ce5357f607876
--- /dev/null
+++ b/code/train/C++/0056191_LinkedList.cpp
@@ -0,0 +1,105 @@
+#include "LinkedList.h"
+using namespace std;
+
+Node::Node( Elemtype * val, bool Res = true)
+{
+	NewLinkList( val );
+	if(Res){
+		Revrse();
+	}
+}
+Node::~Node()
+{
+	DelLinkList();
+}
+
+statue Node::DelLinkList()
+{
+	LinkList del = L, p;
+	for(p = L->next;p->next;p = p->next) {
+		delete del;
+		del = p;
+	}
+	delete del;
+	return OK;
+}
+
+statue Node::Insert( Elemtype ins, int n )
+{
+	LinkList front = L;	// 前驱指针
+	LinkList item = L;	// 本位指针
+	n--;
+	for(int i = 0;item->next && i < n; i++)
+	{
+		front = item;
+		item = item->next;
+	}
+	front->next = new LNode;
+	front->next->data = ins;
+	front->next->next = item;
+	return OK;
+}//Insert
+
+statue Node::Print() {//输出单链表
+	int i = 0;
+	LinkList p = L;
+	cout << "Index\tAddress\tdata\tnext\n" << endl;
+	while(p) {
+		cout << i << "\t" << p << "\t" << p->data << "\t" << p->next << endl;
+		p = p->next;
+		i++;
+	}
+	return OK;
+}//Print
+
+statue Node::NewLinkList( char *data ) {	//创建带头单链表,P30
+	if(L){
+		DelLinkList();
+	}
+	L = new LNode;
+	L->data = '?';
+	L->next = NULL;
+	LinkList p = L;
+	for(char *i = data;*i != '\0';i++) {
+		p = new LNode;
+		p->data = *i;
+		p->next = L->next;
+		L->next = p;
+	}
+	return OK;
+}//NewLinkList
+
+int Node::Length() {	//求单链表长度
+	int len;
+	LinkList p = L;
+	for(len = 0, p = L; p->next; p = p->next, len++);
+	return len;
+
+}//Length
+
+statue Node::Revrse() {//单链表的就地转置
+								 //依次把每一个节点插入到新表的前面
+	LinkList p = L->next;
+	LinkList q = p->next;
+	LinkList s = q->next;
+	p->next = NULL;
+	while(s->next) {
+		q->next = p; p = q;
+		q = s; s = s->next; //把L的元素逐个插入新表表头
+	}
+	q->next = p;
+	s->next = q;
+	L->next = s;
+
+	return OK;
+}
+
+//Reverse
+int main()
+{
+	char *data = "HelloWorld";
+	Node node(data, true);
+	node.Insert('a', 5);
+	node.Print();
+	return 0;
+}
\ No newline at end of file
diff --git a/code/train/C++/0056647_permute_unique.cc b/code/train/C++/0056647_permute_unique.cc
new file mode 100644
index 0000000000000000000000000000000000000000..fc11cd65dd065e31621b8149e6f413efb64733c5
--- /dev/null
+++ b/code/train/C++/0056647_permute_unique.cc
@@ -0,0 +1,23 @@
+class Solution {
+public:
+	vector<vector<int>> permuteUnique(vector<int> &nums) {
+		vector<vector<int>> result;
+		if (nums.empty())
+			return result;
+		perm(result, nums, 0);
+		return result;
+	}
+	void perm(vector<vector<int>> &result, vector<int> &nums, int i) {
+		if (i == nums.size())
+			result.push_back(nums);
+		set<int> s;
+		for (int j = i; j < nums.size(); j++) {
+			if (s.find(nums[j]) != s.end())
+				continue;
+			s.insert(nums[j]);
+			swap(nums[i], nums[j]);
+			perm(result, nums, i + 1);
+			swap(nums[i], nums[j]);
+		}
+	}
+};
diff --git a/code/train/C++/0056848_manifest_icon_downloader.cc b/code/train/C++/0056848_manifest_icon_downloader.cc
new file mode 100644
index 0000000000000000000000000000000000000000..70941ba4020c08b937de0c890c527f0c500c41a2
--- /dev/null
+++ b/code/train/C++/0056848_manifest_icon_downloader.cc
@@ -0,0 +1,194 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/public/browser/manifest_icon_downloader.h"
+
+#include <stddef.h>
+
+#include <limits>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/numerics/safe_conversions.h"
+#include "content/public/browser/browser_task_traits.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/web_contents.h"
+#include "skia/ext/image_operations.h"
+#include "third_party/blink/public/mojom/devtools/console_message.mojom.h"
+
+namespace content {
+
+bool ManifestIconDownloader::Download(
+    WebContents* web_contents,
+    const GURL& icon_url,
+    int ideal_icon_size_in_px,
+    int minimum_icon_size_in_px,
+    int maximum_icon_size_in_px,
+    IconFetchCallback callback,
+    bool square_only,
+    const GlobalRenderFrameHostId& initiator_frame_routing_id) {
+  DCHECK(minimum_icon_size_in_px <= ideal_icon_size_in_px);
+  if (!web_contents || !icon_url.is_valid())
+    return false;
+
+  const gfx::Size preferred_size(ideal_icon_size_in_px, ideal_icon_size_in_px);
+  web_contents->DownloadImageInFrame(
+      initiator_frame_routing_id, icon_url,
+      false,                    // is_favicon
+      preferred_size,           // preferred_size
+      maximum_icon_size_in_px,  // max_bitmap_size - 0 means no maximum size.
+      false,                    // bypass_cache
+      base::BindOnce(&ManifestIconDownloader::OnIconFetched,
+                     ideal_icon_size_in_px, minimum_icon_size_in_px,
+                     square_only, web_contents->GetWeakPtr(),
+                     std::move(callback)));
+  return true;
+}
+
+void ManifestIconDownloader::OnIconFetched(
+    int ideal_icon_size_in_px,
+    int minimum_icon_size_in_px,
+    bool square_only,
+    base::WeakPtr<WebContents> web_contents,
+    IconFetchCallback callback,
+    int id,
+    int http_status_code,
+    const GURL& url,
+    const std::vector<SkBitmap>& bitmaps,
+    const std::vector<gfx::Size>& sizes) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  if (bitmaps.empty()) {
+    if (web_contents) {
+      web_contents->GetMainFrame()->AddMessageToConsole(
+          blink::mojom::ConsoleMessageLevel::kError,
+          "Error while trying to use the following icon from the Manifest: " +
+              url.spec() + " (Download error or resource isn't a valid image)");
+    }
+
+    std::move(callback).Run(SkBitmap());
+    return;
+  }
+
+  const int closest_index = FindClosestBitmapIndex(
+      ideal_icon_size_in_px, minimum_icon_size_in_px, square_only, bitmaps);
+
+  if (closest_index == -1) {
+    if (web_contents) {
+      web_contents->GetMainFrame()->AddMessageToConsole(
+          blink::mojom::ConsoleMessageLevel::kError,
+          "Error while trying to use the following icon from the Manifest: " +
+              url.spec() +
+              " (Resource size is not correct - typo in the Manifest?)");
+    }
+
+    std::move(callback).Run(SkBitmap());
+    return;
+  }
+
+  const SkBitmap& chosen = bitmaps[closest_index];
+  float ratio = 1.0;
+  // Preserve width/height ratio if non-square icons allowed.
+  if (!square_only && !chosen.empty()) {
+    ratio = base::checked_cast<float>(chosen.width()) /
+            base::checked_cast<float>(chosen.height());
+  }
+  float ideal_icon_width_in_px = ratio * ideal_icon_size_in_px;
+  // Only scale if we need to scale down. For scaling up we will let the system
+  // handle that when it is required to display it. This saves space in the
+  // webapp storage system as well.
+  if (chosen.height() > ideal_icon_size_in_px ||
+      chosen.width() > ideal_icon_width_in_px) {
+    GetIOThreadTaskRunner({})->PostTask(
+        FROM_HERE, base::BindOnce(&ManifestIconDownloader::ScaleIcon,
+                                  ideal_icon_width_in_px, ideal_icon_size_in_px,
+                                  chosen, std::move(callback)));
+    return;
+  }
+
+  std::move(callback).Run(chosen);
+}
+
+void ManifestIconDownloader::ScaleIcon(int ideal_icon_width_in_px,
+                                       int ideal_icon_height_in_px,
+                                       const SkBitmap& bitmap,
+                                       IconFetchCallback callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  const SkBitmap& scaled = skia::ImageOperations::Resize(
+      bitmap, skia::ImageOperations::RESIZE_BEST, ideal_icon_width_in_px,
+      ideal_icon_height_in_px);
+
+  GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE, base::BindOnce(std::move(callback), scaled));
+}
+
+int ManifestIconDownloader::FindClosestBitmapIndex(
+    int ideal_icon_size_in_px,
+    int minimum_icon_size_in_px,
+    bool square_only,
+    const std::vector<SkBitmap>& bitmaps) {
+  int best_index = -1;
+  int best_delta = std::numeric_limits<int>::min();
+  const int max_negative_delta =
+      minimum_icon_size_in_px - ideal_icon_size_in_px;
+
+  for (size_t i = 0; i < bitmaps.size(); ++i) {
+    if (bitmaps[i].empty())
+      continue;
+
+    // Check for valid width/height ratio.
+    float width = base::checked_cast<float>(bitmaps[i].width());
+    float height = base::checked_cast<float>(bitmaps[i].height());
+    float ratio = width / height;
+    if (ratio < 1 || ratio > kMaxWidthToHeightRatio)
+      continue;
+    if (square_only && ratio != 1)
+      continue;
+
+    int delta = bitmaps[i].height() - ideal_icon_size_in_px;
+    if (delta == 0)
+      return i;
+
+    if (best_delta > 0 && delta < 0)
+      continue;
+
+    if ((best_delta > 0 && delta < best_delta) ||
+        (best_delta < 0 && delta > best_delta && delta >= max_negative_delta)) {
+      best_index = i;
+      best_delta = delta;
+    }
+  }
+
+  if (best_index != -1)
+    return best_index;
+
+  // There was no square/landscape icon of a correct size found. Try to find the
+  // most square-like icon which has both dimensions greater than the minimum
+  // size.
+  float best_ratio_difference = std::numeric_limits<float>::infinity();
+  for (size_t i = 0; i < bitmaps.size(); ++i) {
+    if (bitmaps[i].height() < minimum_icon_size_in_px ||
+        bitmaps[i].width() < minimum_icon_size_in_px) {
+      continue;
+    }
+
+    float height = static_cast<float>(bitmaps[i].height());
+    float width = static_cast<float>(bitmaps[i].width());
+    float ratio = width / height;
+    if (!square_only && ratio > kMaxWidthToHeightRatio)
+      continue;
+    float ratio_difference = fabs(ratio - 1);
+    if (ratio_difference < best_ratio_difference) {
+      best_index = i;
+      best_ratio_difference = ratio_difference;
+    }
+  }
+
+  return best_index;
+}
+
+}  // namespace content
diff --git a/code/train/C++/0057547_osThread_solaris.cpp b/code/train/C++/0057547_osThread_solaris.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..937ae5cbbcf8d915e044c37be4534309ac233d92
--- /dev/null
+++ b/code/train/C++/0057547_osThread_solaris.cpp
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+// no precompiled headers
+#include "runtime/atomic.hpp"
+#include "runtime/handles.inline.hpp"
+#include "runtime/mutexLocker.hpp"
+#include "runtime/os.hpp"
+#include "runtime/osThread.hpp"
+#include "runtime/safepoint.hpp"
+#include "runtime/vmThread.hpp"
+#ifdef TARGET_ARCH_x86
+# include "assembler_x86.inline.hpp"
+#endif
+#ifdef TARGET_ARCH_sparc
+# include "assembler_sparc.inline.hpp"
+#endif
+
+# include <signal.h>
+
+ // ***************************************************************
+ // Platform dependent initialization and cleanup
+ // ***************************************************************
+
+void OSThread::pd_initialize() {
+  _thread_id                         = 0;
+  sigemptyset(&_caller_sigmask);
+
+  _current_callback                  = NULL;
+  _current_callback_lock = VM_Version::supports_compare_and_exchange() ? NULL
+                    : new Mutex(Mutex::suspend_resume, "Callback_lock", true);
+
+  _saved_interrupt_thread_state      = _thread_new;
+  _vm_created_thread                 = false;
+}
+
+void OSThread::pd_destroy() {
+}
+
+// Synchronous interrupt support
+//
+// _current_callback == NULL          no pending callback
+//                   == 1             callback_in_progress
+//                   == other value   pointer to the pending callback
+//
+
+// CAS on v8 is implemented by using a global atomic_memory_operation_lock,
+// which is shared by other atomic functions. It is OK for normal uses, but
+// dangerous if used after some thread is suspended or if used in signal
+// handlers. Instead here we use a special per-thread lock to synchronize
+// updating _current_callback if we are running on v8. Note in general trying
+// to grab locks after a thread is suspended is not safe, but it is safe for
+// updating _current_callback, because synchronous interrupt callbacks are
+// currently only used in:
+// 1. GetThreadPC_Callback - used by WatcherThread to profile VM thread
+// There is no overlap between the callbacks, which means we won't try to
+// grab a thread's sync lock after the thread has been suspended while holding
+// the same lock.
+
+// used after a thread is suspended
+static intptr_t compare_and_exchange_current_callback (
+       intptr_t callback, intptr_t *addr, intptr_t compare_value, Mutex *sync) {
+  if (VM_Version::supports_compare_and_exchange()) {
+    return Atomic::cmpxchg_ptr(callback, addr, compare_value);
+  } else {
+    MutexLockerEx ml(sync, Mutex::_no_safepoint_check_flag);
+    if (*addr == compare_value) {
+      *addr = callback;
+      return compare_value;
+    } else {
+      return callback;
+    }
+  }
+}
+
+// used in signal handler
+static intptr_t exchange_current_callback(intptr_t callback, intptr_t *addr, Mutex *sync) {
+  if (VM_Version::supports_compare_and_exchange()) {
+    return Atomic::xchg_ptr(callback, addr);
+  } else {
+    MutexLockerEx ml(sync, Mutex::_no_safepoint_check_flag);
+    intptr_t cb = *addr;
+    *addr = callback;
+    return cb;
+  }
+}
+
+// one interrupt at a time. spin if _current_callback != NULL
+int OSThread::set_interrupt_callback(Sync_Interrupt_Callback * cb) {
+  int count = 0;
+  while (compare_and_exchange_current_callback(
+         (intptr_t)cb, (intptr_t *)&_current_callback, (intptr_t)NULL, _current_callback_lock) != NULL) {
+    while (_current_callback != NULL) {
+      count++;
+#ifdef ASSERT
+      if ((WarnOnStalledSpinLock > 0) &&
+          (count % WarnOnStalledSpinLock == 0)) {
+          warning("_current_callback seems to be stalled: %p", _current_callback);
+      }
+#endif
+      os::yield_all(count);
+    }
+  }
+  return 0;
+}
+
+// reset _current_callback, spin if _current_callback is callback_in_progress
+void OSThread::remove_interrupt_callback(Sync_Interrupt_Callback * cb) {
+  int count = 0;
+  while (compare_and_exchange_current_callback(
+         (intptr_t)NULL, (intptr_t *)&_current_callback, (intptr_t)cb, _current_callback_lock) != (intptr_t)cb) {
+#ifdef ASSERT
+    intptr_t p = (intptr_t)_current_callback;
+    assert(p == (intptr_t)callback_in_progress ||
+           p == (intptr_t)cb, "wrong _current_callback value");
+#endif
+    while (_current_callback != cb) {
+      count++;
+#ifdef ASSERT
+      if ((WarnOnStalledSpinLock > 0) &&
+          (count % WarnOnStalledSpinLock == 0)) {
+          warning("_current_callback seems to be stalled: %p", _current_callback);
+      }
+#endif
+      os::yield_all(count);
+    }
+  }
+}
+
+void OSThread::do_interrupt_callbacks_at_interrupt(InterruptArguments *args) {
+  Sync_Interrupt_Callback * cb;
+  cb = (Sync_Interrupt_Callback *)exchange_current_callback(
+        (intptr_t)callback_in_progress, (intptr_t *)&_current_callback, _current_callback_lock);
+
+  if (cb == NULL) {
+    // signal is delivered too late (thread is masking interrupt signal??).
+    // there is nothing we need to do because requesting thread has given up.
+  } else if ((intptr_t)cb == (intptr_t)callback_in_progress) {
+    fatal("invalid _current_callback state");
+  } else {
+    assert(cb->target()->osthread() == this, "wrong target");
+    cb->execute(args);
+    cb->leave_callback();             // notify the requester
+  }
+
+  // restore original _current_callback value
+  intptr_t p;
+  p = exchange_current_callback((intptr_t)cb, (intptr_t *)&_current_callback, _current_callback_lock);
+  assert(p == (intptr_t)callback_in_progress, "just checking");
+}
+
+// Called by the requesting thread to send a signal to target thread and
+// execute "this" callback from the signal handler.
+int OSThread::Sync_Interrupt_Callback::interrupt(Thread * target, int timeout) {
+  // Let signals to the vm_thread go even if the Threads_lock is not acquired
+  assert(Threads_lock->owned_by_self() || (target == VMThread::vm_thread()),
+         "must have threads lock to call this");
+
+  OSThread * osthread = target->osthread();
+
+  // may block if target thread already has a pending callback
+  osthread->set_interrupt_callback(this);
+
+  _target = target;
+
+  int rslt = thr_kill(osthread->thread_id(), os::Solaris::SIGasync());
+  assert(rslt == 0, "thr_kill != 0");
+
+  bool status = false;
+  jlong t1 = os::javaTimeMillis();
+  { // don't use safepoint check because we might be the watcher thread.
+    MutexLockerEx ml(_sync, Mutex::_no_safepoint_check_flag);
+    while (!is_done()) {
+      status = _sync->wait(Mutex::_no_safepoint_check_flag, timeout);
+
+      // status == true if timed out
+      if (status) break;
+
+      // update timeout
+      jlong t2 = os::javaTimeMillis();
+      timeout -= t2 - t1;
+      t1 = t2;
+    }
+  }
+
+  // reset current_callback
+  osthread->remove_interrupt_callback(this);
+
+  return status;
+}
+
+void OSThread::Sync_Interrupt_Callback::leave_callback() {
+  if (!_sync->owned_by_self()) {
+    // notify requesting thread
+    MutexLockerEx ml(_sync, Mutex::_no_safepoint_check_flag);
+    _is_done = true;
+    _sync->notify_all();
+  } else {
+    // Current thread is interrupted while it is holding the _sync lock, trying
+    // to grab it again will deadlock. The requester will timeout anyway,
+    // so just return.
+    _is_done = true;
+  }
+}
+
+// copied from synchronizer.cpp
+
+void OSThread::handle_spinlock_contention(int tries) {
+  if (NoYieldsInMicrolock) return;
+
+  if (tries > 10) {
+    os::yield_all(tries); // Yield to threads of any priority
+  } else if (tries > 5) {
+    os::yield();          // Yield to threads of same or higher priority
+  }
+}
diff --git a/code/train/C++/0057868_main.cpp b/code/train/C++/0057868_main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ab1e59dcdf176b721a9628e6c286f271fa4108ab
--- /dev/null
+++ b/code/train/C++/0057868_main.cpp
@@ -0,0 +1,134 @@
+#include <Arduino.h>
+#include <Wire.h>
+
+#include "ChibiOS_AVR.h"
+// #include "Moti.h"
+#include "Sensors.h"
+#include "Motion.h"
+#include "DriveSystem.h"
+
+float PWMtoLinVel(int PWMdesired){
+int RPM = 260;		// rotation per min of the motor
+float r = 0.02;	// radius of the wheels
+float d = 0.06;	// distance wheeks-center
+float R = 0.09;	//  radius of the shell
+float phid;
+float Vel;
+
+phid = RPM * PWMdesired * 2 * 3.141592 /(255 * 60); // fait en une ligne au lieu de deux, a checker!!!!!!!!!
+Vel = r * phid * R / d;				  // pareil
+return Vel;
+}
+
+int LinVeltoPWM (float Vel){
+int RPM = 260;		// rotation per min of the motor
+float r = 0.02;	// radius of the wheels
+float d = 0.06;	// distance wheeks-center
+float R = 0.09;	//  radius of the shell
+float phid;
+float phiMax;
+float PWM;
+
+phiMax = RPM * 2 * 3.141592;
+phid = (Vel * d) / (r*R) ; // fait en une ligne au lieu de deux, a checker!!!!!!!!!
+PWM = phid * 255 / phiMax;				  // pareil
+// Serial.print("PWM ");
+// Serial.println(PWM);
+int PWMint = static_cast<int>(PWM);
+// Serial.print("PWMint ");
+// Serial.println(PWMint);
+return PWMint;
+}
+
+void mainThread() {
+// DECLARATION
+	int PWM;
+	float	deltaT;
+	float	Acc;
+	float	DPitch;
+	float	Vel;
+	float  Moy;
+	float	SP;
+	float	Vosc;
+
+//INITIALIZATION
+	Sensors::init();
+	Sensors::start();
+	int PWMdesired = 200;
+	float SumAcc = 0;
+	float PitchOld = Sensors::getGyrP();
+	float timeOld = 0;
+	float 	MoySum = 0;
+	float cte = 9.81 * 4 / 1024;
+	bool SpReach = TRUE;
+	int i = 1;
+	
+	while (TRUE) {
+		deltaT = (millis()-timeOld)*0.001; //DeltaT a chaque instant
+		 Serial.print("deltaT :");
+		// Serial.println(deltaT);
+		Acc = Sensors::getAccX();
+		Acc =  Acc * cte;    // Get ACC
+		 Serial.print("Acc :");
+		// Serial.println(Sensors::getAccX());
+		// Serial.println(Acc);
+		SumAcc =  (deltaT*Acc) + SumAcc;    // Integration of Acc SumAcc 
+		 Serial.print("SumAcc :");
+		// Serial.println(SumAcc);
+		DPitch = ((Sensors::getGyrP())-PitchOld)/deltaT; // prime derivative of pitch
+
+		Vel = SumAcc + DPitch;
+		MoySum = MoySum + Vel;
+		Moy = MoySum / i;
+		 Serial.print("sp :");
+		// Serial.println(SP);
+
+		SP = PWMtoLinVel(PWMdesired);
+		 Serial.print("sp :");
+		// Serial.println(SP);
+		if ((Moy <= SP) && (SpReach==TRUE)){
+			 Serial.println("Vosc=Moy");
+			Vosc = Moy;
+		}
+		else {
+			// Serial.println("Vosc no Moy");
+			Vosc = (2 * SP) - Moy;
+			SpReach = 0;
+		}
+
+		PWM = LinVeltoPWM (Vosc);
+		// Serial.println(PWM);
+
+		DriveSystem::go(FORWARD, 200);
+
+		i++;
+		timeOld = millis();
+		PitchOld = Sensors::getGyrP();
+
+		waitMs(50);
+	}
+}
+
+
+
+
+void loop() { }
+
+int main(void) {
+	init();
+
+	Serial.begin(115200);
+	while (!Serial);
+
+		// Serial1.begin(115200);
+		// while (!Serial1);
+
+	Wire.begin();
+	delay(5000);
+
+	chBegin(mainThread);
+
+	while(1);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/code/train/C++/0058569_81.cc b/code/train/C++/0058569_81.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6ec3b56d14ded88a3c5c60d7bd81d45275fef783
--- /dev/null
+++ b/code/train/C++/0058569_81.cc
@@ -0,0 +1,34 @@
+class Solution {
+public:
+    bool search(vector<int>& nums, int target) {
+        int pivot = findMid(nums);
+        int low = 0, high = nums.size() - 1, mid = 0, realmid = 0;
+        while (low <= high) {
+            mid = (low + high) / 2;
+            realmid = (mid + pivot) % nums.size();
+            if (nums[realmid] == target) {
+                return true;
+            } else if (nums[realmid] < target) {
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+        return false;
+    }
+private:
+    int findMid(std::vector<int>& nums) {
+        int low = 0, high = nums.size() - 1, mid = 0;
+        while (low < high) {
+            while (low < high && nums[low] == nums[high])
+                ++low;    
+            mid = (low + high) / 2;
+            if (nums[mid] <= nums[high]) {
+                high = mid;
+            } else {
+                low = mid + 1;
+            }
+        }
+        return low;
+    }
+};
diff --git a/code/train/C++/0058894_list.cpp b/code/train/C++/0058894_list.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d1016e4eee5a467528c4941f1fccf7602d5d9f1a
--- /dev/null
+++ b/code/train/C++/0058894_list.cpp
@@ -0,0 +1,175 @@
+#include "list.hpp"
+
+// initialize list with null
+// TODO: Init with a data
+List::List(){
+  this->_head = nullptr;
+};
+
+List::~List(){
+  Node<int> *node = this->_head;
+  while(node != nullptr){
+    Node<int> *next = node->getNext();
+    delete node;
+    node = next;
+  }
+  this->_head = nullptr;
+}
+
+bool List::isEmpty(){
+  return this->_head == nullptr ? true : false;
+}
+
+int List::size(){
+  int counter = 0;
+  Node<int> *tmp = this->_head;
+  while(tmp != nullptr){
+    counter ++;
+    tmp = tmp->getNext();
+  }
+  return counter;
+}
+
+void List::append(int data){
+  Node<int> *node = new Node<int>();
+  node->setValue(data);
+  // Init a new node.
+  Node<int> *tmp = this->_head;
+  // If list is empty
+  if(isEmpty()){
+    this->_head = node;
+    return;
+  }
+
+  while(tmp->hasNext()){
+    tmp = tmp->getNext();
+  }
+  tmp->setNext(node);
+}
+
+void List::initList(int value){
+  //overflow guard
+  value < 0 ? value = 0 : value;
+  Node<int> *node = new Node<int>();
+  node->setValue(value);
+  this->_head = node;
+}
+
+int List::getHeadValue(){
+  return this->_head->getValue();
+}
+
+int List::getTailValue(){
+  Node<int> *node = this->_head;
+  while(node->hasNext()){
+    node = node->getNext();
+  }
+  return node->getValue();
+}
+
+void List::insertFront(int value){
+  Node<int> *node = new Node<int>();
+  node->setValue(value);
+  node->setNext(this->_head);
+  this->_head = node;
+}
+
+int List::valueAt(int index){
+  Node<int> *tmp = this->_head;
+  for(int i = 0; i != index; ++i){
+    tmp = tmp->getNext();
+  }
+  return tmp->getValue();
+}
+
+int List::popHead(){
+  Node<int> *tmp = this->_head;
+  int value = this->_head->getValue();
+  this->_head = this->_head->getNext();
+  delete tmp;
+  return value;
+}
+
+int List::popTail(){
+  Node<int> *tmp = this->_head;
+  int value;
+  while(tmp->getNext()->hasNext()){
+    tmp = tmp->getNext();
+  }
+  value = tmp->getNext()->getValue();
+  tmp->setNext();
+  return value;
+}
+
+void List::insert(int index, int value){
+  Node<int> *node = new Node<int>();
+  node->setValue(value);
+  if(index == 0){
+    node->setNext(this->_head);
+    this->_head = node;
+    return;
+  }
+  if(index >= size()){
+    append(value);
+    delete node;
+    return;
+  }
+  Node<int> *tmp = this->_head;
+  // index - 1 because we want to change the given index
+  // not the after one.
+  for(int i = 0; i < index - 1; ++i){
+    tmp = tmp->getNext();
+  }
+  node->setNext(tmp->getNext());
+  tmp->setNext(node);
+}
+
+void List::erase(int index){
+  Node<int> *tmp = this->_head;
+  if(index == 0){
+    this->_head = this->_head->getNext();
+    delete tmp;
+    return;
+  }
+  if(index >= size()){
+    popTail();
+    return;
+  }
+  for(int i = 0; i < index - 1; ++i){
+    tmp = tmp->getNext();
+  }
+  tmp->setNext(tmp->getNext()->getNext());
+  delete tmp;
+}
+
+void List::reverse(){
+  Node<int> *tmp = _head;
+  Node<int> *second = new Node<int>();
+  Node<int> *reversedList = nullptr;
+
+  while(tmp){
+    second = tmp->getNext();
+    tmp->setNext(reversedList);
+    reversedList = tmp;
+    tmp = second;
+  }
+  this->_head = reversedList;
+}
+
+int List::kthValueFromTail(int index){
+  index >= size() ? index = size() - 1 : index;
+  return valueAt((size() - 1) - index);
+}
+
+void List::removeValue(int value){
+  Node<int> *tmp = this->_head->getNext();
+  Node<int> *prev = this->_head;
+  while(tmp != nullptr){
+    if(tmp->getValue() == value){
+      prev->setNext(tmp->getNext());
+      delete tmp;
+    }
+    prev = tmp;
+    tmp = tmp->getNext();
+  }
+}
diff --git a/code/train/C++/0059595_cs_pathfinding.cpp b/code/train/C++/0059595_cs_pathfinding.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bbfb525a800e3f5809fe31018631ae8cc49b99d5
--- /dev/null
+++ b/code/train/C++/0059595_cs_pathfinding.cpp
@@ -0,0 +1,260 @@
+/*
+ * Copyright (C) 2008-2010 TrinityCore <http://www.trinitycore.org/>
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+/* ScriptData
+Name: cs_pathfinding
+%Complete: 100
+Comment: all pathfinding related Commands
+Category: commandscripts
+EndScriptData */
+
+#include "ScriptPCH.h"
+#include "Chat.h"
+#include "PathInfo.h"
+#include "PathFactory.h"
+
+class pathfinding_commandscript : public CommandScript
+{
+    public:
+        pathfinding_commandscript() : CommandScript("pathfinding_commandscript") { }
+
+        ChatCommand* GetCommands() const
+        {
+            static ChatCommand pathfindingCommandTable[] = 
+            { 
+                { "path",           SEC_GAMEMASTER,     false, &HandleMmapPathCommand,           "", NULL },
+                { "loc",            SEC_GAMEMASTER,     false, &HandleMmapLocCommand,            "", NULL },
+                { "loadedtiles",    SEC_GAMEMASTER,     false, &HandleMmapLoadedTilesCommand,    "", NULL },
+                { "stats",          SEC_GAMEMASTER,     false, &HandleMmapStatsCommand,          "", NULL },
+                { "",               SEC_ADMINISTRATOR,  false, &HandleMmap,                      "", NULL },
+                { NULL,             0,                  false, NULL,                             "", NULL }
+            };
+            static ChatCommand CommandTable[] =
+            {
+                { "pathfinding",    SEC_GAMEMASTER,     false, NULL,                              "", pathfindingCommandTable },
+                { NULL,             0,                  false, NULL,                              "", NULL }
+            };
+            return CommandTable;
+        }
+
+        static bool HandleMmapPathCommand(ChatHandler* handler, const char* args)
+        {
+            if (!MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId()))
+            {
+                handler->PSendSysMessage("NavMesh not loaded for current map.");
+                return true;
+            }
+
+            handler->PSendSysMessage("mmap path:");
+
+            // units
+            Player* player = handler->GetSession()->GetPlayer();
+            Unit* target = handler->getSelectedUnit();
+            if (!player || !target)
+            {
+                handler->PSendSysMessage("Invalid target/source selection.");
+                return true;
+            }
+
+            char* para = strtok((char*)args, " ");
+
+            bool useStraightPath = false;
+            if (para && strcmp(para, "true") == 0)
+                useStraightPath = true;
+
+            // unit locations
+            float x, y, z;
+            player->GetPosition(x, y, z);
+
+            // path
+            PathInfo path(target, x, y, z, useStraightPath);
+            PointPath pointPath = path.getFullPath();
+            handler->PSendSysMessage("%s's path to %s:", target->GetName(), player->GetName());
+            handler->PSendSysMessage("Building %s", useStraightPath ? "StraightPath" : "SmoothPath");
+            handler->PSendSysMessage("length %i type %u", pointPath.size(), path.getPathType());
+
+            PathNode start = path.getStartPosition();
+            PathNode next = path.getNextPosition();
+            PathNode end = path.getEndPosition();
+            PathNode actualEnd = path.getActualEndPosition();
+
+            handler->PSendSysMessage("start      (%.3f, %.3f, %.3f)", start.x, start.y, start.z);
+            handler->PSendSysMessage("next       (%.3f, %.3f, %.3f)", next.x, next.y, next.z);
+            handler->PSendSysMessage("end        (%.3f, %.3f, %.3f)", end.x, end.y, end.z);
+            handler->PSendSysMessage("actual end (%.3f, %.3f, %.3f)", actualEnd.x, actualEnd.y, actualEnd.z);
+
+            if (!player->isGameMaster())
+                handler->PSendSysMessage("Enable GM mode to see the path points.");
+
+            // this entry visible only to GM's with "gm on"
+            static const uint32 WAYPOINT_NPC_ENTRY = 1;
+            for (uint32 i = 0; i < pointPath.size(); ++i)
+                player->SummonCreature(WAYPOINT_NPC_ENTRY, pointPath[i].x, pointPath[i].y, pointPath[i].z, 0, TEMPSUMMON_TIMED_DESPAWN, 9000);
+
+            return true;
+        }
+
+        static bool HandleMmapLocCommand(ChatHandler* handler, const char* /*args*/)
+        {
+            handler->PSendSysMessage("mmap tileloc:");
+
+            // grid tile location
+            Player* player = handler->GetSession()->GetPlayer();
+
+            int32 gx = 32 - player->GetPositionX() / SIZE_OF_GRIDS;
+            int32 gy = 32 - player->GetPositionY() / SIZE_OF_GRIDS;
+
+            handler->PSendSysMessage("%03u%02i%02i.mmtile", player->GetMapId(), gy, gx);
+            handler->PSendSysMessage("gridloc [%i,%i]", gx, gy);
+
+            // calculate navmesh tile location
+            const dtNavMesh* navmesh = MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(player->GetMapId());
+            const dtNavMeshQuery* navmeshquery = MMAP::MMapFactory::createOrGetMMapManager()->GetNavMeshQuery(player->GetMapId(), player->GetInstanceId());
+            if (!navmesh || !navmeshquery)
+            {
+                handler->PSendSysMessage("NavMesh not loaded for current map.");
+                return true;
+            }
+
+            const float* min = navmesh->getParams()->orig;
+
+            float x, y, z;
+            player->GetPosition(x, y, z);
+            float location[VERTEX_SIZE] = {y, z, x};
+            float extents[VERTEX_SIZE] = {2.f,4.f,2.f};
+
+            int32 tilex = int32((y - min[0]) / SIZE_OF_GRIDS);
+            int32 tiley = int32((x - min[2]) / SIZE_OF_GRIDS);
+
+            handler->PSendSysMessage("Calc   [%02i,%02i]", tilex, tiley);
+
+            // navmesh poly -> navmesh tile location
+            dtQueryFilter filter = dtQueryFilter();
+            dtPolyRef polyRef = INVALID_POLYREF;
+            navmeshquery->findNearestPoly(location, extents, &filter, &polyRef, NULL);
+
+            if (polyRef == INVALID_POLYREF)
+                handler->PSendSysMessage("Dt     [??,??] (invalid poly, probably no tile loaded)");
+            else
+            {
+                const dtMeshTile* tile;
+                const dtPoly* poly;
+                navmesh->getTileAndPolyByRef(polyRef, &tile, &poly);
+                if (tile)
+                    handler->PSendSysMessage("Dt     [%02i,%02i]", tile->header->x, tile->header->y);
+                else
+                    handler->PSendSysMessage("Dt     [??,??] (no tile loaded)");
+            }
+
+            return true;
+        }
+
+        static bool HandleMmapLoadedTilesCommand(ChatHandler* handler, const char* /*args*/)
+        {
+            uint32 mapid = handler->GetSession()->GetPlayer()->GetMapId();
+
+            const dtNavMesh* navmesh = MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(mapid);
+            const dtNavMeshQuery* navmeshquery = MMAP::MMapFactory::createOrGetMMapManager()->GetNavMeshQuery(mapid, handler->GetSession()->GetPlayer()->GetInstanceId());
+            if (!navmesh || !navmeshquery)
+            {
+                handler->PSendSysMessage("NavMesh not loaded for current map.");
+                return true;
+            }
+
+            handler->PSendSysMessage("mmap loadedtiles:");
+
+            for (int32 i = 0; i < navmesh->getMaxTiles(); ++i)
+            {
+                const dtMeshTile* tile = navmesh->getTile(i);
+                if (!tile || !tile->header)
+                    continue;
+
+                handler->PSendSysMessage("[%02i,%02i]", tile->header->x, tile->header->y);
+            }
+
+            return true;
+        }
+
+        static bool HandleMmapStatsCommand(ChatHandler* handler, const char* /*args*/)
+        {
+            handler->PSendSysMessage("mmap stats:");
+            handler->PSendSysMessage("global mmap pathfinding is %sabled", sWorld->getBoolConfig(CONFIG_ENABLE_PATHFINDING) ? "en" : "dis");
+
+            MMAP::PathManager *manager = MMAP::MMapFactory::createOrGetMMapManager();
+            handler->PSendSysMessage(" %u maps loaded with %u tiles overall", manager->getLoadedMapsCount(), manager->getLoadedTilesCount());
+
+            const dtNavMesh* navmesh = manager->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId());
+            if (!navmesh)
+            {
+                handler->PSendSysMessage("NavMesh not loaded for current map.");
+                return true;
+            }
+
+            uint32 tileCount = 0;
+            uint32 nodeCount = 0;
+            uint32 polyCount = 0;
+            uint32 vertCount = 0;
+            uint32 triCount = 0;
+            uint32 triVertCount = 0;
+            uint32 dataSize = 0;
+            for (int32 i = 0; i < navmesh->getMaxTiles(); ++i)
+            {
+                const dtMeshTile* tile = navmesh->getTile(i);
+                if (!tile || !tile->header)
+                    continue;
+
+                tileCount ++;
+                nodeCount += tile->header->bvNodeCount;
+                polyCount += tile->header->polyCount;
+                vertCount += tile->header->vertCount;
+                triCount += tile->header->detailTriCount;
+                triVertCount += tile->header->detailVertCount;
+                dataSize += tile->dataSize;
+            }
+
+            handler->PSendSysMessage(" Navmesh stats on current map:");
+            handler->PSendSysMessage(" %u tiles loaded", tileCount);
+            handler->PSendSysMessage(" %u BVTree nodes", nodeCount);
+            handler->PSendSysMessage(" %u polygons (%u vertices)", polyCount, vertCount);
+            handler->PSendSysMessage(" %u triangles (%u vertices)", triCount, triVertCount);
+            handler->PSendSysMessage(" %.2f MB of data (not including pointers)", ((float)dataSize / sizeof(unsigned char)) / 1048576);
+
+            return true;
+        }
+
+        static bool HandleMmap(ChatHandler* handler, const char* args) 
+        {
+            std::string argstr = (char*)args; 
+            if (argstr == "on") 
+            { 
+                sWorld->setBoolConfig(CONFIG_ENABLE_PATHFINDING, true);
+                handler->SendSysMessage("WORLD: Pathfinding are now ENABLED (individual map settings still in effect)");
+            }
+
+            if (argstr == "off")
+            { 
+                sWorld->setBoolConfig(CONFIG_ENABLE_PATHFINDING, false);
+                handler->SendSysMessage("WORLD: Pathfinding are now DISABLED"); 
+            } 
+            return true;
+        }
+};
+
+void AddSC_pathfinding_commandscript()
+{
+    new pathfinding_commandscript();
+}
diff --git a/code/train/C++/0059644_2-markov.cpp b/code/train/C++/0059644_2-markov.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2283fe06c3e5bcaf83b6d0b98af327e631e07a44
--- /dev/null
+++ b/code/train/C++/0059644_2-markov.cpp
@@ -0,0 +1,162 @@
+#include<iostream>
+#include<utility>
+#include<vector>
+#include<random>
+
+#include<boost/graph/adjacency_list.hpp>
+
+#include<boost/algorithm/string/classification.hpp>
+#include<boost/algorithm/string/split.hpp>
+#include<boost/algorithm/string/trim.hpp>
+
+using namespace boost;
+
+int main(int argc, char** argv){
+  //first is the current word of the vertex, second is the word that preceeded it
+  //this may not be necessary, the pair may only be needed in word_map
+  typedef property<vertex_name_t, std::pair<std::string,
+                                            std::string> >      Vertex_property;
+  typedef adjacency_list<vecS,
+                         vecS,
+                         directedS,
+                         Vertex_property>  Graph;
+  typedef graph_traits<Graph>::vertex_descriptor                Vertex;
+  typedef std::pair<graph_traits<Graph>::edge_descriptor, bool> Edge;
+
+  long sentences = 1;
+  if(argc == 2){
+    sentences = strtol(argv[1], NULL, 10);
+    if(sentences < 1){
+      std::cerr << "The number of generated sentences must be positive.\n";
+    }
+  }
+
+  Graph g(0);
+
+  property_map<Graph, vertex_name_t>::type vertex_words = get(vertex_name, g);
+  std::map<std::pair<std::string, std::string>, Vertex> word_map; //use to quickly find vertices
+
+  //make starting vertex
+  Vertex v_start = add_vertex(g);
+  //use "-" as placeholder for no preceeding word or not caring
+  vertex_words[v_start] = std::make_pair("_", "-");
+  word_map.emplace(std::make_pair("_", "-"), v_start);
+
+  //make vertices for periods and exclamation marks
+  Vertex v_period = add_vertex(g);
+  vertex_words[v_period] = std::make_pair(".", "-");
+  word_map.emplace(std::make_pair(".", "-"), v_period);
+  Vertex v_excl = add_vertex(g);
+  vertex_words[v_excl] = std::make_pair("!", "-");
+  word_map.emplace(std::make_pair("!", "-"), v_excl);
+  Vertex v_ques = add_vertex(g);
+  vertex_words[v_ques] = std::make_pair("?", "-");
+  word_map.emplace(std::make_pair("?", "-"), v_ques);
+
+  //get input and split on space
+  std::string input;
+  while(std::getline(std::cin, input)){
+    std::vector<std::string> words;
+    split(words, input, is_space());
+
+    /*for(auto s : words){
+      std::cout << s << " ";
+    }
+    std::cout << std::endl;*/
+
+    bool first = true; //true if s is first word in line
+    Vertex prev = graph_traits<Graph>::null_vertex(); //previous Vertex added to graph
+    std::string p_word = vertex_words[v_start].first; //previous word in sentence
+    for(auto s : words){
+
+      char c = 0;
+      //remember if word is end of sentence
+      if(s.back() == '.'){
+        c = '.';
+      } else if (s.back() == '!'){
+        c = '!';
+      } else if (s.back() == '?'){
+        c = '?';
+      }
+
+      trim_if(s, is_punct()); //remove grammatical marks
+      if(!s.empty()){ //do nothing if s is empty
+        //std::cout << s << " ";
+        if(word_map.find(std::make_pair(s, p_word)) == word_map.end()) {
+          //currenty no vertex for word s preceeded by p_word
+          //add vertex to graph, add string property, add (string,string)=>vertex to word_map
+          Vertex v = add_vertex(g);
+          vertex_words[v] = std::make_pair(s, p_word);;
+          word_map.emplace(std::make_pair(s, p_word), v);
+        }
+        //std::cout << "\"" << s << "\"" << std::endl;
+        Vertex v = word_map.find(std::make_pair(s, p_word))->second;
+
+        //add edge for previous word to s
+        if(first){
+          add_edge(v_start, v, g);
+        } else {
+          add_edge(prev, v, g);
+        }
+        first = false;
+        prev = v;
+        p_word = s;
+
+        if(c == '.'){
+          add_edge(v, v_period, g); //edge from word to period
+          //std::cout << ". ";
+          first = true; //next word is the first in a sentence
+        } else if (c == '!'){
+          add_edge(v, v_excl, g); //edge from word to exclamation mark
+          //std::cout << "! ";
+          first = true;
+        } else if (c == '?'){
+          add_edge(v, v_ques, g);
+          //std::cout << "? ";
+          first = true;
+        }
+      }
+    }
+    //std::cout << "done" << std::endl << std::endl;
+  }
+  //std::cout << std::endl;
+
+#ifdef GRAPHVIZ
+  //output all edges
+  Vertex v = graph_traits<Graph>::null_vertex();
+  Vertex u = graph_traits<Graph>::null_vertex();
+  typedef graph_traits<Graph>::edge_iterator  edge_iter;
+  std::pair<edge_iter, edge_iter> ep;
+  edge_iter ei, ei_end;
+  for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei){
+    std::cout << "\"" << vertex_words[source(*ei, g)].first << ", "
+              << vertex_words[source(*ei, g)].second
+              << "\" -> \"" << vertex_words[target(*ei, g)].first << ", "
+              << vertex_words[target(*ei, g)].second << "\";" << std::endl;
+  }
+#endif
+
+  std::cout << num_vertices(g) << " " << num_edges(g) << std::endl << std::endl;
+
+  for(long i = 0; i < sentences; ++i){
+    Vertex current = v_start;
+    boost::graph_traits<Graph>::degree_size_type d = 0;
+    while((d = out_degree(current, g)) != 0){
+      //this is probably really slow
+      std::random_device rand;
+      std::mt19937 gen(rand());
+      std::uniform_int_distribution<> dis(0, d-1);
+
+      int i = dis(gen);
+
+      //std::cout << d << " " << i << std::endl;
+
+      graph_traits<Graph>::out_edge_iterator oet = out_edges(current, g).first;
+      current = target(*(oet + i), g);
+      std::cout << vertex_words[current].first << " ";
+    }
+    std::cout << std::endl;
+  }
+
+  return 0;
+}
diff --git a/code/train/C++/0059645_m3humanoid_shm_test.cpp b/code/train/C++/0059645_m3humanoid_shm_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e2ec4169f00ed6e8af017e56c310d682e800dc7d
--- /dev/null
+++ b/code/train/C++/0059645_m3humanoid_shm_test.cpp
@@ -0,0 +1,249 @@
+/* 
+M3 -- Meka Robotics Real-Time Control System
+Copyright (c) 2010 Meka Robotics
+Author: edsinger@mekabot.com (Aaron Edsinger)
+
+M3 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 3 of the License, or
+(at your option) any later version.
+
+M3 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 M3.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include <rtai_sched.h>
+#include <stdio.h>
+#include <signal.h>
+#include <rtai_shm.h>
+#include <rtai.h>
+#include <rtai_sem.h>
+//#include "m3rt/base/m3ec_def.h>
+//#include "m3rt/base/m3rt_def.h>
+#include <rtai_nam2num.h>
+#include <rtai_registry.h>
+#include "m3/robots/humanoid_shm_sds.h"
+
+
+#define RT_TASK_FREQUENCY_BOT_SHM 400
+#define RT_TIMER_TICKS_NS_BOT_SHM (1000000000 / RT_TASK_FREQUENCY_BOT_SHM)		//Period of rt-timer 
+#define BOT_SHM "TSHMM"
+#define BOT_CMD_SEM "TSHMC"
+#define BOT_STATUS_SEM "TSHMS"
+
+////////////////////////////////////////////////////////////////////////////////////
+static int sys_thread_active = 0;
+static int sys_thread_end=0;
+static int end=0;
+static int hst;
+static M3HumanoidShmSdsCommand cmd;
+static M3HumanoidShmSdsStatus status;
+static int sds_status_size;
+static int sds_cmd_size;
+static long step_cnt = 0;
+static void endme(int dummy) { end=1; }
+////////////////////////////////////////////////////////////////////////////////////
+////// TorqueShm API:
+
+///////  Periodic Control Loop:
+void StepHumanoidShm();
+
+///////////////////////////////
+
+void SetTimestamp(int64_t  timestamp)
+{
+  cmd.timestamp = timestamp;
+    return; 
+}
+
+int64_t GetTimestamp()
+{  
+    return status.timestamp; 
+}
+
+////////////////////////// MAIN COMPUTATION METHOD /////////////////////////////
+
+    
+
+void StepHumanoidShm(int cntr)
+{   
+    SetTimestamp(GetTimestamp()); //Pass back timestamp as a heartbeat
+  
+    
+      
+      
+      for (int i = 0; i < 7; i++)
+      {
+	//cmd.right_arm.ctrl_mode[i] = JOINT_ARRAY_MODE_TORQUE;
+	cmd.right_arm.ctrl_mode[i] = JOINT_ARRAY_MODE_THETA_GC;
+	cmd.right_arm.q_desired[i] = 0.0;
+	cmd.right_arm.tq_desired[i] = 40.0;
+	cmd.right_arm.slew_rate_q_desired[i] = 10.0;
+	cmd.right_arm.q_stiffness[i] = 0.35;	
+      }
+      
+
+      if (cntr % RT_TASK_FREQUENCY_BOT_SHM == 0)
+      {
+	printf("------------------------------\n");
+	printf("timestamp: %ld\n",GetTimestamp() );
+	 
+	/*printf("Fx: %f\n", status.right_loadx6.wrench[0]);
+	printf("Fy: %f\n", status.right_loadx6.wrench[1]);
+	printf("Fz: %f\n", status.right_loadx6.wrench[2]);
+	printf("Tx: %f\n", status.right_loadx6.wrench[3]);
+	printf("Ty: %f\n", status.right_loadx6.wrench[4]);
+	printf("Tz: %f\n", status.right_loadx6.wrench[5]);*/
+	  
+	for (int i = 0; i < 7; i++)
+	{
+	    //printf("jnt_tq: %i, %f\n", i, status.right_arm.torque[i]);
+	    printf("joint_angle_read: %i, %f\n", i, status.right_arm.theta[i]);
+	    printf("joint_angle_command: %i, %f\n", i, cmd.right_arm.q_desired[i]);	    
+	    //printf("jnt_vel: %i, %f\n", i, status.right_arm.thetadot[i]);	    
+	}
+	
+	
+	
+      }
+}
+
+////////////////////////// RTAI PROCESS BOILERPLATE /////////////////////////////
+
+static void* rt_system_thread(void * arg)
+{	
+	SEM * status_sem;
+	SEM * command_sem;
+	RT_TASK *task;
+	int cntr=0;
+	M3Sds * sds = (M3Sds *)arg;
+	printf("Starting real-time thread\n",0);
+		
+	
+	sds_status_size = sizeof(M3HumanoidShmSdsStatus);
+	sds_cmd_size = sizeof(M3HumanoidShmSdsCommand);
+	
+	memset(&cmd, 0, sds_cmd_size);
+	
+	task = rt_task_init_schmod(nam2num("TSHMP"), 0, 0, 0, SCHED_FIFO, 0xF);
+	rt_allow_nonroot_hrt();
+	if (task==NULL)
+	{
+		printf("Failed to create RT-TASK TSHMP\n",0);
+		return 0;
+	}
+	status_sem=(SEM*)rt_get_adr(nam2num(BOT_STATUS_SEM));
+	command_sem=(SEM*)rt_get_adr(nam2num(BOT_CMD_SEM));
+	if (!status_sem)
+	{
+		printf("Unable to find the %s semaphore.\n",BOT_STATUS_SEM);
+		rt_task_delete(task);
+		return 0;
+	}
+	if (!command_sem)
+	{
+		printf("Unable to find the %s semaphore.\n",BOT_CMD_SEM);
+		rt_task_delete(task);
+		return 0;
+	}
+	
+	
+	RTIME tick_period = nano2count(RT_TIMER_TICKS_NS_BOT_SHM); 
+	RTIME now = rt_get_time();
+	rt_task_make_periodic(task, now + tick_period, tick_period); 
+	mlockall(MCL_CURRENT | MCL_FUTURE);
+	rt_make_hard_real_time();
+	long long start_time, end_time, dt;
+	long long step_cnt = 0;
+	sys_thread_active=1;
+	
+	
+	
+	while(!sys_thread_end)
+	{
+		start_time = nano2count(rt_get_cpu_time_ns());
+		rt_sem_wait(status_sem);
+		memcpy(&status, sds->status, sds_status_size);		
+		rt_sem_signal(status_sem);
+		
+		StepHumanoidShm(cntr);		
+		
+		rt_sem_wait(command_sem);
+		memcpy(sds->cmd, &cmd, sds_cmd_size);		
+		rt_sem_signal(command_sem);
+				
+		end_time = nano2count(rt_get_cpu_time_ns());
+		dt=end_time-start_time;
+		/*
+		Check the time it takes to run components, and if it takes longer
+		than our period, make us run slower. Otherwise this task locks
+		up the CPU.*/
+		if (dt > tick_period && step_cnt>10) 
+		{
+			printf("Step %lld: Computation time of components is too long. Forcing all components to state SafeOp.\n",step_cnt);
+			printf("Previous period: %f. New period: %f\n", (double)count2nano(tick_period),(double)count2nano(dt));
+ 			tick_period=dt;
+			rt_task_make_periodic(task, end + tick_period,tick_period);			
+		}
+		step_cnt++;
+		cntr++;
+		rt_task_wait_period();
+	}	
+	printf("Exiting RealTime Thread...\n",0);
+	rt_make_soft_real_time();
+	rt_task_delete(task);
+	sys_thread_active=0;
+	return 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+int main (void)
+{	
+	RT_TASK *task;
+	M3Sds * sys;
+	int cntr=0;
+	
+	signal(SIGINT, endme);
+
+	if (sys = (M3Sds*)rt_shm_alloc(nam2num(BOT_SHM),sizeof(M3Sds),USE_VMALLOC))
+		printf("Found shared memory starting m3humandoid_shm_test.\n");
+	else
+	{
+		printf("Rtai_malloc failure for %s\n",BOT_SHM);
+		return 0;
+	}
+
+	rt_allow_nonroot_hrt();
+	/*if (!(task = rt_task_init_schmod(nam2num("TSHM"), RT_TASK_PRIORITY, 0, 0, SCHED_FIFO, 0xF)))
+	{
+		rt_shm_free(nam2num(TORQUE_SHM));
+		printf("Cannot init the RTAI task %s\n","TSHM");
+		return 0;
+	}*/
+	hst=rt_thread_create((void*)rt_system_thread, sys, 10000);
+	usleep(100000); //Let start up
+	if (!sys_thread_active)
+	{
+		rt_task_delete(task);
+		rt_shm_free(nam2num(BOT_SHM));
+		printf("Startup of thread failed.\n",0);
+		return 0;
+	}
+	while(!end)
+	{		
+		usleep(250000);
+		
+	}
+	printf("Removing RT thread...\n",0);
+	sys_thread_end=1;
+	rt_thread_join(hst);
+	if (sys_thread_active)printf("Real-time thread did not shutdown correctly\n");
+	rt_task_delete(task);
+	rt_shm_free(nam2num(BOT_SHM));
+	return 0;
+}
+
diff --git a/code/train/C++/0059790_MemRefDataFlowOpt.cpp b/code/train/C++/0059790_MemRefDataFlowOpt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c531ca551b4670246538a76e6ad162b86b59b4bb
--- /dev/null
+++ b/code/train/C++/0059790_MemRefDataFlowOpt.cpp
@@ -0,0 +1,236 @@
+//===- MemRefDataFlowOpt.cpp - MemRef DataFlow Optimization pass ------ -*-===//
+//
+// Copyright 2019 The MLIR 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
+//
+// 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.
+// =============================================================================
+//
+// This file implements a pass to forward memref stores to loads, thereby
+// potentially getting rid of intermediate memref's entirely.
+// TODO(mlir-team): In the future, similar techniques could be used to eliminate
+// dead memref store's and perform more complex forwarding when support for
+// SSA scalars live out of 'affine.for'/'affine.if' statements is available.
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Analysis/AffineAnalysis.h"
+#include "mlir/Analysis/Dominance.h"
+#include "mlir/Analysis/Utils.h"
+#include "mlir/Dialect/AffineOps/AffineOps.h"
+#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/Passes.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include <algorithm>
+
+#define DEBUG_TYPE "memref-dataflow-opt"
+
+using namespace mlir;
+
+namespace {
+
+// The store to load forwarding relies on three conditions:
+//
+// 1) they need to have mathematically equivalent affine access functions
+// (checked after full composition of load/store operands); this implies that
+// they access the same single memref element for all iterations of the common
+// surrounding loop,
+//
+// 2) the store op should dominate the load op,
+//
+// 3) among all op's that satisfy both (1) and (2), the one that postdominates
+// all store op's that have a dependence into the load, is provably the last
+// writer to the particular memref location being loaded at the load op, and its
+// store value can be forwarded to the load. Note that the only dependences
+// that are to be considered are those that are satisfied at the block* of the
+// innermost common surrounding loop of the <store, load> being considered.
+//
+// (* A dependence being satisfied at a block: a dependence that is satisfied by
+// virtue of the destination operation appearing textually / lexically after
+// the source operation within the body of a 'affine.for' operation; thus, a
+// dependence is always either satisfied by a loop or by a block).
+//
+// The above conditions are simple to check, sufficient, and powerful for most
+// cases in practice - they are sufficient, but not necessary --- since they
+// don't reason about loops that are guaranteed to execute at least once or
+// multiple sources to forward from.
+//
+// TODO(mlir-team): more forwarding can be done when support for
+// loop/conditional live-out SSA values is available.
+// TODO(mlir-team): do general dead store elimination for memref's. This pass
+// currently only eliminates the stores only if no other loads/uses (other
+// than dealloc) remain.
+//
+struct MemRefDataFlowOpt : public FunctionPass<MemRefDataFlowOpt> {
+  void runOnFunction() override;
+
+  void forwardStoreToLoad(AffineLoadOp loadOp);
+
+  // A list of memref's that are potentially dead / could be eliminated.
+  SmallPtrSet<Value *, 4> memrefsToErase;
+  // Load op's whose results were replaced by those forwarded from stores.
+  SmallVector<Operation *, 8> loadOpsToErase;
+
+  DominanceInfo *domInfo = nullptr;
+  PostDominanceInfo *postDomInfo = nullptr;
+};
+
+} // end anonymous namespace
+
+/// Creates a pass to perform optimizations relying on memref dataflow such as
+/// store to load forwarding, elimination of dead stores, and dead allocs.
+std::unique_ptr<OpPassBase<FuncOp>> mlir::createMemRefDataFlowOptPass() {
+  return std::make_unique<MemRefDataFlowOpt>();
+}
+
+// This is a straightforward implementation not optimized for speed. Optimize
+// if needed.
+void MemRefDataFlowOpt::forwardStoreToLoad(AffineLoadOp loadOp) {
+  Operation *loadOpInst = loadOp.getOperation();
+
+  // First pass over the use list to get minimum number of surrounding
+  // loops common between the load op and the store op, with min taken across
+  // all store ops.
+  SmallVector<Operation *, 8> storeOps;
+  unsigned minSurroundingLoops = getNestingDepth(*loadOpInst);
+  for (auto *user : loadOp.getMemRef()->getUsers()) {
+    auto storeOp = dyn_cast<AffineStoreOp>(user);
+    if (!storeOp)
+      continue;
+    auto *storeOpInst = storeOp.getOperation();
+    unsigned nsLoops = getNumCommonSurroundingLoops(*loadOpInst, *storeOpInst);
+    minSurroundingLoops = std::min(nsLoops, minSurroundingLoops);
+    storeOps.push_back(storeOpInst);
+  }
+
+  // The list of store op candidates for forwarding that satisfy conditions
+  // (1) and (2) above - they will be filtered later when checking (3).
+  SmallVector<Operation *, 8> fwdingCandidates;
+
+  // Store ops that have a dependence into the load (even if they aren't
+  // forwarding candidates). Each forwarding candidate will be checked for a
+  // post-dominance on these. 'fwdingCandidates' are a subset of depSrcStores.
+  SmallVector<Operation *, 8> depSrcStores;
+
+  for (auto *storeOpInst : storeOps) {
+    MemRefAccess srcAccess(storeOpInst);
+    MemRefAccess destAccess(loadOpInst);
+    // Find stores that may be reaching the load.
+    FlatAffineConstraints dependenceConstraints;
+    unsigned nsLoops = getNumCommonSurroundingLoops(*loadOpInst, *storeOpInst);
+    unsigned d;
+    // Dependences at loop depth <= minSurroundingLoops do NOT matter.
+    for (d = nsLoops + 1; d > minSurroundingLoops; d--) {
+      DependenceResult result = checkMemrefAccessDependence(
+          srcAccess, destAccess, d, &dependenceConstraints,
+          /*dependenceComponents=*/nullptr);
+      if (hasDependence(result))
+        break;
+    }
+    if (d == minSurroundingLoops)
+      continue;
+
+    // Stores that *may* be reaching the load.
+    depSrcStores.push_back(storeOpInst);
+
+    // 1. Check if the store and the load have mathematically equivalent
+    // affine access functions; this implies that they statically refer to the
+    // same single memref element. As an example this filters out cases like:
+    //     store %A[%i0 + 1]
+    //     load %A[%i0]
+    //     store %A[%M]
+    //     load %A[%N]
+    // Use the AffineValueMap difference based memref access equality checking.
+    if (srcAccess != destAccess)
+      continue;
+
+    // 2. The store has to dominate the load op to be candidate.
+    if (!domInfo->dominates(storeOpInst, loadOpInst))
+      continue;
+
+    // We now have a candidate for forwarding.
+    fwdingCandidates.push_back(storeOpInst);
+  }
+
+  // 3. Of all the store op's that meet the above criteria, the store that
+  // postdominates all 'depSrcStores' (if one exists) is the unique store
+  // providing the value to the load, i.e., provably the last writer to that
+  // memref loc.
+  // Note: this can be implemented in a cleaner way with postdominator tree
+  // traversals. Consider this for the future if needed.
+  Operation *lastWriteStoreOp = nullptr;
+  for (auto *storeOpInst : fwdingCandidates) {
+    if (llvm::all_of(depSrcStores, [&](Operation *depStore) {
+          return postDomInfo->postDominates(storeOpInst, depStore);
+        })) {
+      lastWriteStoreOp = storeOpInst;
+      break;
+    }
+  }
+  if (!lastWriteStoreOp)
+    return;
+
+  // Perform the actual store to load forwarding.
+  Value *storeVal = cast<AffineStoreOp>(lastWriteStoreOp).getValueToStore();
+  loadOp.replaceAllUsesWith(storeVal);
+  // Record the memref for a later sweep to optimize away.
+  memrefsToErase.insert(loadOp.getMemRef());
+  // Record this to erase later.
+  loadOpsToErase.push_back(loadOpInst);
+}
+
+void MemRefDataFlowOpt::runOnFunction() {
+  // Only supports single block functions at the moment.
+  FuncOp f = getFunction();
+  if (f.getBlocks().size() != 1) {
+    markAllAnalysesPreserved();
+    return;
+  }
+
+  domInfo = &getAnalysis<DominanceInfo>();
+  postDomInfo = &getAnalysis<PostDominanceInfo>();
+
+  loadOpsToErase.clear();
+  memrefsToErase.clear();
+
+  // Walk all load's and perform load/store forwarding.
+  f.walk([&](AffineLoadOp loadOp) { forwardStoreToLoad(loadOp); });
+
+  // Erase all load op's whose results were replaced with store fwd'ed ones.
+  for (auto *loadOp : loadOpsToErase) {
+    loadOp->erase();
+  }
+
+  // Check if the store fwd'ed memrefs are now left with only stores and can
+  // thus be completely deleted. Note: the canonicalize pass should be able
+  // to do this as well, but we'll do it here since we collected these anyway.
+  for (auto *memref : memrefsToErase) {
+    // If the memref hasn't been alloc'ed in this function, skip.
+    Operation *defInst = memref->getDefiningOp();
+    if (!defInst || !isa<AllocOp>(defInst))
+      // TODO(mlir-team): if the memref was returned by a 'call' operation, we
+      // could still erase it if the call had no side-effects.
+      continue;
+    if (llvm::any_of(memref->getUsers(), [&](Operation *ownerInst) {
+          return (!isa<AffineStoreOp>(ownerInst) && !isa<DeallocOp>(ownerInst));
+        }))
+      continue;
+
+    // Erase all stores, the dealloc, and the alloc on the memref.
+    for (auto *user : llvm::make_early_inc_range(memref->getUsers()))
+      user->erase();
+    defInst->erase();
+  }
+}
+
+static PassRegistration<MemRefDataFlowOpt>
+    pass("memref-dataflow-opt", "Perform store/load forwarding for memrefs");
diff --git a/code/train/C++/0060355_uiinspector.cpp b/code/train/C++/0060355_uiinspector.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8fb21e4fb632ab75d54af6b11b66f3bdaac3157b
--- /dev/null
+++ b/code/train/C++/0060355_uiinspector.cpp
@@ -0,0 +1,167 @@
+/*
+    QSnapshot, a screen capture tool.
+    Copyright (C)  2012 Wei Cheng Pan <legnaleurc@gmail>
+
+    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 "utility/uiinspector.hpp"
+
+#include <QtGui/QCursor>
+
+#include <Windows.h>
+
+namespace {
+
+	const int minSize = 8;
+	uint cxWindowBorder;
+	uint cyWindowBorder;
+
+	QPixmap grabWindow( HWND hWnd ) {
+		RECT windowRect;
+		GetWindowRect(hWnd, &windowRect);
+		int w = windowRect.right - windowRect.left;
+		int h = windowRect.bottom - windowRect.top;
+		HDC targetDC = GetWindowDC(hWnd);
+		HDC hDC = CreateCompatibleDC(targetDC);
+		HBITMAP tempPict = CreateCompatibleBitmap(targetDC, w, h);
+		HGDIOBJ oldPict = SelectObject(hDC, tempPict);
+		BitBlt(hDC, 0, 0, w, h, targetDC, 0, 0, SRCCOPY);
+		tempPict = (HBITMAP) SelectObject(hDC, oldPict);
+		QPixmap pm = QPixmap::fromWinHBITMAP(tempPict);
+
+		DeleteDC(hDC);
+		ReleaseDC(hWnd, targetDC);
+
+		return pm;
+	}
+
+	HWND windowUnderCursor( bool includeDecorations = true ) {
+		POINT pointCursor;
+		QPoint qpointCursor = QCursor::pos();
+		pointCursor.x = qpointCursor.x();
+		pointCursor.y = qpointCursor.y();
+		HWND windowUnderCursor = WindowFromPoint(pointCursor);
+
+		if( includeDecorations ) {
+			LONG_PTR style = GetWindowLongPtr( windowUnderCursor, GWL_STYLE );
+			if( ( style & WS_CHILD ) != 0 ) {
+				windowUnderCursor = GetAncestor( windowUnderCursor, GA_ROOT );
+			}
+		}
+		return windowUnderCursor;
+	}
+
+	bool maybeAddWindow( HWND hwnd, std::vector< QRect > * windows) {
+		WINDOWINFO wi;
+		GetWindowInfo( hwnd, &wi );
+		RECT rect = wi.rcClient;
+
+	#if 0
+		RECT rect;
+		GetWindowRect( hwnd, &rect );
+	#endif
+
+		int width = rect.right - rect.left;
+		int height = rect.bottom - rect.top;
+
+		// For some reason, rect.left and rect.top are shifted by cxWindowBorders and cyWindowBorders pixels respectively
+		// in *every* case (for every window), but cxWindowBorders and cyWindowBorders are non-zero only in the
+		// biggest-window case, therefore we need to save the biggest cxWindowBorders and cyWindowBorders to adjust the rect later
+		cxWindowBorder = qMax( cxWindowBorder, wi.cxWindowBorders );
+		cyWindowBorder = qMax( cyWindowBorder, wi.cyWindowBorders );
+
+		if ( ( ( wi.dwStyle & WS_VISIBLE ) != 0 ) && (width >= minSize ) && (height >= minSize ) ) {
+			//QRect r( rect.left + 4, rect.top + 4, width, height); // 4 = max(wi.cxWindowBorders) = max(wi.cyWindowBorders)
+			QRect r(rect.left + cxWindowBorder, rect.top + cyWindowBorder, width, height);
+			if ( std::find( windows->begin(), windows->end(), r ) == windows->end() ) {
+				windows->push_back( r );
+				return true;
+			}
+		}
+		return false;
+	}
+
+	BOOL CALLBACK getWindowsRecursiveHelper( HWND hwnd, LPARAM lParam ) {
+		maybeAddWindow( hwnd, reinterpret_cast< std::vector< QRect > * >( lParam ) );
+		return TRUE;
+	}
+
+	void getWindowsRecursive( std::vector< QRect > & windows, HWND hwnd, int rx = 0, int ry = 0, int depth = 0 ) {
+		maybeAddWindow( hwnd, &windows );
+
+		EnumChildWindows( hwnd, getWindowsRecursiveHelper, reinterpret_cast< LPARAM >( &windows ) );
+
+		std::sort( windows.begin(), windows.end() );
+	}
+
+}
+
+bool operator< ( const QRect& r1, const QRect& r2 ) {
+	return r1.width() * r1.height() < r2.width() * r2.height();
+}
+
+std::tuple< QPixmap, QRect, std::vector< QRect > > qsnapshot::utility::grabWindow() {
+	HWND child = windowUnderCursor();
+
+	WINDOWINFO wi;
+	GetWindowInfo( child, &wi);
+
+	RECT r;
+	GetWindowRect( child, &r);
+	int x = r.left;
+	int y = r.top;
+	uint w = r.right - r.left;
+	uint h = r.bottom - r.top;
+	cxWindowBorder = wi.cxWindowBorders;
+	cyWindowBorder = wi.cyWindowBorders;
+
+	HDC childDC = GetDC(child);
+	Q_UNUSED( childDC );
+
+	QPixmap pm( ::grabWindow( child ) );
+	std::vector< QRect > windows;
+	getWindowsRecursive( windows, child );
+	QRect windowGeometry( QPoint( r.left, r.top ), pm.size() );
+	QPoint offset( r.left + wi.cxWindowBorders, r.top + wi.cyWindowBorders );
+	std::for_each( windows.begin(), windows.end(), [&offset]( QRect & r )->void {
+		r.translate( -offset );
+	} );
+
+	return std::make_tuple( pm, windowGeometry, windows );
+}
+
+std::tuple< QPixmap, QPoint > qsnapshot::utility::grabCurrent( bool includeDecorations ) {
+	int x, y;
+	HWND hWindow;
+	hWindow = windowUnderCursor(includeDecorations);
+	Q_ASSERT(hWindow);
+
+	HWND hParent;
+
+// Now find the top-most window
+	do {
+	  hParent = hWindow;
+	} while( (hWindow = GetParent(hWindow)) != NULL );
+	Q_ASSERT(hParent);
+
+	RECT r;
+	GetWindowRect(hParent, &r);
+
+	x = r.left;
+	y = r.top;
+
+	QPixmap pm( ::grabWindow( hParent ) );
+	return std::make_tuple( pm, QPoint( x, y ) );
+}
diff --git a/code/train/C++/0061878_main.cpp b/code/train/C++/0061878_main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7e7916ef5c4734abfcd38e55a52cf1608c160145
--- /dev/null
+++ b/code/train/C++/0061878_main.cpp
@@ -0,0 +1,265 @@
+/*
+ * This file is a part of pl0-compiler.
+ *
+ * Copyright (C) 2012 xStone <chen_fu_hua@126.com>
+ *
+ * pl0-compiler is free software; you can redestribute it and/or modify it
+ * under terms of GNU General Public License by Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY. See GPL for more details.
+ */
+
+#include<cstring>
+#include<fstream>
+#include<iomanip>
+#include<iostream>
+#include<sstream>
+#include<string>
+#include"ast/ast.h"
+#include"code_gen/code_generator.h"
+#include"lex/lexer.h"
+#include"machine/machine.h"
+#include"parse/parser.h"
+using namespace pl0;
+
+
+void display_usage();
+std::string read_file_data(const char* file_name);
+void output_token_stream(Lexer& lexer, bool lex);
+void output_ast(Parser& parser, bool parse);
+void output_pcode(CodeGenerator& generator, bool analytics);
+void execute_pcode(Machine& machine, bool execute);
+
+
+int main(int argc, char* argv[])
+{
+    bool lex = false;
+    bool parse = false;
+    bool analytics = false;
+    bool execute = false;
+    const char* file_name = 0;
+
+    char opt = 0;
+    for (int i = 1; i < argc; i++) {
+        if (argv[i][0] == '-' && std::strlen(argv[i]) == 2) {
+            opt = argv[i][1];
+        } else if (argv[i][0] != '-' && file_name == 0) {
+            file_name = argv[i];
+            continue;;
+        } else {
+            opt = '?';
+        }
+        switch (opt) {
+            case 'l':
+                lex = true;
+                break;
+            case 'p':
+                parse = true;
+                break;
+            case 'a':
+                analytics = true;
+                break;
+            case 'e':
+                execute = true;
+                break;
+            case '?':
+            default:
+                display_usage();
+                exit(EXIT_FAILURE);
+        }
+    }
+    if (file_name == 0) {
+        display_usage();
+        exit(EXIT_FAILURE);
+    }
+
+    std::string file_data = read_file_data(file_name);
+
+    std::cout << "Run pl0-compiler ...\n\n";
+
+    if (!lex && !parse && !analytics && !execute) {
+        std::cout << "Finish pl0-compiler ...\n\n" << std::flush;
+        return 0;
+    }
+    Lexer lexer(file_data);
+    output_token_stream(lexer, lex);
+
+    if (!parse && !analytics && !execute) {
+        std::cout << "Finish pl0-compiler ...\n\n" << std::flush;
+        return 0;
+    }
+    Parser parser(file_data);
+    output_ast(parser, parse);
+
+    if (parser.parseProgram() == 0) {
+        std::cout << "Finish pl0-compiler ...\n\n" << std::flush;
+        return 0;
+    }
+    CodeGenerator generator(parser.parseProgram());
+    output_pcode(generator, analytics);
+
+    Machine machine(generator.getProgramCode());
+    execute_pcode(machine, execute);
+
+    std::cout << "Finish pl0-compiler ...\n\n" << std::flush;
+
+    return 0;
+}
+
+
+void display_usage()
+{
+    std::cout << "\n"
+              << "Usage: \n"
+              << "pl0-compiler [ flags ] source_code_file\n"
+              << "\n"
+              << "Flags: \n"
+              << "-l: lex source code, and output token stream.\n"
+              << "-p: parse token stream, and output abstract syntax tree.\n"
+              << "-a: analytics abstract syntax tree, and output pcode.\n"
+              << "-e: execute pcode.\n"
+              << "-?: help.\n";
+}
+
+std::string read_file_data(const char* file_name)
+{
+    std::ifstream ifs(file_name);
+    std::string file_data;
+    if (ifs) {
+        std::stringstream buffer;
+        buffer << ifs.rdbuf();
+        file_data = buffer.str();
+    } else {
+        std::cout << "Cannot open file: " << file_name << "\n\n";
+        exit(EXIT_FAILURE);
+    }
+    ifs.close();
+    return file_data;
+}
+
+void output_token_stream(Lexer& lexer, bool lex)
+{
+    std::cout << "Start lex source code ...\n\n";
+
+    if (!lex) {
+        return;
+    }
+
+    const char* const file_name = "token_stream.txt";
+    std::ofstream ofs(file_name);
+    if (!ofs) {
+        std::cout << "Cannot create output file: " << file_name << "\n\n";
+        exit(EXIT_FAILURE);
+    }
+
+    std::stringstream source_buffer;
+    std::stringstream token_buffer;
+    token_buffer.setf(std::ios::left);
+    Token token;
+
+    lexer.lex(token);
+    unsigned line_number = token.getSourceLocation().getLineNumber();
+    unsigned token_line_number = line_number;
+    while (true) {
+        token_line_number = token.getSourceLocation().getLineNumber();
+
+        if (line_number < token_line_number) {
+            ofs << line_number << ":" << source_buffer.str() << "\n";
+            ofs << token_buffer.str();
+            line_number = token_line_number;
+            source_buffer.str("");
+            token_buffer.str("");
+        }
+
+        if (token.is(Token::Kind::eof)) {
+            ofs << "    " << std::setw(2) <<token_line_number << ": eof\n";
+            break;
+        }
+
+        source_buffer << " " << token.getRawData();
+
+        token_buffer << "    " << std::setw(2) << token_line_number << ": "
+                     << std::setw(16) << token.getTokenKindName()
+                     << token.getRawData() << "\n";
+
+        lexer.lex(token);
+    }
+
+    std::cout << "Generate token stream file: " << file_name << " ...\n\n";
+}
+
+void output_ast(Parser& /*parser*/, bool parse)
+{
+    std::cout << "Start parse token stream ...\n\n";
+
+    if (!parse) {
+        return;
+    }
+}
+
+void output_pcode(CodeGenerator& generator, bool analytics)
+{
+    std::cout << "Start analytics abstract syntax tree ...\n\n";
+
+    if (!analytics) {
+        return;
+    }
+
+    const char* const file_name = "pcode.txt";
+    std::ofstream ofs(file_name);
+    if (!ofs) {
+        std::cout << "Cannot create output file: " << file_name << "\n\n";
+        exit(EXIT_FAILURE);
+    }
+
+    std::vector<PCode> code = generator.getProgramCode();
+    PCode c;
+    for (size_t i = 0; i < code.size(); i++) {
+        c = code[i];
+        ofs << std::setw(3) << i << ":  ";
+        switch (c.f) {
+            case PCode::OpCode::Lit:
+                ofs << "Lit";
+                break;
+            case PCode::OpCode::Lod:
+                ofs << "Lod";
+                break;
+            case PCode::OpCode::Sto:
+                ofs << "Sto";
+                break;
+            case PCode::OpCode::Cal:
+                ofs << "Cal";
+                break;
+            case PCode::OpCode::Int:
+                ofs << "Int";
+                break;
+            case PCode::OpCode::Jmp:
+                ofs << "Jmp";
+                break;
+            case PCode::OpCode::Jpc:
+                ofs << "Jpc";
+                break;
+            case PCode::OpCode::Opr:
+                ofs << "Opr";
+                break;
+        }
+        ofs << "  " << std::setw(2) << c.l
+            << "  " << c.a << "\n";
+    }
+
+    std::cout << "Generate pcode file: " << file_name << " ...\n\n";
+}
+
+void execute_pcode(Machine& machine, bool execute)
+{
+    std::cout << "Start execute pcode ...\n\n";
+
+    if (!execute) {
+        return;
+    }
+
+    machine.start();
+
+    std::cout << "\n";
+}
diff --git a/code/train/C++/0061995_Bottom.cc b/code/train/C++/0061995_Bottom.cc
new file mode 100644
index 0000000000000000000000000000000000000000..adfd13bdbad222a01c3030d57eeba317b3ea3279
--- /dev/null
+++ b/code/train/C++/0061995_Bottom.cc
@@ -0,0 +1,263 @@
+// Copyright (C) 2007-2010 Dominik Dahlem <Dominik.Dahlem@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 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 Bottom.cc
+ * Implementation of the bottom structure @ref{Bottom.hh} of the Ladder Queue.
+ */
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#ifndef NDEBUG_QUEUE
+# include <iostream>
+# include <iomanip>
+#endif /* NDEBUG_QUEUE */
+
+#ifdef HAVE_LADDERSTATS
+# include <iostream>
+# include <ostream>
+# include <string>
+
+# include <boost/iostreams/stream.hpp>
+namespace bio = boost::iostreams;
+
+# include <boost/shared_ptr.hpp>
+#endif /* HAVE_LADDERSTATS */
+
+#include <cstddef>
+
+#include "Bottom.hh"
+#include "Entry.hh"
+
+namespace des
+{
+namespace common
+{
+
+
+Bottom::Bottom()
+    : m_lastEvent(0.0), m_list(new EntryList())
+{
+#ifdef HAVE_LADDERSTATS
+    events_in = 0;
+    events_out = 0;
+
+    std::string bottomfile = "./bottom-stats.txt";
+
+    // create a buffer
+    buf = tStrBufSP(new str_buf(bottomfile.c_str()));
+
+    // create a output stream
+    os = tOstreamSP(new std::ostream(buf.get()));
+    (*os.get()) << "EventsIn,EventsOut,NumEvents"  << std::endl;
+#endif /* HAVE_LADDERSTATS */
+}
+
+
+Bottom::~Bottom()
+{
+    m_list->erase_and_dispose(m_list->begin(), m_list->end(),
+                              delete_disposer());
+
+    if (m_list != NULL) {
+        delete m_list;
+    }
+}
+
+
+#ifdef HAVE_LADDERSTATS
+void Bottom::record()
+{
+    (*os.get()) << events_in << "," << events_out << "," << size() << std::endl;
+
+    // reset the stat fields
+    events_in = 0;
+    events_out = 0;
+}
+#endif /* HAVE_LADDERSTATS */
+
+
+boost::uint32_t Bottom::size()
+{
+    return static_cast<boost::uint32_t> (m_list->size());
+}
+
+
+/**
+ * Insert an entry into the bottom structure. Since the bottom structure
+ * maintains a sorted list, this enqueue operation uses an insertion algorithm
+ * starting from the back of the queue in order to maintain stability. Otherwise,
+ * the bottom structure would not offer stability characteristics.
+ *
+ * @see Queue#push(Entry) throw (QueueException)
+ */
+bool Bottom::push(Entry *p_entry) throw (QueueException)
+{
+#ifndef NDEBUG_QUEUE
+    std::cout << std::setprecision(14) << "Bottom -- Push event: " << const_cast <const Entry&> (*p_entry)
+              << std::endl;
+#endif /* NDEBUG_EVENTS */
+    bool inserted = false;
+
+    if (p_entry->getArrival() < m_lastEvent) {
+#ifndef NDEBUG_QUEUE
+        std::cout << std::setprecision(14) << "Bottom -- PAST event! Last dequeued event: "
+                  << m_lastEvent << std::endl;
+#endif /* NDEBUG_QUEUE */
+        throw QueueException(
+            QueueException::PAST_EVENT_NOT_ALLOWED);
+    }
+
+    if (m_list->empty()) {
+        // insert straight-away
+        m_list->push_back(*p_entry);
+#ifndef NDEBUG_QUEUE
+        std::cout << "Bottom -- Inserted at the back." << std::endl;
+#endif /* NDEBUG_EVENTS */
+        inserted = true;
+    } else {
+        // if the last element is already <= the new entry then insert at the back
+        if (m_list->back().getArrival() <= p_entry->getArrival()) {
+            m_list->push_back(*p_entry);
+#ifndef NDEBUG_QUEUE
+            std::cout << "Bottom -- Inserted at the back." << std::endl;
+#endif /* NDEBUG_EVENTS */
+            inserted = true;
+        } else {
+            // insertion sort from the back
+            // maintain stability
+            EntryList::reverse_iterator it(m_list->rbegin()), itend(m_list->rend());
+
+            for(; it != itend; ++it) {
+                if (it->getArrival() <= p_entry->getArrival()) {
+                    EntryList::iterator pos = m_list->s_iterator_to(*it);
+                    pos++;
+#ifndef NDEBUG_QUEUE
+                    EntryList::iterator pos_start = m_list->s_iterator_to(*it);
+                    std::cout << "Bottom -- Inserted between " << pos_start->getArrival()
+                              << " and " << pos->getArrival() << std::endl;
+#endif /* NDEBUG_EVENTS */
+                    m_list->insert(pos, *p_entry);
+                    inserted = true;
+                    break;
+                }
+            }
+        }
+    }
+
+    // worst case scenario: we ended up iterating from back to front without inserting
+    if (!inserted) {
+        m_list->push_front(*p_entry);
+#ifndef NDEBUG_QUEUE
+        std::cout << "Bottom -- Inserted at the front." << std::endl;
+#endif /* NDEBUG_EVENTS */
+        inserted = true;
+    }
+
+#ifdef HAVE_LADDERSTATS
+    events_in++;
+#endif /* HAVE_LADDERSTATS */
+
+    return inserted;
+}
+
+/**
+ * Insert a list into the bottom structure. If the size of the list to be
+ * inserted is less than 10 elements, an insertion sort algorithm is employed.
+ * Otherwise, a merge sort algorithm is used.
+ *
+ * @see List#enlist(node_double_t*, long)
+ */
+void Bottom::push(EntryList* p_list)
+{
+    // this sort does NOT seem to be stable at all
+    p_list->sort();
+
+#ifndef NDEBUG_QUEUE
+    std::cout << "Bottom -- Push list. Size: " << p_list->size() << std::endl;
+    Entry *ef = reinterpret_cast<Entry*>(&p_list->front());
+    Entry *eb = reinterpret_cast<Entry*>(&p_list->back());
+    std::cout << "from: " << ef->getArrival() << " to: " << eb->getArrival() << std::endl;
+#endif /* NDEBUG_EVENTS */
+
+    m_list->merge(*p_list);
+
+#ifndef NDEBUG_QUEUE
+    std::cout << "Bottom -- Merged lists. Size: " << m_list->size() << std::endl;
+    ef = reinterpret_cast<Entry*>(&m_list->front());
+    eb = reinterpret_cast<Entry*>(&m_list->back());
+    std::cout << "from: " << ef->getArrival() << " to: " << eb->getArrival() << std::endl;
+#endif /* NDEBUG_EVENTS */
+
+#ifdef HAVE_LADDERSTATS
+    events_in += p_list->size();
+#endif /* HAVE_LADDERSTATS */
+}
+
+
+EntryList* Bottom::list()
+{
+    return m_list;
+}
+
+Entry* Bottom::front() throw (QueueException)
+{
+    if (m_list->size() == 0) {
+        throw QueueException(
+            QueueException::QUEUE_EMPTY);
+    }
+
+    return reinterpret_cast<Entry*>(&m_list->front());
+}
+
+void Bottom::pop_front() throw (QueueException)
+{
+    if (m_list->size() == 0) {
+        throw QueueException(
+            QueueException::QUEUE_EMPTY);
+    }
+
+#ifdef HAVE_LADDERSTATS
+    events_out++;
+#endif /* HAVE_LADDERSTATS */
+
+    // record the last event time stamp
+    m_lastEvent = m_list->front().getArrival();
+
+    m_list->pop_front();
+}
+
+double Bottom::getMaxTS()
+{
+    if (!m_list->empty()) {
+        return m_list->back().getArrival();
+    }
+
+    return m_lastEvent;
+}
+
+
+double Bottom::getMinTS()
+{
+    if (!m_list->empty()) {
+        return m_list->front().getArrival();
+    }
+
+    return m_lastEvent;
+}
+
+}
+}
diff --git a/code/train/C++/0062112_helper.cpp b/code/train/C++/0062112_helper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..db6b16c0fd25f657ed3f08b4033908e43ef3c6a4
--- /dev/null
+++ b/code/train/C++/0062112_helper.cpp
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** 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 Digia Plc and its Subsidiary(-ies) 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 "helper.h"
+
+//! [0]
+Helper::Helper()
+{
+    QLinearGradient gradient(QPointF(50, -20), QPointF(80, 20));
+    gradient.setColorAt(0.0, Qt::white);
+    gradient.setColorAt(1.0, QColor(0xa6, 0xce, 0x39));
+
+    background = QBrush(QColor(64, 32, 64));
+    circleBrush = QBrush(gradient);
+    circlePen = QPen(Qt::black);
+    circlePen.setWidth(1);
+    textPen = QPen(Qt::white);
+    textFont.setPixelSize(50);
+}
+//! [0]
+
+//! [1]
+void Helper::paint(QPainter *painter, QPaintEvent *event, int elapsed)
+{
+    painter->fillRect(event->rect(), background);
+    painter->translate(100, 100);
+//! [1]
+
+//! [2]
+    painter->save();
+    painter->setBrush(circleBrush);
+    painter->setPen(circlePen);
+    painter->rotate(elapsed * 0.030);
+
+    qreal r = elapsed/1000.0;
+    int n = 30;
+    for (int i = 0; i < n; ++i) {
+        painter->rotate(30);
+        qreal radius = 0 + 120.0*((i+r)/n);
+        qreal circleRadius = 1 + ((i+r)/n)*20;
+        painter->drawEllipse(QRectF(radius, -circleRadius,
+                                    circleRadius*2, circleRadius*2));
+    }
+    painter->restore();
+//! [2]
+
+//! [3]
+    painter->setPen(textPen);
+    painter->setFont(textFont);
+    painter->drawText(QRect(-50, -50, 100, 100), Qt::AlignCenter, "Qt");
+}
+//! [3]
diff --git a/code/train/C++/0063171_SlotIndexes.cpp b/code/train/C++/0063171_SlotIndexes.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6a7666e8e25f54270730b9113aaede829ec5e99d
--- /dev/null
+++ b/code/train/C++/0063171_SlotIndexes.cpp
@@ -0,0 +1,181 @@
+//===-- SlotIndexes.cpp - Slot Indexes Pass  ------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "slotindexes"
+
+#include "llvm/CodeGen/SlotIndexes.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Target/TargetInstrInfo.h"
+
+using namespace llvm;
+
+char SlotIndexes::ID = 0;
+INITIALIZE_PASS(SlotIndexes, "slotindexes",
+                "Slot index numbering", false, false)
+
+STATISTIC(NumLocalRenum,  "Number of local renumberings");
+STATISTIC(NumGlobalRenum, "Number of global renumberings");
+
+void SlotIndexes::getAnalysisUsage(AnalysisUsage &au) const {
+  au.setPreservesAll();
+  MachineFunctionPass::getAnalysisUsage(au);
+}
+
+void SlotIndexes::releaseMemory() {
+  mi2iMap.clear();
+  MBBRanges.clear();
+  idx2MBBMap.clear();
+  clearList();
+}
+
+bool SlotIndexes::runOnMachineFunction(MachineFunction &fn) {
+
+  // Compute numbering as follows:
+  // Grab an iterator to the start of the index list.
+  // Iterate over all MBBs, and within each MBB all MIs, keeping the MI
+  // iterator in lock-step (though skipping it over indexes which have
+  // null pointers in the instruction field).
+  // At each iteration assert that the instruction pointed to in the index
+  // is the same one pointed to by the MI iterator. This 
+
+  // FIXME: This can be simplified. The mi2iMap_, Idx2MBBMap, etc. should
+  // only need to be set up once after the first numbering is computed.
+
+  mf = &fn;
+  initList();
+
+  // Check that the list contains only the sentinal.
+  assert(indexListHead->getNext() == 0 &&
+         "Index list non-empty at initial numbering?");
+  assert(idx2MBBMap.empty() &&
+         "Index -> MBB mapping non-empty at initial numbering?");
+  assert(MBBRanges.empty() &&
+         "MBB -> Index mapping non-empty at initial numbering?");
+  assert(mi2iMap.empty() &&
+         "MachineInstr -> Index mapping non-empty at initial numbering?");
+
+  functionSize = 0;
+  unsigned index = 0;
+  MBBRanges.resize(mf->getNumBlockIDs());
+  idx2MBBMap.reserve(mf->size());
+
+  push_back(createEntry(0, index));
+
+  // Iterate over the function.
+  for (MachineFunction::iterator mbbItr = mf->begin(), mbbEnd = mf->end();
+       mbbItr != mbbEnd; ++mbbItr) {
+    MachineBasicBlock *mbb = &*mbbItr;
+
+    // Insert an index for the MBB start.
+    SlotIndex blockStartIndex(back(), SlotIndex::Slot_Block);
+
+    for (MachineBasicBlock::iterator miItr = mbb->begin(), miEnd = mbb->end();
+         miItr != miEnd; ++miItr) {
+      MachineInstr *mi = miItr;
+      if (mi->isDebugValue())
+        continue;
+
+      // Insert a store index for the instr.
+      push_back(createEntry(mi, index += SlotIndex::InstrDist));
+
+      // Save this base index in the maps.
+      mi2iMap.insert(std::make_pair(mi, SlotIndex(back(),
+                                                  SlotIndex::Slot_Block)));
+ 
+      ++functionSize;
+    }
+
+    // We insert one blank instructions between basic blocks.
+    push_back(createEntry(0, index += SlotIndex::InstrDist));
+
+    MBBRanges[mbb->getNumber()].first = blockStartIndex;
+    MBBRanges[mbb->getNumber()].second = SlotIndex(back(),
+                                                   SlotIndex::Slot_Block);
+    idx2MBBMap.push_back(IdxMBBPair(blockStartIndex, mbb));
+  }
+
+  // Sort the Idx2MBBMap
+  std::sort(idx2MBBMap.begin(), idx2MBBMap.end(), Idx2MBBCompare());
+
+  DEBUG(dump());
+
+  // And we're done!
+  return false;
+}
+
+void SlotIndexes::renumberIndexes() {
+  // Renumber updates the index of every element of the index list.
+  DEBUG(dbgs() << "\n*** Renumbering SlotIndexes ***\n");
+  ++NumGlobalRenum;
+
+  unsigned index = 0;
+
+  for (IndexListEntry *curEntry = front(); curEntry != getTail();
+       curEntry = curEntry->getNext()) {
+    curEntry->setIndex(index);
+    index += SlotIndex::InstrDist;
+  }
+}
+
+// Renumber indexes locally after curEntry was inserted, but failed to get a new
+// index.
+void SlotIndexes::renumberIndexes(IndexListEntry *curEntry) {
+  // Number indexes with half the default spacing so we can catch up quickly.
+  const unsigned Space = SlotIndex::InstrDist/2;
+  assert((Space & 3) == 0 && "InstrDist must be a multiple of 2*NUM");
+
+  IndexListEntry *start = curEntry->getPrev();
+  unsigned index = start->getIndex();
+  IndexListEntry *tail = getTail();
+  do {
+    curEntry->setIndex(index += Space);
+    curEntry = curEntry->getNext();
+    // If the next index is bigger, we have caught up.
+  } while (curEntry != tail && curEntry->getIndex() <= index);
+
+  DEBUG(dbgs() << "\n*** Renumbered SlotIndexes " << start->getIndex() << '-'
+               << index << " ***\n");
+  ++NumLocalRenum;
+}
+
+
+void SlotIndexes::dump() const {
+  for (const IndexListEntry *itr = front(); itr != getTail();
+       itr = itr->getNext()) {
+    dbgs() << itr->getIndex() << " ";
+
+    if (itr->getInstr() != 0) {
+      dbgs() << *itr->getInstr();
+    } else {
+      dbgs() << "\n";
+    }
+  }
+
+  for (unsigned i = 0, e = MBBRanges.size(); i != e; ++i)
+    dbgs() << "BB#" << i << "\t[" << MBBRanges[i].first << ';'
+           << MBBRanges[i].second << ")\n";
+}
+
+// Print a SlotIndex to a raw_ostream.
+void SlotIndex::print(raw_ostream &os) const {
+  if (isValid())
+    os << entry().getIndex() << "Berd"[getSlot()];
+  else
+    os << "invalid";
+}
+
+// Dump a SlotIndex to stderr.
+void SlotIndex::dump() const {
+  print(dbgs());
+  dbgs() << "\n";
+}
+
diff --git a/code/train/C++/0063617_sanitizer_stacktrace.cc b/code/train/C++/0063617_sanitizer_stacktrace.cc
new file mode 100644
index 0000000000000000000000000000000000000000..35396392a0f4b115c039ec0de0cf1b2747471279
--- /dev/null
+++ b/code/train/C++/0063617_sanitizer_stacktrace.cc
@@ -0,0 +1,86 @@
+//===-- sanitizer_stacktrace.cc -------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common.h"
+#include "sanitizer_flags.h"
+#include "sanitizer_stacktrace.h"
+
+namespace __sanitizer {
+
+uptr StackTrace::GetPreviousInstructionPc(uptr pc) {
+#if defined(__arm__)
+  // Cancel Thumb bit.
+  pc = pc & (~1);
+#endif
+#if defined(__powerpc__) || defined(__powerpc64__)
+  // PCs are always 4 byte aligned.
+  return pc - 4;
+#elif defined(__sparc__)
+  return pc - 8;
+#else
+  return pc - 1;
+#endif
+}
+
+uptr StackTrace::GetCurrentPc() {
+  return GET_CALLER_PC();
+}
+
+void StackTrace::FastUnwindStack(uptr pc, uptr bp,
+                                 uptr stack_top, uptr stack_bottom,
+                                 uptr max_depth) {
+  CHECK_GE(max_depth, 2);
+  trace[0] = pc;
+  size = 1;
+  uhwptr *frame = (uhwptr *)bp;
+  uhwptr *prev_frame = frame - 1;
+  if (stack_top < 4096) return;  // Sanity check for stack top.
+  // Avoid infinite loop when frame == frame[0] by using frame > prev_frame.
+  while (frame > prev_frame &&
+         frame < (uhwptr *)stack_top - 2 &&
+         frame > (uhwptr *)stack_bottom &&
+         IsAligned((uptr)frame, sizeof(*frame)) &&
+         size < max_depth) {
+    uhwptr pc1 = frame[1];
+    if (pc1 != pc) {
+      trace[size++] = (uptr) pc1;
+    }
+    prev_frame = frame;
+    frame = (uhwptr *)frame[0];
+  }
+}
+
+static bool MatchPc(uptr cur_pc, uptr trace_pc, uptr threshold) {
+  return cur_pc - trace_pc <= threshold || trace_pc - cur_pc <= threshold;
+}
+
+void StackTrace::PopStackFrames(uptr count) {
+  CHECK_LT(count, size);
+  size -= count;
+  for (uptr i = 0; i < size; ++i) {
+    trace[i] = trace[i + count];
+  }
+}
+
+uptr StackTrace::LocatePcInTrace(uptr pc) {
+  // Use threshold to find PC in stack trace, as PC we want to unwind from may
+  // slightly differ from return address in the actual unwinded stack trace.
+  const int kPcThreshold = 288;
+  for (uptr i = 0; i < size; ++i) {
+    if (MatchPc(pc, trace[i], kPcThreshold))
+      return i;
+  }
+  return 0;
+}
+
+}  // namespace __sanitizer
diff --git a/code/train/C++/0063677_driver.cc b/code/train/C++/0063677_driver.cc
new file mode 100644
index 0000000000000000000000000000000000000000..00f1927df1750803dafa6f5e43ff1a0bfc90349a
--- /dev/null
+++ b/code/train/C++/0063677_driver.cc
@@ -0,0 +1,210 @@
+
+#include "Flagpole.cc"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <sys/time.h>
+#include <vector>
+
+
+const static double __EPSILON = 1e-9;
+static double __time = 0.0;
+
+static void __timer_start()
+{
+	struct timeval tv;
+	if (gettimeofday(&tv, NULL) == 0)
+	{
+		__time = double(tv.tv_sec) * 1000.0 + double(tv.tv_usec) * 0.001;
+	}
+}
+
+static double __timer_stop()
+{
+	double start = __time;
+	__timer_start();
+	return __time - start;
+}
+
+
+static void __eat_whitespace(std::istream& in)
+{
+	while (in.good() && std::isspace(in.peek())) in.get();
+}
+
+
+std::ostream& operator << (std::ostream& out, const std::string& str)
+{
+	out << '"' << str.c_str() << '"';
+	return out;
+}
+
+template <class T>
+std::ostream& operator << (std::ostream& out, const std::vector<T>& vec)
+{
+	out << '{';
+	if (0 < vec.size())
+	{
+		out << vec[0];
+		for (size_t i = 1; i < vec.size(); ++i) out << ", " << vec[i];
+	}
+	out << '}';
+	return out;
+}
+
+std::istream& operator >> (std::istream& in, std::string& str)
+{
+	__eat_whitespace(in);
+
+	int c;
+	if (in.good() && (c = in.get()) == '"')
+	{
+		std::ostringstream s;
+		while (in.good() && (c = in.get()) != '"')
+		{
+			s.put(char(c));
+		}
+		str = s.str();
+	}
+
+	return in;
+}
+
+template <class T>
+std::istream& operator >> (std::istream& in, std::vector<T>& vec)
+{
+	__eat_whitespace(in);
+
+	int c;
+	if (in.good() && (c = in.get()) == '{')
+	{
+		__eat_whitespace(in);
+		vec.clear();
+		while (in.good() && (c = in.get()) != '}')
+		{
+			if (c != ',') in.putback(c);
+
+			T t;
+			in >> t;
+			__eat_whitespace(in);
+
+			vec.push_back(t);
+		}
+	}
+
+	return in;
+}
+
+
+template <class T>
+bool __equals(const T& actual, const T& expected)
+{
+	return actual == expected;
+}
+
+bool __equals(double actual, double expected)
+{
+	if (std::abs(actual - expected) < __EPSILON)
+	{
+		return true;
+	}
+	else
+	{
+		double minimum = std::min(expected * (1.0 - __EPSILON), expected * (1.0 + __EPSILON));
+		double maximum = std::max(expected * (1.0 - __EPSILON), expected * (1.0 + __EPSILON));
+		return actual > minimum && actual < maximum;
+	}
+}
+
+bool __equals(const std::vector<double>& actual, const std::vector<double>& expected)
+{
+	if (actual.size() != expected.size())
+	{
+		return false;
+	}
+
+	for (size_t i = 0; i < actual.size(); ++i)
+	{
+		if (!__equals(actual[i], expected[i]))
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+int main(int argc, char* argv[])
+{
+	bool	__abort_on_fail = false;
+	int	__pass = 0;
+	int	__fail = 0;
+
+	if (1 < argc) __abort_on_fail = true;
+
+	std::cout << "TAP version 13" << std::endl;
+	std::cout.flush();
+
+	std::ifstream __in("testcases.txt");
+	for(;;)
+	{
+		int __testnum = __pass + __fail + 1;
+
+		long long	__expected;
+		vector <int>	segments;
+long long	LO;
+long long	HI;
+
+		__in >> __expected >> segments >> LO >> HI;
+		if (!__in.good()) break;
+
+		std::cout << "# input for test " << __testnum << ": " << segments << ", " << LO << ", " << HI << std::endl;
+		std::cout.flush();
+
+		__timer_start();
+
+		Flagpole __object;
+		long long __actual = __object.build(segments, LO, HI);
+
+		double __t = __timer_stop();
+
+		std::cout << "# test completed in " << __t << "ms" << std::endl;
+		std::cout.flush();
+
+		if (__equals(__actual, __expected))
+		{
+			std::cout << "ok";
+			++__pass;
+		}
+		else
+		{
+			std::cout << "not ok";
+			++__fail;
+		}
+
+		std::cout << " " << __testnum << " - " << __actual << " must equal " << __expected << std::endl;
+		std::cout.flush();
+
+		if (__abort_on_fail && 0 < __fail) std::abort();
+	}
+
+	std::cout << "1.." << (__pass + __fail) << std::endl
+		  << "# passed: " << __pass << std::endl
+		  << "# failed: " << __fail << std::endl;
+
+	if (__fail == 0)
+	{
+		std::cout << std::endl
+			  << "# Nice! Don't forget to compile remotely before submitting." << std::endl;
+	}
+
+	return __fail;
+}
+
+// vim:ft=cpp:noet:ts=8
diff --git a/code/train/C++/0064576_maxSum.cpp b/code/train/C++/0064576_maxSum.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b5d35824c8b96dba8b34c1916fa3bbee6b104136
--- /dev/null
+++ b/code/train/C++/0064576_maxSum.cpp
@@ -0,0 +1,99 @@
+#include <iostream>
+#include <limits>
+
+namespace betacore
+{
+	void kadane( int input[], int n, int &x1, int &x2, int &max )  
+	{  
+		int current_sum;
+		int i;  
+		max = 0;  
+		current_sum = 0;  
+		x1 = x2 = 0;  
+		int lx1, lx2;  
+		lx1 = 0;  
+		for( i = 0; i < n; i++ )  
+		{  
+			current_sum = current_sum + input[i];  
+			if( max < current_sum )  
+			{  
+				max = current_sum;  
+				x2 = i;  
+				x1 = lx1;  
+			}  
+			if ( current_sum < 0 )  
+			{  
+				current_sum = 0;  
+				lx1 = i + 1;  
+			}  
+		}  
+	}
+	
+	template <size_t rows, size_t cols>  
+	void find_max_sum( int (&input) [rows][cols] )  
+	{  
+		int temp[cols], n, x1, x2;  
+		int current_sum, max_sum, fx1, fx2, fy1, fy2;  
+		int i,j,k;  
+		fx1 = fx2 = fy1 = fy2 = max_sum = current_sum = -1;  
+	
+		for ( i = 0; i < rows; i++ )  
+		{  	//zeroing out the information
+			for( k = 0 ; k < cols; k++ )
+			{  
+				temp[k] = 0;  
+			}
+			for ( j = i ; j < rows; j++ )  
+			{  
+				for( k = 0; k < cols ; k++ ){  
+					temp[k] += input[j][k];  
+				}
+				kadane( temp, cols, x1, x2, current_sum );  
+	
+				if ( current_sum > max_sum )  
+				{  
+					fy1 = x1;  
+					fy2 = x2;  
+					fx1 = i;  
+					fx2 = j;  
+					max_sum = current_sum;  
+				}  
+			}  
+		}  
+		std::cout << "max Sum = " << max_sum << " from (" << fx1 << "," << fy1 << ") to ("  
+			      << fx2 << "," << fy2 << ")" << std::endl;  
+	}  
+}
+
+// ===================================
+// Main method to run max_sum instance 
+// ===================================
+int main ( int argc, char ** argv )
+{
+	//        X  Y
+	int setX [3][3] =
+	{
+	  { 1, 5, 7 },
+	  { 4, 9, 2 },
+      { 2, 3, 2 }
+	};	
+
+    betacore::find_max_sum(setX); 
+    //std::cout << "Press Any Key to quit" << std::endl;
+    //std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );
+		
+	int gg[9][9] = {
+		            {0, 4, 0, 0, 0, 0, 0, 8, 0},
+					{4, 0, 8, 0, 0, 0, 0, 11, 0},
+					{0, 8, 0, 7, 0, 4, 0, 0, 2},
+					{0, 0, 7, 0, 9, 14, 0, 0, 0},
+					{0, 0, 0, 9, 0, 10, 0, 0, 0},
+					{0, 0, 4, 0, 10, 0, 2, 0, 0},
+					{0, 0, 0, 14, 0, 2, 0, 1, 6},
+					{8, 11, 0, 0, 0, 0, 1, 0, 7},
+					{0, 0, 2, 0, 0, 0, 6, 7, 0}
+					};
+	betacore::find_max_sum(gg);
+    //std::cin.get();
+	return 0;
+}//main
diff --git a/code/train/C++/0065657_main.cpp b/code/train/C++/0065657_main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9f7d394e04d9ce17682a24c307698cf3de486d31
--- /dev/null
+++ b/code/train/C++/0065657_main.cpp
@@ -0,0 +1,48 @@
+#include <iostream>
+#include <vector>
+#include <iterator>
+#include <algorithm>
+
+//
+// Calculate the maximum trading profit possible given a price history.
+//
+uint64_t maxProfit(const std::vector<uint32_t>& prices) {
+  // No profit possible with less than 2 trading days...
+  if (prices.size() < 2) {
+    return 0;
+  }
+  uint64_t profit = 0;
+  // Highest price in first i + 1 prices...
+  uint32_t high = prices[prices.size() - 1];
+  // Go through prices in reverse...
+  for (int i = prices.size() - 2; i >= 0; i--) {
+    if (prices[i] > high) {
+      high = prices[i];
+    }
+    // The potential profit from a purchase today...
+    profit += high - prices[i];
+  }
+  return profit;
+}
+
+//
+// Read N stock prices into a vector of size N.
+//
+std::vector<uint32_t> loadPrices(std::istream& in, size_t N) { // NOLINT
+  std::vector<uint32_t> prices;
+  std::copy_n(std::istream_iterator<uint32_t>(std::cin),
+              N,
+              std::back_inserter(prices));
+  return prices;
+}
+
+int main() {
+  size_t T, N;
+  std::cin >> T;
+  while (T--) {
+    std::cin >> N;
+    std::vector<uint32_t> prices = loadPrices(std::cin, N);
+    std::cout << maxProfit(prices) << std::endl;
+  }
+  return 0;
+}
diff --git a/code/train/C++/0065785_test_Compare.cpp b/code/train/C++/0065785_test_Compare.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e37e546be8513b1cc7438810a01641859a4bad18
--- /dev/null
+++ b/code/train/C++/0065785_test_Compare.cpp
@@ -0,0 +1,158 @@
+/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
+
+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 <paddle/legacy/utils/PythonUtil.h>
+
+#include "paddle/legacy/trainer/Trainer.h"
+
+#include <gtest/gtest.h>
+#include <cstdlib>
+
+using namespace paddle;  // NOLINT
+using namespace std;     // NOLINT
+
+static const string& configFile =
+    "legacy/trainer/tests/sample_trainer_config.conf";
+
+DECLARE_int32(gpu_id);
+DECLARE_bool(use_gpu);
+DECLARE_string(config);
+DECLARE_string(config_args);
+
+struct comData {
+  vector<Argument> outArgs;
+  vector<ParameterPtr> parameters;
+};
+
+void calcGradient(bool useGpu, comData& Data) {
+  FLAGS_use_gpu = useGpu;
+  FLAGS_config = configFile;
+
+  *ThreadLocalRand::getSeed() = 0;
+  srand(0);
+  Trainer trainer;
+  trainer.init(TrainerConfigHelper::createFromFlagConfig());
+
+  Data.parameters = trainer.getGradientMachine()->getParameters();
+  DataBatch dataBatch;
+  int32_t batchSize = trainer.getConfig().opt_config().batch_size();
+  trainer.getDataProvider()->setSkipShuffle();
+  trainer.getDataProvider()->getNextBatch(batchSize, &dataBatch);
+  CHECK(dataBatch.getSize()) << "No data from data provider";
+  vector<Argument>& inArgs = dataBatch.getStreams();
+  trainer.getGradientMachine()->start();
+  for (int i = 0; i < 2; ++i) {
+    trainer.getGradientMachine()->forwardBackward(
+        inArgs, &Data.outArgs, PASS_TRAIN);
+  }
+  trainer.getGradientMachine()->finish();
+}
+
+void compareGradient(comData& comDataCpu, comData& comDataGpu);
+
+TEST(Trainer, create) {
+  int devCount = 0;
+  devCount = hl_get_device_count();
+  FLAGS_config_args = "drop_rate=0";
+
+  comData comDataCpu;
+  calcGradient(false, comDataCpu);
+  LOG(INFO) << "Cpu is completed";
+
+  {
+    LOG(INFO) << "Test GPU";
+    comData comData;
+    calcGradient(true, comData);
+    compareGradient(comDataCpu, comData);
+    LOG(INFO) << "Gpu is completed";
+  }
+
+  {
+    LOG(INFO) << "Test test multi gpu";
+    comData comData;
+    FLAGS_trainer_count = devCount;
+    calcGradient(true, comData);
+    compareGradient(comDataCpu, comData);
+    LOG(INFO) << "Gpu4 is completed";
+  }
+
+  {
+    LOG(INFO) << "Test use_sparse_update=true";
+    comData comData;
+    calcGradient(false, comData);
+    compareGradient(comDataCpu, comData);
+    LOG(INFO) << "Cpu4 is completed";
+  }
+}
+
+double checkBuffer(real* A, real* B, size_t len) {
+#ifdef PADDLE_TYPE_DOUBLE
+  double precision = 1e-7;
+#else
+  double precision = 2e-3;
+#endif
+  int nNum = 0;
+  double maxE = 0;
+  for (size_t i = 0; i < len; ++i) {
+    double e = fabs(A[i] - B[i]);
+    maxE = std::max(e, maxE);
+    nNum += e > precision * fabs(A[i]);
+  }
+  EXPECT_EQ(0, nNum);
+  return maxE;
+}
+
+void compareGradient(comData& comDataCpu, comData& comDataGpu) {
+  /*compare outArgs*/
+  vector<Argument> outArgs1 = comDataCpu.outArgs;
+  vector<Argument> outArgs2 = comDataGpu.outArgs;
+  CpuMatrix out1(outArgs1[0].value->getHeight(), outArgs1[0].value->getWidth());
+  CpuMatrix out2(outArgs2[0].value->getHeight(), outArgs2[0].value->getWidth());
+  out1.copyFrom(*outArgs1[0].value);
+  out2.copyFrom(*outArgs2[0].value);
+  checkBuffer(out1.getData(), out2.getData(), out1.getElementCnt());
+
+  /*compare parameters*/
+  vector<ParameterPtr>& parameters1 = comDataCpu.parameters;
+  vector<ParameterPtr>& parameters2 = comDataGpu.parameters;
+  for (size_t i = 0; i < parameters1.size(); ++i) {
+    ParameterPtr parameter1, parameter2;
+    parameter1 = parameters1[i];
+    parameter2 = parameters2[i];
+    /*compare parameters value*/
+    CpuVector para1(parameter1->getSize());
+    CpuVector para2(parameter2->getSize());
+    para1.copyFrom(*parameter1->getBuf(PARAMETER_VALUE));
+    para2.copyFrom(*parameter2->getBuf(PARAMETER_VALUE));
+    checkBuffer(para1.getData(), para2.getData(), para1.getSize());
+
+    /*compare parameters grad*/
+    CpuVector cpuGrad1(*parameter1->getBuf(PARAMETER_GRADIENT));
+    CpuVector cpuGrad2(*parameter2->getBuf(PARAMETER_GRADIENT));
+    double e =
+        checkBuffer(cpuGrad1.getData(), cpuGrad2.getData(), cpuGrad1.getSize());
+    LOG(INFO) << parameter1->getName() << " max error=" << e;
+  }
+}
+
+int main(int argc, char** argv) {
+#ifndef PADDLE_WITH_CUDA
+  exit(0);
+#endif
+  paddle::initMain(argc, argv);
+  testing::InitGoogleTest(&argc, argv);
+  initPython(argc, argv);
+  int ret = RUN_ALL_TESTS();
+  exit(ret);
+}
diff --git a/code/train/C++/0065811_string_functions.cc b/code/train/C++/0065811_string_functions.cc
new file mode 100644
index 0000000000000000000000000000000000000000..312b806ba180ad34439262f675b0cc9389ef97c3
--- /dev/null
+++ b/code/train/C++/0065811_string_functions.cc
@@ -0,0 +1,207 @@
+/* string_functions.cc
+   Jeremy Barnes, 7 February 2005
+   Copyright (c) 2005 Jeremy Barnes.  All rights reserved.
+   
+   This file is part of "Jeremy's Machine Learning Library", copyright (c)
+   1999-2005 Jeremy Barnes.
+   
+   This program is available under the GNU General Public License, the terms
+   of which are given by the file "license.txt" in the top level directory of
+   the source code distribution.  If this file is missing, you have no right
+   to use the program; please contact the author.
+
+   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.
+
+   ---
+   
+   String manipulation functions.
+*/
+
+#include "string_functions.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include "jml/arch/exception.h"
+#include <sys/errno.h>
+#include <stdlib.h>
+
+using namespace std;
+
+
+namespace ML {
+
+struct va_ender {
+    va_ender(va_list & ap)
+        : ap(ap)
+    {
+    }
+
+    ~va_ender()
+    {
+        va_end(ap);
+    }
+
+    va_list & ap;
+};
+
+std::string format(const char * fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+    try {
+        string result = vformat(fmt, ap);
+        va_end(ap);
+        return result;
+    }
+    catch (...) {
+        va_end(ap);
+        throw;
+    }
+}
+
+std::string vformat(const char * fmt, va_list ap)
+{
+    char * mem;
+    string result;
+    int res = vasprintf(&mem, fmt, ap);
+    if (res < 0)
+        throw Exception(errno, "vasprintf", "format()");
+
+    try {
+        result = mem;
+        free(mem);
+        return result;
+    }
+    catch (...) {
+        free(mem);
+        throw;
+    }
+}
+
+std::vector<std::string> split(const std::string & str, char c)
+{
+    vector<string> result;
+    size_t start = 0;
+    size_t pos = 0;
+    while (pos < str.size()) {
+        if (str[pos] == c) {
+            result.push_back(string(str, start, pos - start));
+            start = pos + 1;
+        }
+        ++pos;
+    }
+
+    if (start < str.size())
+        result.push_back(string(str, start, pos - start));
+
+    return result;
+}
+
+std::string lowercase(const std::string & str)
+{
+    string result = str;
+    for (unsigned i = 0;  i < str.size();  ++i)
+        result[i] = tolower(result[i]);
+    return result;
+}
+
+std::string remove_trailing_whitespace(const std::string & str)
+{
+    int startOfSpace = -1;
+    for (unsigned i = 0;  i < str.length();  ++i) {
+        if (isspace(str[i])) {
+            if (startOfSpace == -1) startOfSpace = i;
+        }
+        else startOfSpace = -1;
+    }
+
+    if (startOfSpace == -1) return str;
+    return string(str, 0, startOfSpace);
+}
+
+bool removeIfEndsWith(std::string & str, const std::string & ending)
+{
+    if (str.rfind(ending) == str.size() - ending.length()) {
+        str = string(str, 0, str.size() - ending.length());
+        return true;
+    }
+    
+    return false;
+}
+
+bool endsWith(const std::string & haystack, const std::string & needle)
+{
+    string::size_type result = haystack.rfind(needle);
+    return result != string::npos
+        && result == haystack.size() - needle.size();
+}
+
+std::string hexify_string(const std::string & str)
+{
+    size_t i, len(str.size());
+    std::string newString;
+    newString.reserve(len * 3);
+
+    for (i = 0; i < len; i++) {
+        if (str[i] < 32 || str[i] > 127) {
+            newString += format("\\x%.2x", int(str[i] & 0xff));
+        }
+        else {
+            newString += str[i];
+        }
+    }
+
+    return newString;
+}
+
+int
+antoi(const char * start, const char * end, int base)
+{
+    int result(0);
+    bool neg = false;
+    if (*start == '-') {
+        if (base == 10) {
+            neg = true;
+        }
+        else {
+            throw ML::Exception("Cannot negate non base 10");
+        }
+        start++;
+    }
+    else if (*start == '+') {
+        start++;
+    }
+
+    for (const char * ptr = start; ptr < end; ptr++) {
+        int digit;
+        if (*ptr >= '0' and *ptr <= '9') {
+            digit = *ptr - '0';
+        }
+        else if (*ptr >= 'A' and *ptr <= 'F') {
+            digit = *ptr - 'A' + 10;
+        }
+        else if (*ptr >= 'a' and *ptr <= 'f') {
+            digit = *ptr - 'a' + 10;
+        }
+        else {
+            throw ML::Exception("expected digit");
+        }
+        if (digit > base) {
+            intptr_t offset = ptr - start;
+            throw ML::Exception("digit '%c' (%d) exceeds base '%d'"
+                                " at offset '%d'",
+                                *ptr, digit, base, offset);
+        }
+        result = result * base + digit;
+    }
+
+    if (neg) {
+        return result * -1;
+    }
+
+    return result;
+}
+
+} // namespace ML
diff --git a/code/train/C++/0066210_38.cc b/code/train/C++/0066210_38.cc
new file mode 100644
index 0000000000000000000000000000000000000000..dd66c283254f842c82092ededa02bd2f77354d09
--- /dev/null
+++ b/code/train/C++/0066210_38.cc
@@ -0,0 +1,61 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <set>
+#include <string>
+#include <algorithm>
+
+using namespace std;
+
+int max( int a, int b ) {
+  if ( a > b ) {
+    return a;
+  }
+  return b;
+}
+
+int concat( int a, int b ) {
+  char lenB;
+  int ten;
+
+  lenB = floor( log10( b ) ) + 1;
+  ten = 1;
+  while ( lenB-- ) {
+    ten *= 10;
+  }
+  return a * ten + b;
+}
+
+int main() {
+  char len;
+  int ans, maxAns, i, j;
+  string s;
+  set< int > pandigitals;
+
+  s = "123456789";
+  do {
+    pandigitals.insert( atoi( s.c_str() ) );
+  } while ( next_permutation( s.begin(), s.end() ) );
+
+  maxAns = 0;
+  for ( i = 1; i <= 9999; ++i ) {
+    ans = i;
+    for ( j = 2; ; ++j ) {
+      ans = concat( ans, i * j );
+      len = floor( log10( ans ) ) + 1;
+
+      if ( len == 9 ) {
+        if ( pandigitals.find( ans ) != pandigitals.end() ) {
+          maxAns = max( maxAns, ans );
+        }
+      }
+      else if ( len > 9 ) {
+        break;
+      }
+    }
+  }
+
+  printf( "%d\n", maxAns );
+
+  return 0;
+}
diff --git a/code/train/C++/0066256_fuente.cpp b/code/train/C++/0066256_fuente.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c5453fe74e21c469971dfad9cfa32d43e0446475
--- /dev/null
+++ b/code/train/C++/0066256_fuente.cpp
@@ -0,0 +1,203 @@
+#include <string.h>
+#include <SDL/SDL_image.h>
+#include "Fuente.h"
+
+/*!
+ * \brief Carga una grilla con las fuentes
+ * \author Hugo Ruscitti
+ */
+Fuente :: Fuente (char *ruta, bool alpha)
+{
+	Uint32 colorkey;
+	char tmp_ruta[1024] = "images/";
+
+	strcat(tmp_ruta, ruta);
+	printf("+ Cargando fuente: %s\n", ruta);
+
+	ima = IMG_Load(tmp_ruta);
+
+	if (ima == NULL)
+	{
+		printf("Error: %s\n", SDL_GetError());
+		exit(1);
+	}
+
+	if (!alpha)
+	{
+		SDL_Surface *tmp = ima;
+
+		ima = SDL_DisplayFormat(tmp);
+		SDL_FreeSurface(tmp);
+
+		if (ima == NULL)
+		{
+			printf("Error: %s\n", SDL_GetError());
+			exit(1);
+		}
+
+		colorkey = SDL_MapRGB(ima->format, 255, 0, 255);
+		SDL_SetColorKey(ima, SDL_SRCCOLORKEY, colorkey);
+	}
+
+	buscar_posiciones();
+}
+
+/*!
+ * \brief Destructor del objeto
+ * \author Hugo Ruscitti
+ */
+Fuente :: ~Fuente ()
+{
+	SDL_FreeSurface(ima);
+	printf("- Descargando fuente.\n");
+}
+
+
+/*!
+ * \brief Imprime una cadena de texto sobre dst
+ * \author Hugo Ruscitti
+ */
+void Fuente :: imprimir (SDL_Surface *dst, char *texto, int x, int y)
+{
+	int i;
+	int aux = 0;
+
+	for (i = 0; texto[i] != '\0'; i ++)
+	{
+		aux = imprimir(dst, texto[i], x, y);
+		x = x + aux + 2; // o 1 si el modo es 320x240
+	}
+}
+
+
+/*!
+ * \brief Imprime un caracter sobre dst.
+ * \return el ancho (en pixeles) del caracter impreso.
+ *
+ * \author Hugo Ruscitti
+ */
+int Fuente :: imprimir (SDL_Surface *dst, char letra, int x, int y)
+{
+	int i;
+	bool encuentra = false;
+	SDL_Rect dstrect;
+
+	if (letra == ' ')
+	{
+		x += 16; // o 8 si el modo es 320x240
+		return 16; // o 8 si el modo es 320x240
+	}
+
+	// busca el indice del caracter
+	for (i = 0; cadena[i] != '\0'; i++)
+	{
+		if (cadena[i] == letra)
+		{
+			encuentra = true;
+			break;
+		}
+	}
+
+	if (! encuentra)
+	{
+		printf("No se encuentra el caracter '%c'\n", letra);
+		return 0;
+	}
+
+	dstrect.x = x;
+	dstrect.y = y;
+	dstrect.w = rect_letras[i].w;
+	dstrect.h = rect_letras[i].h;
+
+	SDL_BlitSurface(ima, &rect_letras[i], dst, &dstrect);
+
+	return rect_letras[i].w;
+}
+
+
+/*!
+ * \brief Determina la posición de cada letra dentro de la grilla
+ * \author Hugo Ruscitti
+ */
+void Fuente :: buscar_posiciones (void)
+{
+#define LEYENDO 0
+#define DIVISION 1
+	int indice = 0;
+	Uint32 color = 0;
+	Uint32 negro = SDL_MapRGB(ima->format, 0, 0, 0);
+	int estado = DIVISION;
+
+	strcpy(cadena, "abcdefghijklmnopqrstuvwxyz" \
+			"ABCDEFGHIJKLMNOPQRSYUVWXYZ" \
+			"1234567890" \
+			"ñÑáéíóúÁÉÍÓÚäëïöü" \
+			"!¡?¿@#$%&'+-=><*/,.:;-_()[]{}|^`~\\");
+
+	if (SDL_MUSTLOCK(ima))
+	{
+		if (SDL_LockSurface(ima) < 0)
+		{
+			printf("No se puede bloquear %s con %s\n", "ima", \
+					"SDL_LockSurface");
+			return;
+		}
+	}
+
+	indice = -1;
+
+	for (int x = 0; x < ima->w; x ++)
+	{
+		color = get_pixel (ima, x, 0);
+
+		if (estado == DIVISION && color == negro)
+		{
+			estado = LEYENDO;
+			indice ++;
+			rect_letras[indice].x = x;
+			rect_letras[indice].y = 2; // o 1 si el modo es 320x240
+			rect_letras[indice].h = ima->h - 2; // o 1 si ...etc.
+			rect_letras[indice].w = 0;
+		}
+
+		if (color == negro)
+			rect_letras[indice].w ++;
+		else
+			estado = DIVISION;
+	}
+
+	if (SDL_MUSTLOCK(ima))
+		SDL_UnlockSurface(ima);
+}
+
+
+/*!
+ * \brief Obtiene un píxel de la superficie (extraido de la doumentación de SDL)
+ * \author SDL Documentation
+ */
+Uint32 Fuente :: get_pixel(SDL_Surface *surface, int x, int y)
+{
+	int bpp = surface->format->BytesPerPixel;
+	Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
+
+	switch (bpp)
+	{
+		case 1:
+			return *p;
+
+		case 2:
+			return *(Uint16 *)p;
+
+		case 3:
+			if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
+				return p[0] << 16 | p[1] << 8 | p[2];
+			else
+				return p[0] | p[1] << 8 | p[2] << 16;
+
+		case 4:
+			return *(Uint32 *)p;
+
+		default:
+			return 0;
+	}
+}
diff --git a/code/train/C++/0067168_DisassemblyPopup.cpp b/code/train/C++/0067168_DisassemblyPopup.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d637ec87d79c266551cc4d1f241b82e1299fe2b6
--- /dev/null
+++ b/code/train/C++/0067168_DisassemblyPopup.cpp
@@ -0,0 +1,178 @@
+#include "DisassemblyPopup.h"
+#include "CachedFontMetrics.h"
+#include "Configuration.h"
+#include "StringUtil.h"
+#include "MiscUtil.h"
+#include <QPainter>
+
+DisassemblyPopup::DisassemblyPopup(QWidget* parent) :
+    QFrame(parent, Qt::Tool | Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint | Qt::WindowDoesNotAcceptFocus),
+    mFontMetrics(nullptr),
+    mDisasm(ConfigUint("Disassembler", "MaxModuleSize"))
+{
+    addr = 0;
+    addrText = nullptr;
+    connect(Config(), SIGNAL(fontsUpdated()), this, SLOT(updateFont()));
+    connect(Config(), SIGNAL(colorsUpdated()), this, SLOT(updateColors()));
+    connect(Config(), SIGNAL(tokenizerConfigUpdated()), this, SLOT(tokenizerConfigUpdated()));
+    updateFont();
+    updateColors();
+    setFrameStyle(QFrame::Panel);
+    setLineWidth(2);
+    mMaxInstructions = 20;
+}
+
+void DisassemblyPopup::updateColors()
+{
+    disassemblyBackgroundColor = ConfigColor("DisassemblyBackgroundColor");
+    disassemblyTracedColor = ConfigColor("DisassemblyTracedBackgroundColor");
+    labelColor = ConfigColor("DisassemblyLabelColor");
+    labelBackgroundColor = ConfigColor("DisassemblyLabelBackgroundColor");
+    commentColor = ConfigColor("DisassemblyCommentColor");
+    commentBackgroundColor = ConfigColor("DisassemblyCommentBackgroundColor");
+    commentAutoColor = ConfigColor("DisassemblyAutoCommentColor");
+    commentAutoBackgroundColor = ConfigColor("DisassemblyAutoCommentBackgroundColor");
+    QPalette palette;
+    palette.setColor(QPalette::Foreground, ConfigColor("AbstractTableViewSeparatorColor"));
+    setPalette(palette);
+}
+
+void DisassemblyPopup::tokenizerConfigUpdated()
+{
+    mDisasm.UpdateConfig();
+}
+
+void DisassemblyPopup::updateFont()
+{
+    delete mFontMetrics;
+    setFont(ConfigFont("Disassembly"));
+    QFontMetricsF metrics(font());
+    mFontMetrics = new CachedFontMetrics(this, font());
+    // Update font size, used in layout calculations.
+    charWidth = mFontMetrics->width('W');
+    charHeight = metrics.height();
+}
+
+void DisassemblyPopup::paintEvent(QPaintEvent* event)
+{
+    QRect viewportRect(0, 0, width(), height());
+    QPainter p(this);
+    p.setFont(font());
+
+    // Render background
+    p.fillRect(viewportRect, disassemblyBackgroundColor);
+    // Draw Address
+    p.setPen(QPen(labelColor));
+    int addrWidth = mFontMetrics->width(addrText);
+    p.fillRect(3, 2 + lineWidth(), addrWidth, charHeight, QBrush(labelBackgroundColor));
+    p.drawText(3, 2, addrWidth, charHeight, 0, addrText);
+    // Draw Comments
+    if(!addrComment.isEmpty())
+    {
+        int commentWidth = mFontMetrics->width(addrComment);
+        QBrush background = QBrush(addrCommentAuto ? commentAutoBackgroundColor : commentBackgroundColor);
+        p.setPen(addrCommentAuto ? commentAutoColor : commentColor);
+        p.fillRect(3 + addrWidth, 2, commentWidth, charHeight, background);
+        p.drawText(3 + addrWidth, 2, commentWidth, charHeight, 0, addrComment);
+    }
+    // Draw Instructions
+    int y = charHeight + 1;
+    for(auto & instruction : mDisassemblyToken)
+    {
+        if(instruction.second)
+            p.fillRect(QRect(3, y, mWidth - 3, charHeight), disassemblyTracedColor);
+        RichTextPainter::paintRichText(&p, 3, y, mWidth - 3, charHeight, 0, instruction.first, mFontMetrics);
+        y += charHeight;
+    }
+    QFrame::paintEvent(event);
+}
+
+void DisassemblyPopup::setAddress(duint Address)
+{
+    addr = Address;
+    QList<Instruction_t> instBuffer;
+    mDisassemblyToken.clear();
+    if(addr != 0)
+    {
+        mWidth = 1;
+        // Get RVA
+        auto addr = Address;
+        duint size;
+        duint base = DbgMemFindBaseAddr(addr, &size);
+        // Prepare RVA of every instruction
+        unsigned int i = 0;
+        instBuffer.clear();
+        auto nextAddr = addr;
+        bool hadBranch = false;
+        duint bestBranch = 0;
+        byte data[64];
+        do
+        {
+            if(nextAddr >= base + size)
+                break;
+            if(!DbgMemRead(nextAddr, data, sizeof(data)))
+                break;
+            auto instruction = mDisasm.DisassembleAt(data, sizeof(data), 0, nextAddr);
+            if(!instruction.length)
+                break;
+            instBuffer.append(std::move(instruction));
+            if(!hadBranch || bestBranch <= nextAddr)
+            {
+                if(instruction.instStr.contains("ret"))
+                    break;
+                if(instruction.instStr.contains("jmp") && instruction.instStr.contains("["))
+                    break;
+            }
+            if(instruction.branchDestination && !instruction.instStr.contains("call") && !instruction.instStr.contains("ret"))
+            {
+                hadBranch = true;
+                if(instruction.branchDestination > bestBranch)
+                    bestBranch = instruction.branchDestination;
+            }
+            auto nextAddr2 = nextAddr + instruction.length;
+            if(nextAddr2 == nextAddr)
+                break;
+            else
+                nextAddr = nextAddr2;
+            if(DbgGetFunctionTypeAt(nextAddr - 1) == FUNC_END)
+                break;
+            i++;
+        }
+        while(i < mMaxInstructions);
+        // Disassemble
+        for(auto & instruction : instBuffer)
+        {
+            RichTextPainter::List richText;
+            CapstoneTokenizer::TokenToRichText(instruction.tokens, richText, nullptr);
+            // Calculate width
+            int currentInstructionWidth = 0;
+            for(auto & token : richText)
+                currentInstructionWidth += mFontMetrics->width(token.text);
+            mWidth = std::max(mWidth, currentInstructionWidth);
+            mDisassemblyToken.push_back(std::make_pair(std::move(richText), DbgFunctions()->GetTraceRecordHitCount(instruction.rva) != 0));
+        }
+        // Address
+        addrText = getSymbolicName(addr);
+        // Comments
+        GetCommentFormat(addr, addrComment, &addrCommentAuto);
+        if(addrComment.length())
+            addrText.append(' ');
+        // Calculate width of address
+        mWidth = std::max(mWidth, mFontMetrics->width(addrText) + mFontMetrics->width(addrComment));
+        mWidth += charWidth * 6;
+        // Resize popup
+        resize(mWidth + 2, charHeight * int(mDisassemblyToken.size() + 1) + 2);
+    }
+    update();
+}
+
+duint DisassemblyPopup::getAddress()
+{
+    return addr;
+}
+
+void DisassemblyPopup::hide()
+{
+    addr = 0;
+    QFrame::hide();
+}
diff --git a/code/train/C++/0067295_Surname.cpp b/code/train/C++/0067295_Surname.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8d5600f6fdac535258c8ce037ccbe45387c6c0e7
--- /dev/null
+++ b/code/train/C++/0067295_Surname.cpp
@@ -0,0 +1,23 @@
+#include <iostream>
+#include <vector>
+#include <string>
+using namespace std;
+class Surname
+{
+	public:
+		int bestSurname(vector<string> surname)
+		{
+			int l_score = 0;
+			int m_score = 0;
+			int m_index = -1;
+			for (unsigned i = 0; i < surname.size(); i++) {
+				string s = surname.at(i);
+				l_score = 0;
+				for (unsigned j = 0; j < s.length(); j++) 
+					l_score += s.at(j);
+				if (l_score > m_score)
+					m_score = l_score, m_index = i;
+			}
+			return m_index;
+		}
+};
diff --git a/code/train/C++/0067977_shortcuts_backend_unittest.cc b/code/train/C++/0067977_shortcuts_backend_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..dbc4e833aceba4e4fe3f3dcb502284815069ff6d
--- /dev/null
+++ b/code/train/C++/0067977_shortcuts_backend_unittest.cc
@@ -0,0 +1,175 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/files/scoped_temp_dir.h"
+#include "base/message_loop.h"
+#include "base/path_service.h"
+#include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/time.h"
+#include "chrome/browser/history/shortcuts_backend.h"
+#include "chrome/browser/history/shortcuts_backend_factory.h"
+#include "chrome/browser/history/shortcuts_database.h"
+#include "chrome/test/base/testing_profile.h"
+#include "content/public/test/test_browser_thread.h"
+#include "sql/statement.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+using content::BrowserThread;
+
+namespace history {
+
+const base::TimeDelta kMaxRequestWaitTimeout = base::TimeDelta::FromSeconds(1);
+
+class ShortcutsBackendTest : public testing::Test,
+                             public ShortcutsBackend::ShortcutsBackendObserver {
+ public:
+  ShortcutsBackendTest()
+      : ui_thread_(BrowserThread::UI, &ui_message_loop_),
+        db_thread_(BrowserThread::DB),
+        load_notified_(false),
+        changed_notified_(false) {}
+
+  virtual void SetUp();
+  virtual void TearDown();
+
+  virtual void OnShortcutsLoaded() OVERRIDE;
+  virtual void OnShortcutsChanged() OVERRIDE;
+
+  void InitBackend();
+
+  TestingProfile profile_;
+  scoped_refptr<ShortcutsBackend> backend_;
+  base::MessageLoopForUI ui_message_loop_;
+  content::TestBrowserThread ui_thread_;
+  content::TestBrowserThread db_thread_;
+
+  bool load_notified_;
+  bool changed_notified_;
+};
+
+void ShortcutsBackendTest::SetUp() {
+  db_thread_.Start();
+  ShortcutsBackendFactory::GetInstance()->SetTestingFactoryAndUse(
+      &profile_, &ShortcutsBackendFactory::BuildProfileForTesting);
+  backend_ = ShortcutsBackendFactory::GetForProfile(&profile_);
+  ASSERT_TRUE(backend_.get());
+  backend_->AddObserver(this);
+}
+
+void ShortcutsBackendTest::TearDown() {
+  backend_->RemoveObserver(this);
+  db_thread_.Stop();
+}
+
+void ShortcutsBackendTest::OnShortcutsLoaded() {
+  load_notified_ = true;
+  base::MessageLoop::current()->Quit();
+}
+
+void ShortcutsBackendTest::OnShortcutsChanged() {
+  changed_notified_ = true;
+}
+
+void ShortcutsBackendTest::InitBackend() {
+  ShortcutsBackend* backend =
+      ShortcutsBackendFactory::GetForProfile(&profile_).get();
+  ASSERT_TRUE(backend);
+  ASSERT_FALSE(load_notified_);
+  ASSERT_FALSE(backend_->initialized());
+  base::MessageLoop::current()->Run();
+  EXPECT_TRUE(load_notified_);
+  EXPECT_TRUE(backend_->initialized());
+}
+
+TEST_F(ShortcutsBackendTest, AddAndUpdateShortcut) {
+  InitBackend();
+  EXPECT_FALSE(changed_notified_);
+  ShortcutsBackend::Shortcut shortcut("BD85DBA2-8C29-49F9-84AE-48E1E90880DF",
+      ASCIIToUTF16("goog"), GURL("http://www.google.com"),
+      ASCIIToUTF16("Google"),
+      AutocompleteMatch::ClassificationsFromString("0,1"),
+      ASCIIToUTF16("Google"),
+      AutocompleteMatch::ClassificationsFromString("0,1"), base::Time::Now(),
+      100);
+  EXPECT_TRUE(backend_->AddShortcut(shortcut));
+  EXPECT_TRUE(changed_notified_);
+  changed_notified_ = false;
+
+  const ShortcutsBackend::ShortcutMap& shortcuts = backend_->shortcuts_map();
+  ASSERT_TRUE(shortcuts.end() != shortcuts.find(shortcut.text));
+  EXPECT_EQ(shortcut.id, shortcuts.find(shortcut.text)->second.id);
+  EXPECT_EQ(shortcut.contents, shortcuts.find(shortcut.text)->second.contents);
+  shortcut.contents = ASCIIToUTF16("Google Web Search");
+  EXPECT_TRUE(backend_->UpdateShortcut(shortcut));
+  EXPECT_TRUE(changed_notified_);
+  EXPECT_EQ(shortcut.id, shortcuts.find(shortcut.text)->second.id);
+  EXPECT_EQ(shortcut.contents, shortcuts.find(shortcut.text)->second.contents);
+}
+
+TEST_F(ShortcutsBackendTest, DeleteShortcuts) {
+  InitBackend();
+  ShortcutsBackend::Shortcut shortcut1("BD85DBA2-8C29-49F9-84AE-48E1E90880DF",
+      ASCIIToUTF16("goog"), GURL("http://www.google.com"),
+      ASCIIToUTF16("Google"),
+      AutocompleteMatch::ClassificationsFromString("0,1,4,0"),
+      ASCIIToUTF16("Google"),
+      AutocompleteMatch::ClassificationsFromString("0,3,4,1"),
+      base::Time::Now(), 100);
+  EXPECT_TRUE(backend_->AddShortcut(shortcut1));
+
+  ShortcutsBackend::Shortcut shortcut2("BD85DBA2-8C29-49F9-84AE-48E1E90880E0",
+      ASCIIToUTF16("gle"), GURL("http://www.google.com"),
+      ASCIIToUTF16("Google"),
+      AutocompleteMatch::ClassificationsFromString("0,1"),
+      ASCIIToUTF16("Google"),
+      AutocompleteMatch::ClassificationsFromString("0,1"), base::Time::Now(),
+      100);
+  EXPECT_TRUE(backend_->AddShortcut(shortcut2));
+
+  ShortcutsBackend::Shortcut shortcut3("BD85DBA2-8C29-49F9-84AE-48E1E90880E1",
+      ASCIIToUTF16("sp"), GURL("http://www.sport.com"), ASCIIToUTF16("Sports"),
+      AutocompleteMatch::ClassificationsFromString("0,1"),
+      ASCIIToUTF16("Sport news"),
+      AutocompleteMatch::ClassificationsFromString("0,1"), base::Time::Now(),
+      10);
+  EXPECT_TRUE(backend_->AddShortcut(shortcut3));
+
+  ShortcutsBackend::Shortcut shortcut4("BD85DBA2-8C29-49F9-84AE-48E1E90880E2",
+      ASCIIToUTF16("mov"), GURL("http://www.film.com"), ASCIIToUTF16("Movies"),
+      AutocompleteMatch::ClassificationsFromString("0,1"),
+      ASCIIToUTF16("Movie news"),
+      AutocompleteMatch::ClassificationsFromString("0,1"), base::Time::Now(),
+      10);
+  EXPECT_TRUE(backend_->AddShortcut(shortcut4));
+
+  const ShortcutsBackend::ShortcutMap& shortcuts = backend_->shortcuts_map();
+
+  ASSERT_EQ(4U, shortcuts.size());
+  EXPECT_EQ(shortcut1.id, shortcuts.find(shortcut1.text)->second.id);
+  EXPECT_EQ(shortcut2.id, shortcuts.find(shortcut2.text)->second.id);
+  EXPECT_EQ(shortcut3.id, shortcuts.find(shortcut3.text)->second.id);
+  EXPECT_EQ(shortcut4.id, shortcuts.find(shortcut4.text)->second.id);
+
+  EXPECT_TRUE(backend_->DeleteShortcutsWithUrl(shortcut1.url));
+
+  ASSERT_EQ(2U, shortcuts.size());
+  EXPECT_TRUE(shortcuts.end() == shortcuts.find(shortcut1.text));
+  EXPECT_TRUE(shortcuts.end() == shortcuts.find(shortcut2.text));
+  ASSERT_TRUE(shortcuts.end() != shortcuts.find(shortcut3.text));
+  ASSERT_TRUE(shortcuts.end() != shortcuts.find(shortcut4.text));
+  EXPECT_EQ(shortcut3.id, shortcuts.find(shortcut3.text)->second.id);
+  EXPECT_EQ(shortcut4.id, shortcuts.find(shortcut4.text)->second.id);
+
+  std::vector<std::string> deleted_ids;
+  deleted_ids.push_back(shortcut3.id);
+  deleted_ids.push_back(shortcut4.id);
+
+  EXPECT_TRUE(backend_->DeleteShortcutsWithIds(deleted_ids));
+
+  ASSERT_EQ(0U, shortcuts.size());
+}
+
+}  // namespace history
diff --git a/code/train/C++/0068467_notification_ui_manager_impl.cc b/code/train/C++/0068467_notification_ui_manager_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..324530f2e2a16c965d78d7532948327f16c718ae
--- /dev/null
+++ b/code/train/C++/0068467_notification_ui_manager_impl.cc
@@ -0,0 +1,206 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/notifications/notification_ui_manager_impl.h"
+
+#include "base/logging.h"
+#include "base/prefs/pref_service.h"
+#include "base/memory/linked_ptr.h"
+#include "base/stl_util.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/fullscreen.h"
+#include "chrome/browser/idle.h"
+#include "chrome/browser/notifications/balloon_collection.h"
+#include "chrome/browser/notifications/notification.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/pref_names.h"
+#include "content/public/browser/notification_service.h"
+
+namespace {
+const int kUserStatePollingIntervalSeconds = 1;
+}
+
+// A class which represents a notification waiting to be shown.
+class QueuedNotification {
+ public:
+  QueuedNotification(const Notification& notification, Profile* profile)
+      : notification_(notification),
+        profile_(profile) {
+  }
+
+  const Notification& notification() const { return notification_; }
+  Profile* profile() const { return profile_; }
+
+  void Replace(const Notification& new_notification) {
+    notification_ = new_notification;
+  }
+
+ private:
+  // The notification to be shown.
+  Notification notification_;
+
+  // Non owned pointer to the user's profile.
+  Profile* profile_;
+
+  DISALLOW_COPY_AND_ASSIGN(QueuedNotification);
+};
+
+NotificationUIManagerImpl::NotificationUIManagerImpl()
+    : is_user_active_(true) {
+  registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
+                 content::NotificationService::AllSources());
+}
+
+NotificationUIManagerImpl::~NotificationUIManagerImpl() {
+}
+
+void NotificationUIManagerImpl::Add(const Notification& notification,
+                                    Profile* profile) {
+  if (TryReplacement(notification, profile)) {
+    return;
+  }
+
+  VLOG(1) << "Added notification. URL: "
+          << notification.content_url().spec();
+  show_queue_.push_back(linked_ptr<QueuedNotification>(
+      new QueuedNotification(notification, profile)));
+  CheckAndShowNotifications();
+}
+
+bool NotificationUIManagerImpl::DoesIdExist(const std::string& id) {
+  for (NotificationDeque::iterator iter = show_queue_.begin();
+       iter != show_queue_.end(); ++iter) {
+    if ((*iter)->notification().notification_id() == id)
+      return true;
+  }
+  return false;
+}
+
+bool NotificationUIManagerImpl::CancelById(const std::string& id) {
+  // See if this ID hasn't been shown yet.
+  for (NotificationDeque::iterator iter = show_queue_.begin();
+       iter != show_queue_.end(); ++iter) {
+    if ((*iter)->notification().notification_id() == id) {
+      show_queue_.erase(iter);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool NotificationUIManagerImpl::CancelAllBySourceOrigin(const GURL& source) {
+  // Same pattern as CancelById, but more complicated than the above
+  // because there may be multiple notifications from the same source.
+  bool removed = false;
+  for (NotificationDeque::iterator loopiter = show_queue_.begin();
+       loopiter != show_queue_.end(); ) {
+    NotificationDeque::iterator curiter = loopiter++;
+    if ((*curiter)->notification().origin_url() == source) {
+      show_queue_.erase(curiter);
+      removed = true;
+    }
+  }
+  return removed;
+}
+
+bool NotificationUIManagerImpl::CancelAllByProfile(Profile* profile) {
+  // Same pattern as CancelAllBySourceOrigin.
+  bool removed = false;
+  for (NotificationDeque::iterator loopiter = show_queue_.begin();
+       loopiter != show_queue_.end(); ) {
+    NotificationDeque::iterator curiter = loopiter++;
+    if ((*curiter)->profile() == profile) {
+      show_queue_.erase(curiter);
+      removed = true;
+    }
+  }
+  return removed;
+}
+
+void NotificationUIManagerImpl::CancelAll() {
+}
+
+void NotificationUIManagerImpl::CheckAndShowNotifications() {
+  CheckUserState();
+  if (is_user_active_)
+    ShowNotifications();
+}
+
+void NotificationUIManagerImpl::CheckUserState() {
+  bool is_user_active_previously = is_user_active_;
+  is_user_active_ = !CheckIdleStateIsLocked() && !IsFullScreenMode();
+  if (is_user_active_ == is_user_active_previously)
+    return;
+
+  if (is_user_active_) {
+    user_state_check_timer_.Stop();
+    // We need to show any postponed nofications when the user becomes active
+    // again.
+    ShowNotifications();
+  } else if (!user_state_check_timer_.IsRunning()) {
+    // Start a timer to detect the moment at which the user becomes active.
+    user_state_check_timer_.Start(FROM_HERE,
+        base::TimeDelta::FromSeconds(kUserStatePollingIntervalSeconds), this,
+        &NotificationUIManagerImpl::CheckUserState);
+  }
+}
+
+// Attempts to show each notification, leaving any failures in the queue.
+// TODO(dewittj): Eliminate recursion when BallonCollection is used to render
+// the Notification UI surfaces.
+void NotificationUIManagerImpl::ShowNotifications() {
+  while (!show_queue_.empty()) {
+    linked_ptr<QueuedNotification> queued_notification(show_queue_.front());
+    show_queue_.pop_front();
+    if (!ShowNotification(queued_notification->notification(),
+                          queued_notification->profile())) {
+      // Subclass could not show notification, put it back in the queue.
+      show_queue_.push_front(queued_notification);
+      return;
+    }
+  }
+}
+
+bool NotificationUIManagerImpl::TryReplacement(
+    const Notification& notification, Profile* profile) {
+  const GURL& origin = notification.origin_url();
+  const string16& replace_id = notification.replace_id();
+
+  if (replace_id.empty())
+    return false;
+
+  // First check the queue of pending notifications for replacement.
+  // Then check the list of notifications already being shown.
+  for (NotificationDeque::const_iterator iter = show_queue_.begin();
+       iter != show_queue_.end(); ++iter) {
+    if (profile == (*iter)->profile() &&
+        origin == (*iter)->notification().origin_url() &&
+        replace_id == (*iter)->notification().replace_id()) {
+      (*iter)->Replace(notification);
+      return true;
+    }
+  }
+
+  // Give the subclass the opportunity to update existing notification.
+  return UpdateNotification(notification, profile);
+}
+
+void NotificationUIManagerImpl::GetQueuedNotificationsForTesting(
+    std::vector<const Notification*>* notifications) {
+  for (NotificationDeque::const_iterator iter = show_queue_.begin();
+       iter != show_queue_.end(); ++iter) {
+    notifications->push_back(&(*iter)->notification());
+  }
+}
+
+void NotificationUIManagerImpl::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  if (type == chrome::NOTIFICATION_APP_TERMINATING) {
+    CancelAll();
+  } else {
+    NOTREACHED();
+  }
+}
diff --git a/code/train/C++/0068484_16.cpp b/code/train/C++/0068484_16.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aaaa7018809f0f2070c79a9ed5ef49f3c85ca5bf
--- /dev/null
+++ b/code/train/C++/0068484_16.cpp
@@ -0,0 +1,44 @@
+/*
+*
+*    author:	nillhex
+*    website:	nillhex.com
+*    E-mail:	nillhex[AT]gmail.com
+*
+*/
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    int threeSumClosest(vector<int> &num, int target) {
+        sort(num.begin(),num.end());
+        int res_sum = 0;
+        int res_gap = 99999;
+        for(int i=0; i<num.size()-2; i++)
+        {
+            int j = i+1;
+            int k = num.size() -1;
+            while(j!=k)
+            {
+                int sum = num[i]+num[j]+num[k];
+                int res_gap_new = abs(sum-target);
+                if(res_gap_new<res_gap)
+                {
+                    res_sum = sum;
+                    res_gap = res_gap_new;
+                }
+                if(sum<target) j++;
+                else if(sum>target) k--;
+                else return target;
+            }
+            
+        }
+        
+        return res_sum;
+    }
+};
\ No newline at end of file
diff --git a/code/train/C++/0068489_quick_sort.cpp b/code/train/C++/0068489_quick_sort.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2755150c1ef1268e2948e2db6c4bc04d7e80efcc
--- /dev/null
+++ b/code/train/C++/0068489_quick_sort.cpp
@@ -0,0 +1,87 @@
+/*
+ * quicksort.cpp
+ *
+ *  Created on: Jul 12, 2015
+ *      Author: zxliu
+ */
+
+
+#include "leetcode/leetcode_fwd.h"
+
+class Solution
+{
+public:
+    static const int CUTOFF = 3;
+
+    static void insertSort(int nums[], int left, int right)
+    {
+        for (int forward = 1; forward <= right; forward++)
+        {
+            int saved = nums[forward];
+            int backward = forward;
+            while(backward > left and nums[backward - 1] > nums[forward])
+            {
+                nums[backward] = nums[backward - 1];
+                backward--;
+            }
+        }
+    }
+
+    static int median(int nums[], int left, int right)
+    {
+        int med = (left + right) / 2;
+
+        if (nums[left] > nums[med])
+            std::swap(nums[left], nums[med]);
+
+        if (nums[left] > nums[right])
+            std::swap(nums[left], nums[right]);
+
+        if (nums[med] > nums[right])
+            std::swap(nums[med], nums[right]);
+
+        std::swap(nums[med], nums[right - 1]);
+        return nums[right - 1];
+    }
+
+    static void quickSort(int nums[], int left, int right)
+    {
+        int forward = left;
+        int backward = right - 1;
+
+        if (left + CUTOFF <= right)
+        {
+            int medNum = median(nums, left, right);
+
+            for ( ; ; )
+            {
+                while(nums[++forward] < medNum){};
+                while(nums[--backward] > medNum){};
+                if (forward < backward)
+                    std::swap(nums[forward], nums[backward]);
+                else
+                    break;
+            }
+            std::swap(nums[forward], nums[right - 1]);
+            quickSort(nums, left, forward - 1);
+            quickSort(nums, forward + 1, right);
+        }
+        else
+            insertSort(nums, left, right);
+    }
+
+};
+
+int main(int argc, char** argv)
+{
+    int nums[] = {5, 2, 4, 3, 3, 2, 6, 9, 8, 7};
+
+    int size = sizeof(nums)/ sizeof(int);
+    Solution::quickSort(nums, 0, size);
+
+    for(int i = 0; i < size; i++)
+        cout << nums[i] << ' ';
+    cout << endl;
+    return EXIT_SUCCESS;
+}
+
diff --git a/code/train/C++/0068822_rscompress.cc b/code/train/C++/0068822_rscompress.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1942e4febd991773fa3f129888e308c0806f1328
--- /dev/null
+++ b/code/train/C++/0068822_rscompress.cc
@@ -0,0 +1,200 @@
+/*
+ * libretroshare/src/utils: rscompress.cc
+ *
+ * Basic memory chunk compression, based on openpgp-sdk
+ *
+ * Copyright 2013 by Cyril Soler
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License Version 2 as published by the Free Software Foundation.
+ *
+ * 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA.
+ *
+ * Please report all bugs and problems to "csoler@users.sourceforge.net".
+ *
+ */
+
+#include <stdint.h>
+#include <algorithm>
+#include <iostream>
+#include <string.h>
+#include <assert.h>
+#include "rscompress.h"
+#include "zlib.h"
+#include "util/rsmemory.h"
+
+// 16K buffer size. 
+//
+static const unsigned int CHUNK = 16384u ;
+
+bool RsCompress::compress_memory_chunk(const uint8_t *input_mem,const uint32_t input_size,uint8_t *& output_mem,uint32_t& output_size) 
+{
+
+	uint32_t remaining_input = input_size ;
+	uint32_t output_offset = 0 ;
+	uint32_t input_offset = 0 ;
+	output_size = 1024 ;
+	output_mem = (uint8_t*)rs_malloc(output_size) ;
+    
+    	if(!output_mem)
+            return false ;
+
+	int ret, flush;
+	unsigned have;
+	int level = 9 ;
+	z_stream strm;
+	unsigned char in[CHUNK];
+	unsigned char out[CHUNK];
+	/* allocate deflate state */
+	strm.zalloc = Z_NULL;
+	strm.zfree = Z_NULL;
+	strm.opaque = Z_NULL;
+
+	ret = deflateInit(&strm, level);
+	if (ret != Z_OK)
+		return false;
+
+	/* compress until end of file */
+	do 
+	{
+		uint32_t available_in = std::min(CHUNK,remaining_input) ;
+		memcpy(in,input_mem+input_offset,available_in) ;
+		strm.avail_in = available_in ;
+		remaining_input -= available_in ;
+		input_offset += available_in ;
+
+		flush = /*feof(source)*/ remaining_input ? Z_NO_FLUSH: Z_FINISH ;
+		strm.next_in = in;
+
+		/* run deflate() on input until output buffer not full, finish
+			compression if all of source has been read in */
+		do 
+		{
+			strm.avail_out = CHUNK;
+			strm.next_out = out;
+			ret = deflate(&strm, flush);    /* no bad return value */
+			assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
+			have = CHUNK - strm.avail_out;
+
+			if(output_size < have+output_offset)
+			{
+				//std::cerr << "Growing outputbuffer from " << output_size << " to " << have+output_offset << std::endl;
+				output_mem = (uint8_t*)realloc(output_mem,have+output_offset) ;
+				output_size = have+output_offset ;
+			}
+			
+			memcpy(output_mem+output_offset,out,have) ;
+			output_offset += have ;
+			
+			//std::cerr << "Copying " << have << " bytes to output. New offset=" << output_offset << std::endl;
+		} while (strm.avail_out == 0);
+		assert(strm.avail_in == 0);     /* all input will be used */
+
+		/* done when last data in file processed */
+	} while (flush != Z_FINISH);
+	assert(ret == Z_STREAM_END);        /* stream will be complete */
+
+	/* clean up and return */
+	(void)deflateEnd(&strm);
+
+	output_size = output_offset ;
+
+	return true ;
+}
+
+bool RsCompress::uncompress_memory_chunk(const uint8_t *input_mem,const uint32_t input_size,uint8_t *& output_mem,uint32_t& output_size) 
+{
+	uint32_t remaining_input = input_size ;
+	output_size = input_size ;
+	uint32_t output_offset = 0 ;
+	uint32_t input_offset = 0 ;
+	output_mem = (uint8_t*)rs_malloc(output_size) ;
+
+	if(!output_mem)
+	    return false ;
+    
+	int ret;
+	unsigned have;
+	z_stream strm;
+	unsigned char in[CHUNK];
+	unsigned char out[CHUNK];
+
+	/* allocate inflate state */
+	memset(&strm,0,sizeof(strm)) ;
+	strm.zalloc = Z_NULL;
+	strm.zfree = Z_NULL;
+	strm.opaque = Z_NULL;
+	strm.next_in = Z_NULL;
+	strm.next_out = Z_NULL;
+
+	ret = inflateInit(&strm);
+	if (ret != Z_OK)
+		return ret;
+
+	/* decompress until deflate stream ends or end of file */
+	do 
+	{
+		uint32_t available_in = std::min(CHUNK,remaining_input) ;
+		memcpy(in,input_mem+input_offset,available_in) ;
+		strm.avail_in = available_in ;
+		remaining_input -= available_in ;
+		input_offset += available_in ;
+		
+		if (strm.avail_in == 0)
+			break;
+
+		strm.next_in = in;
+		/* run inflate() on input until output buffer not full */
+		do {
+			strm.avail_out = CHUNK;
+			strm.next_out = out;
+
+			ret = inflate(&strm, Z_NO_FLUSH);
+			assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
+			switch (ret) {
+				case Z_NEED_DICT:
+					ret = Z_DATA_ERROR;     /* and fall through */
+					/* fallthrough */
+				case Z_DATA_ERROR:
+				case Z_MEM_ERROR:
+					(void)inflateEnd(&strm);
+					return ret;
+			}
+
+
+			have = CHUNK - strm.avail_out;
+
+			if(output_size < have+output_offset)
+			{
+				output_mem = (uint8_t*)realloc(output_mem,have+output_offset) ;
+				output_size = have+output_offset ;
+			}
+			
+			memcpy(output_mem+output_offset,out,have) ;
+			output_offset += have ;
+
+		} while (strm.avail_out == 0);
+		/* done when inflate() says it's done */
+	} while (ret != Z_STREAM_END);
+
+	/* clean up and return */
+	(void)inflateEnd(&strm);
+
+	output_size = output_offset ;
+	return ret == Z_STREAM_END ;
+}
+
+
+
+
+
+
diff --git a/code/train/C++/0068853_ParseTools.cpp b/code/train/C++/0068853_ParseTools.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..25592be334be6e95f2c9aa4ee84aa0aaa9ed06cd
--- /dev/null
+++ b/code/train/C++/0068853_ParseTools.cpp
@@ -0,0 +1,140 @@
+#include "ParseTools.h"
+#include <climits>
+#include <cctype>
+#include <cstring>
+#include <cstdio>
+#include <cstdlib>
+#include <sstream>
+
+//This functions recognizes only numbers with digits, plus sign, minus sign, decimal point, e, or E. Hexadecimal and pointers not currently supported.
+bool isNumeric(const QuickString &str) {
+	for (int i=0; i < (int)str.size(); i++) {
+		char currChar = str[i];
+		if (!(isdigit(currChar) || currChar == '-' || currChar == '.' || currChar == '+' || currChar == 'e' || currChar == 'E')) {
+			return false;
+		}
+	}
+	return true;
+}
+
+int str2chrPos(const QuickString &str) {
+	return str2chrPos(str.c_str(), str.size());
+}
+
+int str2chrPos(const char *str, size_t ulen) {
+
+	if (ulen == 0) {
+		ulen = strlen(str);
+	}
+
+	//first test for exponents / scientific notation
+	bool hasExponent = false;
+	for (size_t i=0; i < ulen; i++) {
+		if (str[i] == 'e' || str[i] == 'E') {
+			std::istringstream ss(str);
+			double retVal;
+			ss >> retVal;
+			return (int)retVal;
+		}
+	}
+
+	int len=(int)ulen;
+	if (len < 1 || len > 10) {
+		fprintf(stderr, "***** ERROR: too many digits/characters for integer conversion in string %s. Exiting...\n", str);
+		exit(1);
+	}
+
+	register int sum=0;
+	int startPos =0;
+	bool isNegative = false;
+
+	//check for negative numbers
+	if (str[0] == '-') {
+		isNegative = true;
+		startPos = 1;
+	}
+
+	for (int i=startPos; i < len; i++) {
+		char currChar = str[i];
+		if (currChar == 'e' || currChar == 'E') {
+			//default to atoi for scientific notation
+			return atoi(str);
+		}
+		if (!isdigit(currChar)) {
+			fprintf(stderr, "***** ERROR: illegal character '%c' found in integer conversion of string \"%s\". Exiting...\n", currChar, str);
+			exit(1);
+		}
+
+		int dig = currChar - 48; //ascii code for zero.
+		int power = len -i -1;
+
+		switch (power) {
+		case 0:
+			sum += dig;
+			break;
+		case 1:
+			sum += dig * 10;
+			break;
+		case 2:
+			sum += dig *100;
+			break;
+		case 3:
+			sum += dig *1000;
+			break;
+		case 4:
+			sum += dig *10000;
+			break;
+		case 5:
+			sum += dig *100000;
+			break;
+		case 6:
+			sum += dig *1000000;
+			break;
+		case 7:
+			sum += dig *10000000;
+			break;
+		case 8:
+			sum += dig *100000000;
+			break;
+		case 9:
+			sum += dig *1000000000;
+			break;
+		default:
+			return 0;
+			break;
+		}
+	}
+	return isNegative ? 0 - sum : sum;
+}
+
+string vectorIntToStr(const vector<int> &vec) {
+	string str;
+	str.reserve(vec.size());
+	for (int i=0; i < (int)vec.size(); i++) {
+		str += (char)(vec[i]);
+	}
+	return str;
+}
+
+bool isHeaderLine(const QuickString &line) {
+	if (line[0] == '>') {
+		return true;
+	}
+	if (line[0] == '!') {
+		return true;
+	}
+	if (line[0] == '#') {
+		return true;
+	}
+	//GFF file headers can also start with the words "browser" or "track", followed by a whitespace character.
+	if (memcmp(line.c_str(), "browser", 7) == 0 && isspace(line[7])) {
+		return true;
+	}
+	if (memcmp(line.c_str(), "track", 5) == 0 && isspace(line[5])) {
+		return true;
+	}
+	if (memcmp(line.c_str(), "visibility", 10) == 0) {
+		return true;
+	}
+	return false;
+}
diff --git a/code/train/C++/0068884_vss2xhtml.cpp b/code/train/C++/0068884_vss2xhtml.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..edfeea5be7746ada8bc8863c3273264ca3f803ed
--- /dev/null
+++ b/code/train/C++/0068884_vss2xhtml.cpp
@@ -0,0 +1,118 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * This file is part of the libvisio project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include <stdio.h>
+#include <string.h>
+#include <librevenge-stream/librevenge-stream.h>
+#include <librevenge-generators/librevenge-generators.h>
+#include <librevenge/librevenge.h>
+#include <libvisio/libvisio.h>
+
+#ifndef VERSION
+#define VERSION "UNKNOWN VERSION"
+#endif
+
+namespace
+{
+
+int printUsage()
+{
+  printf("`vss2xhtml' converts Microsoft Visio stencils to SVG.\n");
+  printf("\n");
+  printf("Usage: vss2xhtml [OPTION] INPUT\n");
+  printf("\n");
+  printf("Options:\n");
+  printf("\t--help                show this help message\n");
+  printf("\t--version             show version information\n");
+  printf("\n");
+  printf("Report bugs to <https://bugs.documentfoundation.org/>.\n");
+  return -1;
+}
+
+int printVersion()
+{
+  printf("vss2xhtml " VERSION "\n");
+  return 0;
+}
+
+} // anonymous namespace
+
+int main(int argc, char *argv[])
+{
+  if (argc < 2)
+    return printUsage();
+
+  char *file = nullptr;
+
+  for (int i = 1; i < argc; i++)
+  {
+    if (!strcmp(argv[i], "--version"))
+      return printVersion();
+    else if (!file && strncmp(argv[i], "--", 2))
+      file = argv[i];
+    else
+      return printUsage();
+  }
+
+  if (!file)
+    return printUsage();
+
+  librevenge::RVNGFileStream input(file);
+
+  if (!libvisio::VisioDocument::isSupported(&input))
+  {
+    std::cerr << "ERROR: Unsupported file format (unsupported version) or file is encrypted!" << std::endl;
+    return 1;
+  }
+
+  librevenge::RVNGStringVector output;
+  librevenge::RVNGSVGDrawingGenerator generator(output, "svg");
+  if (!libvisio::VisioDocument::parseStencils(&input, &generator))
+  {
+    std::cerr << "ERROR: SVG Generation failed!" << std::endl;
+    return 1;
+  }
+  if (output.empty())
+  {
+    std::cerr << "ERROR: No SVG document generated!" << std::endl;
+    return 1;
+  }
+
+  std::cout << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
+  std::cout << "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" << std::endl;
+  std::cout << "<html xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:svg=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">" << std::endl;
+  std::cout << "<body>" << std::endl;
+  std::cout << "<?import namespace=\"svg\" urn=\"http://www.w3.org/2000/svg\"?>" << std::endl;
+
+  for (unsigned k = 0; k<output.size(); ++k)
+  {
+    if (k>0)
+      std::cout << "<hr/>\n";
+
+    std::cout << "<!-- \n";
+    std::cout << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n";
+    std::cout << "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"";
+    std::cout << " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n";
+    std::cout << " -->\n";
+
+    std::cout << output[k].cstr() << std::endl;
+  }
+
+  std::cout << "</body>" << std::endl;
+  std::cout << "</html>" << std::endl;
+
+  return 0;
+}
+/* vim:set shiftwidth=2 softtabstop=2 expandtab: */
diff --git a/code/train/C++/0069357_01knapSackBnBBF.cpp b/code/train/C++/0069357_01knapSackBnBBF.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..01385665751bb2f7089df1a501de13c7b795a1dc
--- /dev/null
+++ b/code/train/C++/0069357_01knapSackBnBBF.cpp
@@ -0,0 +1,113 @@
+#include <iostream>
+#include <algorithm>
+#include <queue>
+#include <cstdio>
+
+struct Node
+{
+	int nivel;
+	int ganancia;
+	int peso;
+};
+
+//se va hasta que el peso aguante en el fondo de un arbol para determinar la utilidad
+float bound(Node u, int pesoMax, int n, const int peso[], const int val[])
+{
+	if(u.peso >= pesoMax)
+		return 0;
+	
+	int j;
+	int pesoTotal;
+	float resultado;
+
+	resultado = u.ganancia;
+	j = u.nivel + 1;
+	pesoTotal = u.peso;
+
+	while(j <= n && pesoTotal + peso[j] <= pesoMax)
+	{
+		pesoTotal += peso[j];
+		resultado += val[j];
+		j++;
+	}
+	
+	if(j <= n)
+		resultado += (pesoMax - pesoTotal) * val[j]/peso[j];
+	
+	return resultado;
+}
+
+//beardth first search con branch and bound pruning
+int knapSack(int n, const int val[], const int peso[], int pesoMax)
+{
+	int gananciaMax;
+
+	//la busqueda de breadth first
+	std::queue<Node> Q;
+	Node u, v;
+
+	v.nivel = 0;
+	v.ganancia = 0;
+	v.peso = 0;
+
+	gananciaMax = 0;
+
+	Q.push(v);
+
+	while(!Q.empty())
+	{
+		v = Q.front();
+		Q.pop();
+
+		u.nivel = v.nivel + 1;
+		u.peso = v.peso + peso[u.nivel];
+		u.ganancia = v.ganancia + val[u.nivel];
+		
+		if(u.peso <= pesoMax && u.ganancia > gananciaMax)
+			gananciaMax = u.ganancia;
+		
+		if(bound(u, pesoMax, n, peso, val) > gananciaMax)
+			Q.push(u);
+		
+		u.peso = v.peso;
+		u.ganancia = v.ganancia;
+
+		if(bound(u, pesoMax, n, peso, val) > gananciaMax)
+			Q.push(u);
+	}
+
+	return gananciaMax;
+}
+
+/*params
+ * t: numero de test cases
+ * n: numero de objetos
+ * pesoMax: peso Maximo que aguanta el saco
+ * val: vector de valores de cada objeto
+ * peso: vector de peso de cada objeto
+ */
+int main()
+{
+	int n, pesoMax, t;
+	
+	//saco el numero de casos
+	std::scanf("%d", &t);
+
+	while(t--)
+	{
+		//obtengi el numero de objetos y el peso maximo
+		std::scanf("%d %d", &n, &pesoMax);
+	
+		//creo el vector de valores
+		int *val = new int[n];
+		for(int i = 0; i < n; i++)
+			std::scanf("%d", &val[i]);
+	
+		//creo el vector de pesos
+		int *peso = new int[n];
+		for(int i = 0; i < n; i++)
+			std::scanf("%d", &peso[i]);
+		
+		std::cout << knapSack(n, val, peso, pesoMax) << std::endl;
+	}
+}
diff --git a/code/train/C++/0069495_MMA7660.cpp b/code/train/C++/0069495_MMA7660.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ff2bcd876d7c930d709b37acc30e1c6531697a55
--- /dev/null
+++ b/code/train/C++/0069495_MMA7660.cpp
@@ -0,0 +1,193 @@
+#include "MMA7660.h"
+
+MMA7660::MMA7660(PinName sda, PinName scl, bool active) : _i2c(sda, scl)
+{
+    setActive(active);
+    samplerate = 64;
+
+}
+
+//Since the MMA lacks a WHO_AM_I register, we can only check if there is a device that answers to the I2C address
+bool MMA7660::testConnection( void )
+{
+    if (_i2c.write(MMA7660_ADDRESS, NULL, 0) == 0 )
+        return true;
+    else
+        return false;
+}
+
+void MMA7660::setActive(bool state)
+{
+    char modereg = read(MMA7660_MODE_R);
+    modereg &= ~(1<<0);
+
+    //If it somehow was in testmode, disable that
+    if (modereg && (1<<2)) {
+        modereg &= ~(1<<2);
+        write(MMA7660_MODE_R, modereg);
+    }
+
+    modereg += state;
+    write(MMA7660_MODE_R, modereg);
+}
+
+void MMA7660::readData(int *data)
+{
+    if (!active) {
+        setActive(true);
+        active = true;
+        wait(0.012 + 1/samplerate); //Wait until new sample is ready, my experience is that 1/samplerate isnt needed, but datasheet says so
+    }
+
+    char temp[3];
+    bool alert;
+
+    do {
+        alert = false;
+        read(MMA7660_XOUT_R, temp, 3);
+        for (int i = 0; i<3; i++) {
+            if (temp[i] > 63)
+                alert = true;
+            if (temp[i] > 31)
+                temp[i] += 128+64;
+            data[i] = (signed char)temp[i];
+        }
+    } while (alert);
+
+    if (!active)
+        setActive(false);
+}
+
+
+void MMA7660::readData(float *data)
+{
+    int intdata[3];
+    readData(intdata);
+    for (int i = 0; i<3; i++)
+        data[i] = intdata[i]/MMA7660_SENSITIVITY;
+}
+
+float MMA7660::x( void )
+{
+    return getSingle(0);
+}
+
+float MMA7660::y( void )
+{
+    return getSingle(1);
+}
+
+float MMA7660::z( void )
+{
+    return getSingle(2);
+}
+
+
+void MMA7660::setSampleRate(int samplerate)
+{
+    setActive(false);                               //Not allowed to be active to change anything
+    int rates[] = {120, 64, 32, 16, 8, 4, 2, 1};    //Alowed samplerates (and their number in array is also number required for MMA)
+    int sampleLoc = 0, sampleError = 10000, temp;
+    for (int i = 0; i<8; i++) {
+        temp = abs( rates[i] - samplerate );
+        if (temp<sampleError) {
+            sampleLoc = i;
+            sampleError=temp;
+        }
+    }
+
+    //Update the samplerate reg
+    temp = read(MMA7660_SR_R);
+    temp &= ~0x07;                                  //Awake sample rate are lowest 3 bit
+    temp |= sampleLoc;
+    write(MMA7660_SR_R, temp);
+    this->samplerate = rates[sampleLoc];
+    setActive(active);                              //Restore previous active state
+}
+
+
+MMA7660::Orientation MMA7660::getSide( void )
+{
+    char tiltreg = read(MMA7660_TILT_R);
+
+    //We care about 2 LSBs
+    tiltreg &= 0x03;
+    if (tiltreg == 0x01)
+        return MMA7660::Front;
+    if (tiltreg == 0x02)
+        return MMA7660::Back;
+    return MMA7660::Unknown;
+}
+
+MMA7660::Orientation MMA7660::getOrientation( void )
+{
+    char tiltreg = read(MMA7660_TILT_R);
+
+    //We care about bit 2, 3 and 4 (counting from zero)
+    tiltreg &= 0x07<<2;
+    tiltreg >>= 2;
+    if (tiltreg == 0x01)
+        return MMA7660::Left;
+    if (tiltreg == 0x02)
+        return MMA7660::Right;
+    if (tiltreg == 0x05)
+        return MMA7660::Down;
+    if (tiltreg == 0x06)
+        return MMA7660::Up;
+    return MMA7660::Unknown;
+}
+
+
+
+//////////////////////////////////////////////
+///////////////PRIVATE////////////////////////
+//////////////////////////////////////////////
+
+
+void MMA7660::write(char address, char data)
+{
+    char temp[2];
+    temp[0]=address;
+    temp[1]=data;
+
+    _i2c.write(MMA7660_ADDRESS, temp, 2);
+}
+
+char MMA7660::read(char address)
+{
+    char retval;
+    _i2c.write(MMA7660_ADDRESS, &address, 1, true);
+    _i2c.read(MMA7660_ADDRESS, &retval, 1);
+    return retval;
+}
+
+void MMA7660::read(char address, char *data, int length)
+{
+    _i2c.write(MMA7660_ADDRESS, &address, 1, true);
+    _i2c.read(MMA7660_ADDRESS, data, length);
+}
+
+float MMA7660::getSingle( int number )
+{
+    if (!active) {
+        setActive(true);
+        wait(0.012 + 1/samplerate); //Wait until new sample is ready
+    }
+
+    signed char temp;
+    bool alert;
+
+    do {
+        alert = false;
+        temp = read(MMA7660_XOUT_R + number);
+        if (temp > 63)
+            alert = true;
+        if (temp > 31)
+            temp += 128+64;
+    } while (alert);
+
+    if (!active)
+        setActive(false);
+
+    return temp / MMA7660_SENSITIVITY;
+}
diff --git a/code/train/C++/0069565_CColPolygon.cpp b/code/train/C++/0069565_CColPolygon.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1407fe871ea5928b7f8e19bd2bf9e41de1241544
--- /dev/null
+++ b/code/train/C++/0069565_CColPolygon.cpp
@@ -0,0 +1,187 @@
+/*****************************************************************************
+ *
+ *  PROJECT:     Multi Theft Auto v1.0
+ *  LICENSE:     See LICENSE in the top level directory
+ *  FILE:        mods/deathmatch/logic/CColPolygon.cpp
+ *  PURPOSE:     Polygon-shaped collision entity class
+ *
+ *  Multi Theft Auto is available from http://www.multitheftauto.com/
+ *
+ *****************************************************************************/
+
+#include "StdInc.h"
+
+CColPolygon::CColPolygon(CColManager* pManager, CElement* pParent, const CVector& vecPosition) : CColShape(pManager, pParent)
+{
+    m_vecPosition = vecPosition;
+
+    // That's only to speed up things by not checking the polygon collision,
+    // if the point is not even in the bounds
+    m_fRadius = 0.0f;
+}
+
+CElement* CColPolygon::Clone(bool* bAddEntity, CResource* pResource)
+{
+    CColPolygon* pColPolygon = new CColPolygon(m_pManager, GetParentEntity(), m_vecPosition);
+    pColPolygon->m_Points = m_Points;
+    pColPolygon->m_fRadius = m_fRadius;
+    pColPolygon->SizeChanged();
+    return pColPolygon;
+}
+
+bool CColPolygon::DoHitDetection(const CVector& vecNowPosition)
+{
+    if (!IsInBounds(vecNowPosition))
+        return false;
+
+    if (vecNowPosition.fZ > m_fCeil || vecNowPosition.fZ < m_fFloor)
+        return false;
+
+    bool collides = false;
+
+    int j = m_Points.size() - 1;
+
+    float x = vecNowPosition.fX;
+    float y = vecNowPosition.fY;
+
+    for (unsigned int i = 0; i < m_Points.size(); i++)
+    {
+        CVector2D vecPi = m_Points[i];
+        CVector2D vecPj = m_Points[j];
+
+        if ((vecPi.fY < y && vecPj.fY >= y) || (vecPj.fY < y && vecPi.fY >= y))
+        {
+            if (vecPi.fX + (y - vecPi.fY) / (vecPj.fY - vecPi.fY) * (vecPj.fX - vecPi.fX) < x)
+            {
+                collides = !collides;
+            }
+        }
+
+        j = i;
+    }
+
+    return collides;
+}
+
+bool CColPolygon::ReadSpecialData(const int iLine)
+{
+    int iTemp;
+    if (GetCustomDataInt("dimension", iTemp, true))
+        m_usDimension = static_cast<unsigned short>(iTemp);
+
+    return true;
+}
+
+void CColPolygon::SetPosition(const CVector& vecPosition)
+{
+    CVector vecDifference = m_vecPosition - vecPosition;
+
+    for (unsigned int i = 0; i < m_Points.size(); i++)
+    {
+        m_Points[i].fX -= vecDifference.fX;
+        m_Points[i].fY -= vecDifference.fY;
+    }
+
+    m_vecPosition = vecPosition;
+
+    UpdateSpatialData();
+    // Add queued collider refresh for v1.1
+}
+
+bool CColPolygon::AddPoint(CVector2D vecPoint)
+{
+    m_Points.push_back(vecPoint);
+    CalculateRadius(vecPoint);
+    return true;
+}
+
+bool CColPolygon::AddPoint(CVector2D vecPoint, unsigned int uiPointIndex)
+{
+    if (uiPointIndex > m_Points.size())
+        return false;
+
+    m_Points.insert(m_Points.begin() + uiPointIndex, vecPoint);
+    CalculateRadius(vecPoint);
+
+    return true;
+}
+
+bool CColPolygon::RemovePoint(unsigned int uiPointIndex)
+{
+    if (m_Points.size() <= 3)
+        return false;
+
+    m_Points.erase(m_Points.begin() + uiPointIndex);
+
+    CalculateRadius();
+    return true;
+}
+
+bool CColPolygon::SetPointPosition(unsigned int uiPointIndex, const CVector2D& vecPoint)
+{
+    if (uiPointIndex >= m_Points.size())
+        return false;
+
+    m_Points[uiPointIndex] = vecPoint;
+
+    CalculateRadius();
+    return true;
+}
+
+void CColPolygon::CalculateRadius()
+{
+    m_fRadius = 0.0f;
+    for (auto vecPoint : m_Points)
+    {
+        CVector2D vecDistance = vecPoint - m_vecPosition;
+        float     fDistance = vecDistance.Length();
+
+        if (fDistance > m_fRadius)
+            m_fRadius = fDistance;
+    }
+
+    SizeChanged();
+}
+
+void CColPolygon::CalculateRadius(const CVector2D& vecPoint)
+{
+    CVector2D vecDistance = vecPoint - m_vecPosition;
+    float     fDistance = vecDistance.Length();
+
+    if (fDistance > m_fRadius)
+    {
+        m_fRadius = fDistance;
+        SizeChanged();
+    }
+}
+
+bool CColPolygon::IsInBounds(CVector vecPoint)
+{
+    float fDistanceX = vecPoint.fX - m_vecPosition.fX;
+    float fDistanceY = vecPoint.fY - m_vecPosition.fY;
+
+    float fDist = sqrt(fDistanceX * fDistanceX + fDistanceY * fDistanceY);
+
+    return fDist <= m_fRadius;
+}
+
+CSphere CColPolygon::GetWorldBoundingSphere()
+{
+    CSphere sphere;
+    sphere.vecPosition.fX = m_vecPosition.fX;
+    sphere.vecPosition.fY = m_vecPosition.fY;
+    sphere.vecPosition.fZ = SPATIAL_2D_Z;
+    sphere.fRadius = m_fRadius;
+    return sphere;
+}
+
+bool CColPolygon::SetHeight(float fFloor, float fCeil)
+{
+    if (m_fFloor == fFloor && m_fCeil == fCeil)
+        return false;
+
+    m_fFloor = fFloor;
+    m_fCeil = fCeil;
+
+    return true;
+}
diff --git a/code/train/C++/0070369_Application.cpp b/code/train/C++/0070369_Application.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8d98bf87889c297bba45fd11649c15c550ab5bd6
--- /dev/null
+++ b/code/train/C++/0070369_Application.cpp
@@ -0,0 +1,208 @@
+/*
+  NUI3 - C++ cross-platform GUI framework for OpenGL based applications
+  Copyright (C) 2002-2003 Sebastien Metrot
+
+  licence: see nui3/LICENCE.TXT
+*/
+ 
+
+#include "nui.h"
+#include "nuiInit.h"
+#include "Application.h"
+#include "MainWindow.h"
+#include "Engine/Engine.h"
+
+#include "nglConsole.h"
+
+#ifdef _CARBON_
+#include "nuiAudioDevice_CoreAudio.h"
+#elif (defined _WIN32_)
+#include "nuiAudioDevice_DirectSound.h"
+#elif (defined _UIKIT_)
+#include "nuiAudioDevice_AudioUnit.h"
+#else
+// Add needed sound API
+#endif
+
+
+
+#define APPLICATION_TITLE _T("nuiDemo")
+
+
+NGL_APP_CREATE(Application);
+
+Application::Application()
+{
+  mpMainWindow = NULL;
+  
+  // this make the audio system works (c.f. last update on nuiAudioDevice)
+  #ifdef _CARBON_
+  wprintf(_T("Audio system:%ls\n"), CoreAudioAPI.GetAPIName().GetChars());
+  #elif (defined _UIKIT_)
+  wprintf(_T("Audio system:%ls\n"), AudioUnitAPI.GetAPIName().GetChars());
+  #endif
+}
+
+Application::~Application()
+{
+}
+
+void Application::OnExit (int Code)
+{
+  if (mpMainWindow)
+  {
+    mpMainWindow->Release();
+    mpMainWindow = NULL;
+  }
+
+  nuiUninit();
+}
+
+void Application::OnInit()
+{
+  nuiInit(NULL);
+
+  InitWindow();
+
+}
+
+
+void Application::InitWindow()
+{
+  uint Width = 0, Height = 0;
+  bool HasSize = false;
+  bool IsFullScreen = false;
+  bool DebugObject = false;
+  bool DebugInfo = false;
+  bool ShowFPS = false;
+
+
+  // build application engine
+  mpEngine = new Engine();  
+  
+
+  nuiRenderer Renderer = eOpenGL;
+  //  nuiRenderer Renderer = eDirect3D;
+  //  nuiRenderer Renderer = eSoftware;
+  
+  // Accept NGL default options
+  ParseDefaultArgs();
+  
+  GetLog().UseConsole(true);
+  GetLog().SetLevel(_T("font"), 100);
+  
+  // Manual
+  if ( (GetArgCount() == 1) &&
+      ((!GetArg(0).Compare(_T("-h"))) || (!GetArg(0).Compare(_T("--help")))) )
+  {
+    NGL_OUT(_T("no params\n"));
+    Quit (0);
+    return;
+  }
+  
+  // Parse args
+  int i = 0;
+  while (i < GetArgCount())
+  {
+    nglString arg = GetArg(i);
+    if ((!arg.Compare(_T("--size")) || !arg.Compare(_T("-s"))) && ((i+1) < GetArgCount()))
+    {
+      int w, h;
+      
+      std::string str(GetArg(i+1).GetStdString());
+      sscanf(str.c_str(), "%dx%d", &w, &h);
+      if (w > 0) Width  = w;
+      if (h > 0) Height = h;
+      HasSize = true;
+      i++;
+    }
+    else if (!arg.Compare(_T("--showfps")) || !arg.Compare(_T("-fps"))) ShowFPS = true;
+    else if (!arg.Compare(_T("--fullscreen")) || !arg.Compare(_T("-f"))) IsFullScreen = true;
+    else if (!arg.Compare(_T("--debugobject")) || !arg.Compare(_T("-d"))) DebugObject = true;
+    else if (!arg.Compare(_T("--debuginfo")) || !arg.Compare(_T("-i"))) DebugInfo = true;
+    else if (!arg.Compare(_T("--renderer")) || !arg.Compare(_T("-r"))) 
+    {
+      arg = GetArg(i+1);
+      if (!arg.Compare(_T("opengl"))) Renderer = eOpenGL;
+      else if (!arg.Compare(_T("direct3d"))) Renderer = eDirect3D;
+      else if (!arg.Compare(_T("software"))) Renderer = eSoftware;
+      i++;
+    }
+    i++;
+  }
+  
+  nuiMainWindow::SetRenderer(Renderer);
+  
+  if (!HasSize)
+  {
+    if (IsFullScreen)
+    {
+      nglVideoMode current_mode;
+      
+      Width = current_mode.GetWidth();
+      Height = current_mode.GetHeight();
+    }
+    else
+    {
+      Width = 320;
+      Height = 480;
+    }
+  }
+  
+  
+  /* Create the nglWindow (and thus a GL context, don't even try to
+   *   instantiate the gui (or nglFont) before the nuiWin !)
+   */
+  nuiContextInfo ContextInfo(nuiContextInfo::StandardContext3D);
+  nglWindowInfo Info;
+  
+  Info.Flags = nglWindow::NoResize | (IsFullScreen ? nglWindow::FullScreen : 0);
+  Info.Width = Width;
+  Info.Height = Height;
+  Info.Pos = nglWindowInfo::ePosCenter;
+  Info.Title = APPLICATION_TITLE;
+  Info.XPos = 0;
+  Info.YPos = 0;
+  
+  mpMainWindow = new MainWindow(ContextInfo,Info, ShowFPS);
+  if ((!mpMainWindow) || (mpMainWindow->GetError()))
+  {
+    if (mpMainWindow) 
+      NGL_OUT(_T("Error: cannot create window (%s)\n"), mpMainWindow->GetErrorStr());
+    Quit (1);
+    return;
+  }
+  mpMainWindow->Acquire();
+  mpMainWindow->DBG_SetMouseOverInfo(DebugInfo);  mpMainWindow->DBG_SetMouseOverObject(DebugObject);
+  mpMainWindow->SetState(nglWindow::eShow);  
+}
+
+
+
+MainWindow* Application::GetMainWindow()
+{
+  return mpMainWindow;
+}
+
+Engine* Application::GetEngine()
+{
+  return mpEngine;
+}
+
+
+// globals ***********************************************
+
+Application* GetApp()
+{
+  return ((Application*)App);
+}
+
+MainWindow* GetMainWindow()
+{
+  return ((Application*)App)->GetMainWindow();
+}
+
+Engine* GetEngine()
+{
+  return ((Application*)App)->GetEngine();
+}
\ No newline at end of file
diff --git a/code/train/C++/0071290_DouglasPeuckerMod.cpp b/code/train/C++/0071290_DouglasPeuckerMod.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..da4ab37cb37108a6babe85f163215681efb396a0
--- /dev/null
+++ b/code/train/C++/0071290_DouglasPeuckerMod.cpp
@@ -0,0 +1,210 @@
+/* Copyright_License {
+
+  XCSoar Glide Computer - http://www.xcsoar.org/
+  Copyright (C) 2000-2013 The XCSoar Project
+  A detailed list of copyright holders can be found in the file "AUTHORS".
+
+  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.
+}
+
+  Original code of Douglas-Peucker algorithm by Robert Coup <robert.coup@koordinates.com>
+*/
+
+#include "DouglasPeuckerMod.hpp"
+#include "IGCFixEnhanced.hpp"
+#include "Geo/GeoPoint.hpp"
+
+#include <stack>
+#include <vector>
+#include <list>
+#include <utility>
+#include <algorithm>
+
+DouglasPeuckerMod::DouglasPeuckerMod(const unsigned _num_levels,
+                                     const unsigned _zoom_factor,
+                                     const double _threshold,
+                                     const bool _force_endpoints,
+                                     const unsigned _max_delta_time,
+                                     const unsigned _max_points)
+  : num_levels(_num_levels), zoom_factor(_zoom_factor),
+    threshold(_threshold), force_endpoints(_force_endpoints),
+    max_delta_time(_max_delta_time), max_points(_max_points) {
+  zoom_level_breaks = new double[num_levels];
+
+  for (unsigned i = 0; i < num_levels; i++) {
+    zoom_level_breaks[i] = threshold * pow(zoom_factor, num_levels - i - 1);
+  }
+}
+
+DouglasPeuckerMod::~DouglasPeuckerMod() {
+  delete[] zoom_level_breaks;
+}
+
+void DouglasPeuckerMod::Encode(std::vector<IGCFixEnhanced> &fixes,
+                                             const unsigned start, const unsigned end) {
+  unsigned max_loc = 0;
+  std::stack<std::pair<unsigned, unsigned>> stack;
+  const unsigned fixes_size = end - start;
+  DistQueue dists;
+
+  double temp,
+         max_dist,
+         abs_max_dist_squared = 0.0,
+         abs_max_dist,
+         threshold_squared = pow(threshold, 2);
+
+  /**
+   * use normal douglas peucker distance (perpendicular to segment) for lon/lat
+   * and use simple distance calculation for time
+   */
+
+  // simplify using Douglas-Peucker
+  if (fixes_size > 2) {
+    stack.push(std::pair<unsigned, unsigned>(start, end - 1));
+
+    while (stack.size() > 0) {
+      std::pair<unsigned, unsigned> current = stack.top();
+      stack.pop();
+      max_dist = 0;
+
+      for (unsigned i = current.first + 1; i < current.second; i++) {
+        temp = std::max(DistanceGeo(fixes[i].location,
+                                    fixes[current.first].location,
+                                    fixes[current.second].location),
+                        DistanceTime(fixes[i].clock,
+                                     fixes[current.first].clock,
+                                     fixes[current.second].clock));
+
+        if (temp > max_dist) {
+          max_dist = temp;
+          max_loc = i;
+        }
+      }
+
+      if (max_dist > abs_max_dist_squared) {
+        abs_max_dist_squared = max_dist;
+      }
+
+      if (max_dist > threshold_squared) {
+        dists.push(std::pair<unsigned, double>(max_loc, sqrt(max_dist)));
+        stack.push(std::pair<unsigned, unsigned>(current.first, max_loc));
+        stack.push(std::pair<unsigned, unsigned>(max_loc, current.second));
+      }
+    }
+  }
+
+  abs_max_dist = sqrt(abs_max_dist_squared);
+
+  Classify(fixes, dists, abs_max_dist, start, end);
+}
+
+/**
+ * distance(p0, p1, p2) computes the distance between the point p0 and the
+ * segment [p1,p2]. This could probably be replaced with something that is a
+ * bit more numerically stable.
+ */
+double DouglasPeuckerMod::DistanceGeo(const GeoPoint &p0,
+                                       const GeoPoint &p1,
+                                       const GeoPoint &p2) {
+  double u,
+         out = 0.0,
+         u_nom = 0.0,
+         u_denom = 0.0;
+
+  if (p1.longitude == p2.longitude &&
+      p1.latitude == p2.latitude) {
+    out += pow(p2.longitude.Degrees() - p0.longitude.Degrees(), 2);
+    out += pow(p2.latitude.Degrees() - p0.latitude.Degrees(), 2);
+  } else {
+    u_nom += (p0.longitude.Degrees() - p1.longitude.Degrees())
+             * (p2.longitude.Degrees() - p1.longitude.Degrees());
+    u_nom += (p0.latitude.Degrees() - p1.latitude.Degrees())
+             * (p2.latitude.Degrees() - p1.latitude.Degrees());
+
+    u_denom += pow(p2.longitude.Degrees() - p1.longitude.Degrees(), 2);
+    u_denom += pow(p2.latitude.Degrees() - p1.latitude.Degrees(), 2);
+
+    u = u_nom / u_denom;
+
+    if (u <= 0) {
+      out += pow(p0.longitude.Degrees() - p1.longitude.Degrees(), 2);
+      out += pow(p0.latitude.Degrees() - p1.latitude.Degrees(), 2);
+    } else if (u >= 1) {
+      out += pow(p0.longitude.Degrees() - p2.longitude.Degrees(), 2);
+      out += pow(p0.latitude.Degrees() - p2.latitude.Degrees(), 2);
+    } else if (0 < u && u < 1) {
+      out += pow(p0.longitude.Degrees() - p1.longitude.Degrees()
+             - u * (p2.longitude.Degrees() - p1.longitude.Degrees()), 2);
+      out += pow(p0.latitude.Degrees() - p1.latitude.Degrees()
+             - u * (p2.latitude.Degrees() - p1.latitude.Degrees()), 2);
+    }
+  }
+
+  return out;
+}
+
+double DouglasPeuckerMod::DistanceTime(const unsigned time0,
+                                        const unsigned time1,
+                                        const unsigned time2) {
+  double out = sqrt(abs(time1 - time0) / max_delta_time * threshold) +
+               sqrt(abs(time2 - time0) / max_delta_time * threshold);
+
+  out = pow(out, 2)/4;
+
+  return pow(out, 2);
+}
+
+void DouglasPeuckerMod::Classify(std::vector<IGCFixEnhanced> &fixes,
+                                 DistQueue &dists,
+                                 const double abs_max_dist,
+                                 const unsigned start,
+                                 const unsigned end) {
+
+  /* initialize levels with -1 */
+  for (unsigned i = 0; i < fixes.size(); ++i) {
+    fixes[i].level = -1;
+  }
+
+  // return early if start == end
+  if (start == end) {
+    fixes[start].level = 0;
+    return;
+  }
+
+  unsigned i = force_endpoints ? 2 : 0;
+  while (!dists.empty() && ++i < max_points) {
+    std::pair<unsigned, double> fix_dist = dists.top();
+    fixes[fix_dist.first].level = ComputeLevel(fix_dist.second);
+    dists.pop();
+  }
+
+  /* Level for start- and endpoint */
+  if (force_endpoints) {
+    fixes[start].level = 0;
+    fixes[end - 1].level = 0;
+  }
+}
+
+unsigned DouglasPeuckerMod::ComputeLevel(const double abs_max_dist) {
+  unsigned lev = 0;
+
+  if (abs_max_dist > threshold) {
+    while (abs_max_dist < zoom_level_breaks[lev]) {
+      lev++;
+    }
+  }
+
+  return lev;
+}
diff --git a/code/train/C++/0071608_gyro_calibration.cpp b/code/train/C++/0071608_gyro_calibration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7328613e4be44af3553b0b0927e7d6d4eb52a415
--- /dev/null
+++ b/code/train/C++/0071608_gyro_calibration.cpp
@@ -0,0 +1,213 @@
+#include <ros/ros.h>
+#include <custom_navigation/M_ADC.h>
+#include <vector>
+#include <boost/thread.hpp>
+using namespace std;
+
+
+struct ADCmessages{
+    double time;
+    double data1x;
+    double data4x;
+};
+
+int calib_size = 0;
+double calib_sum = 0.0;
+double calib_sum4x = 0.0;
+bool CALIBRATION_REST_MODE = false;
+bool CALIBRATION_MOVEMENT_MODE = false;
+double AVG1X = 0.0;
+double AVG4X = 0.0;
+ros::Rate *rate;
+string textWhileWaitingUserInput = "";
+vector<ADCmessages> vRestCalibration;
+vector<ADCmessages> vMoveCalibration;
+vector<double> vGain1x;
+vector<double> vGain4x;
+double AVG_GAIN1X = 0.0;
+double AVG_GAIN4X = 0.0;
+string robot_name;
+
+void calibrateAtRest();
+void restCalibration(double &data1x,double &data4x);
+void calibrateRevolutions();
+int getNumberOfCalibrations();
+void movementCalibration();
+void calculateGains();
+void pressAnyKey();
+void waitUser();
+void pressAnyKey();
+void spinFunction();
+
+//=================================== CALLBACKS ===================================
+void dataAdcReceived(const custom_navigation::M_ADC::Ptr& msg){
+    struct ADCmessages data;
+    data.time = msg->header.stamp.toSec();
+    data.data1x = msg->canal5[0];
+    data.data4x = msg->canal6[0];
+
+    if(CALIBRATION_REST_MODE){
+        vRestCalibration.push_back(data);
+    }
+    else if(CALIBRATION_MOVEMENT_MODE){
+        vMoveCalibration.push_back(data);
+    }
+}
+
+//=================================== FUNCTIONS ===================================
+
+void calibrateAtRest(){
+    cout << "The program will be doing calibration when the robot is at rest, so do not move the robot during this step." << endl;
+    textWhileWaitingUserInput = "When ready to start rest calibration of the robot, press enter! ";
+    waitUser();
+    CALIBRATION_REST_MODE = true;
+    cout << "Starting rest calibration" << endl;
+    while(CALIBRATION_REST_MODE && ros::ok()){
+        if(vRestCalibration.size() > 0){
+            struct ADCmessages lData = vRestCalibration.front();
+            vRestCalibration.erase(vRestCalibration.begin());
+            restCalibration(lData.data1x,lData.data4x);
+        }
+        (*rate).sleep();
+    }
+}
+
+void restCalibration(double &data1x,double &data4x){
+    calib_sum += data1x;
+    calib_sum4x += data4x;
+    calib_size++;
+    if(calib_size > 150){
+        AVG1X = calib_sum / calib_size;
+        AVG4X = calib_sum4x / calib_size;
+        CALIBRATION_REST_MODE = false;
+    }
+}
+
+void calibrateRevolutions(){
+    int NumberOfMoveCalib = getNumberOfCalibrations();
+    for(int i=0; i<NumberOfMoveCalib; i++){
+        if(ros::ok()){
+            textWhileWaitingUserInput = "Press enter to begin rotation calibration. ";
+            waitUser();
+            textWhileWaitingUserInput = "Starting to record data. Turn the robot by 360 degrees and press enter when it is completed. ";
+            boost::thread myThread(pressAnyKey);
+            movementCalibration();
+            myThread.join();
+        }
+    }
+    calculateGains();
+}
+
+int getNumberOfCalibrations(){
+    int NumberOfMoveCalib;
+    cout << "How many revolutions you want to do for calibrating the gyroscope (minimum of 3 recommended) ? " << endl;
+    cin >> NumberOfMoveCalib;
+    getchar();
+    return NumberOfMoveCalib;
+}
+
+void movementCalibration(){
+    CALIBRATION_MOVEMENT_MODE = true;
+    bool firstCalibrationTime = true;
+    double oldtime = 0.0;
+    double dt = 0.0;
+    double buffer1X = 0.0;
+    double buffer4X = 0.0;
+    while(CALIBRATION_MOVEMENT_MODE){
+        if(vMoveCalibration.size() > 0){
+            struct ADCmessages lData = vMoveCalibration.front();
+            vMoveCalibration.erase(vMoveCalibration.begin());
+
+            if(firstCalibrationTime){
+                dt = 0.05;
+                firstCalibrationTime = false;
+            }
+            else{
+                dt = lData.time - oldtime;
+            }
+            oldtime = lData.time;
+            double temp1x = (lData.data1x - AVG1X) * dt;
+            double temp4x = (lData.data4x - AVG4X) * dt;
+            buffer1X += temp1x;
+            buffer4X += temp4x;
+            //cout << "-> (" << lData.data1x << " - " << AVG1X << ") * " << dt <<" = " << temp1x;
+            //cout << "  buffer1x = " << buffer1X << endl;
+        }
+    }
+    //cout << "Gain 1x = " << 360/buffer1X << endl;
+    //cout << "Gain 4x = " << 360/buffer1X << endl;
+    if(buffer1X != 0) vGain1x.push_back(360/buffer1X);
+    if(buffer4X != 0) vGain4x.push_back(360/buffer4X);
+}
+
+void calculateGains(){
+    AVG_GAIN1X = 0.0;
+    AVG_GAIN4X = 0.0;
+    double size1x = vGain1x.size();
+    double size4x = vGain1x.size();
+
+    for(int i=0; i<size1x; i++){
+        AVG_GAIN1X += abs(vGain1x.at(i));
+    }
+    if(size1x > 0){
+       AVG_GAIN1X = AVG_GAIN1X / size1x;
+    }
+    for(int i=0; i<size4x; i++){
+        AVG_GAIN4X += abs(vGain4x.at(i));
+    }
+    if(size4x > 0){
+       AVG_GAIN4X = AVG_GAIN4X / size4x;
+    }
+
+    //cout << "size = " << size1x << "  AVG_GAIN1X = " << AVG_GAIN1X << endl;
+}
+
+void waitUser(){
+    boost::thread myThread(pressAnyKey);
+    myThread.join();
+}
+
+void printResults(){
+    //cout << "AVG1X = " << AVG1X << "  AVG4X = " << AVG4X << endl;
+    //cout << "GAIN1X = " << AVG_GAIN1X << "  GAIN4X = " << AVG_GAIN4X << endl;
+    cout << "Calibration is over! Go modify the parameters in custom_navigation.launch ! " << endl;
+    cout << "avg: " << AVG1X << endl;
+    cout << "gain: " << AVG_GAIN1X << endl;
+}
+
+//=================================== THREADS ===================================
+void pressAnyKey(){
+    cout << textWhileWaitingUserInput << endl;
+    getchar();
+    CALIBRATION_MOVEMENT_MODE = false;
+}
+
+void spinFunction(){
+    ros::Rate r(20);
+    while(ros::ok()){
+        ros::spinOnce();
+        r.sleep();
+    }
+}
+
+
+int main(int argc, char **argv)
+{
+    ros::init(argc, argv, "gyro_calibration");
+    ros::NodeHandle n;
+    ros::NodeHandle nh("~");
+    nh.param("robot_name",robot_name, std::string("robot_0"));
+
+    ros::Subscriber sub = n.subscribe("/" + robot_name + "/D_ADC/data", 1000, dataAdcReceived);
+    rate = new ros::Rate(20);
+
+    boost::thread spinThread(spinFunction);
+    calibrateAtRest();
+    printResults();
+    calibrateRevolutions();
+    printResults();
+    spinThread.~thread();
+
+    return 0;
+}
+
diff --git a/code/train/C++/0072022_OrthographicDrawing.cpp b/code/train/C++/0072022_OrthographicDrawing.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2e3ffcdec3b9253047a92d27e85d087be0ca1bea
--- /dev/null
+++ b/code/train/C++/0072022_OrthographicDrawing.cpp
@@ -0,0 +1,185 @@
+#include "OrthographicDrawing.h"
+
+#include <GL/glut.h>
+
+#include <NxFoundation.h>
+
+#include "GLFontRenderer.h"
+
+#include "common.h"
+
+void OrthographicDrawing::setOrthographicProjection(float w, float h)
+{
+	glMatrixMode(GL_PROJECTION);
+	glPushMatrix();
+	glLoadIdentity();
+	glOrtho(0, w, 0, h, -1, 1);
+	glMatrixMode(GL_MODELVIEW);
+	GLFontRenderer::setScreenResolution((int)w, (int)h);
+
+	mWidth = w;
+	mHeight = h;
+}
+
+void OrthographicDrawing::resetPerspectiveProjection()
+{
+	glMatrixMode(GL_PROJECTION);
+	glPopMatrix();
+	glMatrixMode(GL_MODELVIEW);
+}
+
+void OrthographicDrawing::drawCircle(float posX, float posY, float radius, float fromDegree, float toDegree, float stepDegree, int bigMarks, int smallMarks)
+{
+
+	glDisable(GL_DEPTH_TEST);
+	glDisable(GL_LIGHTING);
+	glDisable(GL_BLEND);
+
+	float fromRad = NxMath::degToRad(fromDegree);
+	float toRad = NxMath::degToRad(toDegree);
+	float stepRad = NxMath::degToRad(stepDegree);
+	int lineLen = int(((toRad-fromRad)/stepRad)*2);
+
+	static int vecBufferSize = 0;
+	static NxVec3* pVecBuffer = NULL;
+
+	if(vecBufferSize < lineLen)
+	{
+		delete[] pVecBuffer;
+		pVecBuffer = new NxVec3[lineLen];
+		vecBufferSize = lineLen;
+	}
+
+	float angle = fromRad;
+	for(int i = 0; i < lineLen/2; angle += stepRad, i++)
+	{
+		float Sin, Cos;
+		NxMath::sinCos(angle, Sin, Cos);
+		pVecBuffer[i*2+0].set(posX + Cos*radius, posY - Sin*radius, 0);
+		NxMath::sinCos(angle+stepRad, Sin, Cos);
+		pVecBuffer[i*2+1].set(posX + Cos*radius, posY - Sin*radius, 0);
+	}
+
+	glEnableClientState(GL_VERTEX_ARRAY);
+#ifdef __PPCGEKKO__
+	glVertexPointer(3, GL_FLOAT, sizeof(NxVec3), vecBufferSize, pVecBuffer);
+#else	
+	glVertexPointer(3, GL_FLOAT, sizeof(NxVec3), pVecBuffer);
+#endif
+	glDrawArrays(GL_LINES, 0, lineLen);
+	glDisableClientState(GL_VERTEX_ARRAY);
+
+	if (bigMarks > 0) {
+		stepRad = (toRad - fromRad) / (float)bigMarks;
+		float bigRadius = radius * 1.2f;
+		float smallRadius = radius * 0.8f;
+		float toRad2 = toRad + 0.01f;
+
+		int lineLen = int(((toRad2-fromRad)/stepRad)+1);
+
+		if(vecBufferSize < lineLen*2)
+		{
+			delete[] pVecBuffer;
+			pVecBuffer = new NxVec3[lineLen*2];
+			vecBufferSize = lineLen*2;
+		}
+
+		float angle = fromRad;
+		for(int i = 0; i < lineLen; angle += stepRad, i++)
+		{
+			float Sin, Cos;
+			NxMath::sinCos(angle, Sin, Cos);
+			pVecBuffer[i*2+0].set(posX + Cos*bigRadius, posY - Sin*bigRadius, 0);
+			pVecBuffer[i*2+1].set(posX + Cos*smallRadius, posY - Sin*smallRadius, 0);
+		}
+
+		glEnableClientState(GL_VERTEX_ARRAY);
+#ifdef __PPCGEKKO__
+	glVertexPointer(3, GL_FLOAT, sizeof(NxVec3), vecBufferSize, pVecBuffer);
+#else
+		glVertexPointer(3, GL_FLOAT, sizeof(NxVec3), pVecBuffer);
+#endif
+		glDrawArrays(GL_LINES, 0, lineLen*2);
+		glDisableClientState(GL_VERTEX_ARRAY);	
+
+	}
+
+	if (smallMarks > 0) {
+		stepRad = (toRad - fromRad) / (float)smallMarks;
+		float bigRadius = radius * 1.1f;
+		float smallRadius = radius * 0.9f;
+		float toRad2 = toRad + 0.01f;
+		int lineLen = int(((toRad2-fromRad)/stepRad)+1);
+
+		if(vecBufferSize < lineLen*2)
+		{
+			delete[] pVecBuffer;
+			pVecBuffer = new NxVec3[lineLen*2];
+			vecBufferSize = lineLen*2;
+		}
+		
+		float angle = fromRad;
+		for(int i = 0; i < lineLen; angle += stepRad, i++)		
+		{
+			float Sin, Cos;
+			NxMath::sinCos(angle, Sin, Cos);
+			pVecBuffer[i*2+0].set(posX + Cos*bigRadius, posY - Sin*bigRadius, 0);
+			pVecBuffer[i*2+1].set(posX + Cos*smallRadius, posY - Sin*smallRadius, 0);
+		}
+
+		glEnableClientState(GL_VERTEX_ARRAY);
+#ifdef __PPCGEKKO__
+	glVertexPointer(3, GL_FLOAT, sizeof(NxVec3), vecBufferSize, pVecBuffer);
+#else
+		glVertexPointer(3, GL_FLOAT, sizeof(NxVec3), pVecBuffer);
+#endif
+		glDrawArrays(GL_LINES, 0, lineLen*2);
+		glDisableClientState(GL_VERTEX_ARRAY);
+	}
+	
+}
+
+void OrthographicDrawing::drawLine(float x1, float y1, float x2, float y2)
+{
+#ifdef __PPCGEKKO__
+	glBegin(GL_LINES, 2);
+	glVertex3d(x1, y1, 0);
+	glVertex3d(x2, y2, 0);
+	glEnd();
+#else
+	glEnableClientState(GL_VERTEX_ARRAY);
+	float line[2][3] = {{x1, y1, 0},{x2, y2, 0}};
+	glVertexPointer(3, GL_FLOAT, 0, line);
+	glDrawArrays(GL_LINES, 0, 2);
+	glDisableClientState(GL_VERTEX_ARRAY);
+#endif
+}
+
+void OrthographicDrawing::drawText(int xpos, int ypos, const char* pText)
+{
+
+	float x = (float)xpos/(float)glutGet(GLUT_WINDOW_WIDTH);
+	float y = 1-(float)ypos/(float)glutGet(GLUT_WINDOW_HEIGHT);
+
+	int len = (int)strlen(pText);
+	len = (len < 256)?len:255;
+	int start = 0;
+	char textBuffer[256];
+	for(int i=0;i<len;i++)
+	{
+		if(pText[i] == '\n' || i == len-1)
+		{
+			int offset = i;
+			if(i == len-1) offset= i+1;
+			memcpy(textBuffer, pText+start, offset-start);
+			textBuffer[offset-start]=0;
+#ifdef __PPCGEKKO__
+			GLFontRenderer::print(x, y, 0.025f*512.0f/(float)glutGet(GLUT_WINDOW_HEIGHT), textBuffer, false, 11, true);
+#else
+			GLFontRenderer::print(x, y, 0.025f*512.0f/(float)glutGet(GLUT_WINDOW_HEIGHT), textBuffer, false, 11, false);
+#endif
+			y -= 0.035f;
+			start = offset+1;
+		}
+	}
+}
diff --git a/code/train/C++/0072074_intro.cpp b/code/train/C++/0072074_intro.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..33ce78aeb8036bcd1a0f06311e07ff6587834640
--- /dev/null
+++ b/code/train/C++/0072074_intro.cpp
@@ -0,0 +1,292 @@
+// Copyright (c) 2011-2014 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "intro.h"
+#include "ui_intro.h"
+
+#include "guiutil.h"
+
+#include "util.h"
+
+#include <boost/filesystem.hpp>
+
+#include <QFileDialog>
+#include <QSettings>
+#include <QMessageBox>
+
+/* Minimum free space (in bytes) needed for data directory */
+static const uint64_t GB_BYTES = 1000000000LL;
+static const uint64_t BLOCK_CHAIN_SIZE = 20LL * GB_BYTES;
+
+/* Check free space asynchronously to prevent hanging the UI thread.
+
+   Up to one request to check a path is in flight to this thread; when the check()
+   function runs, the current path is requested from the associated Intro object.
+   The reply is sent back through a signal.
+
+   This ensures that no queue of checking requests is built up while the user is
+   still entering the path, and that always the most recently entered path is checked as
+   soon as the thread becomes available.
+*/
+class FreespaceChecker : public QObject
+{
+    Q_OBJECT
+
+public:
+    FreespaceChecker(Intro *intro);
+
+    enum Status {
+        ST_OK,
+        ST_ERROR
+    };
+
+public slots:
+    void check();
+
+signals:
+    void reply(int status, const QString &message, quint64 available);
+
+private:
+    Intro *intro;
+};
+
+#include "intro.moc"
+
+FreespaceChecker::FreespaceChecker(Intro *intro)
+{
+    this->intro = intro;
+}
+
+void FreespaceChecker::check()
+{
+    namespace fs = boost::filesystem;
+    QString dataDirStr = intro->getPathToCheck();
+    fs::path dataDir = GUIUtil::qstringToBoostPath(dataDirStr);
+    uint64_t freeBytesAvailable = 0;
+    int replyStatus = ST_OK;
+    QString replyMessage = tr("A new data directory will be created.");
+
+    /* Find first parent that exists, so that fs::space does not fail */
+    fs::path parentDir = dataDir;
+    fs::path parentDirOld = fs::path();
+    while(parentDir.has_parent_path() && !fs::exists(parentDir))
+    {
+        parentDir = parentDir.parent_path();
+
+        /* Check if we make any progress, break if not to prevent an infinite loop here */
+        if (parentDirOld == parentDir)
+            break;
+
+        parentDirOld = parentDir;
+    }
+
+    try {
+        freeBytesAvailable = fs::space(parentDir).available;
+        if(fs::exists(dataDir))
+        {
+            if(fs::is_directory(dataDir))
+            {
+                QString separator = "<code>" + QDir::toNativeSeparators("/") + tr("name") + "</code>";
+                replyStatus = ST_OK;
+                replyMessage = tr("Directory already exists. Add %1 if you intend to create a new directory here.").arg(separator);
+            } else {
+                replyStatus = ST_ERROR;
+                replyMessage = tr("Path already exists, and is not a directory.");
+            }
+        }
+    } catch(fs::filesystem_error &e)
+    {
+        /* Parent directory does not exist or is not accessible */
+        replyStatus = ST_ERROR;
+        replyMessage = tr("Cannot create data directory here.");
+    }
+    emit reply(replyStatus, replyMessage, freeBytesAvailable);
+}
+
+
+Intro::Intro(QWidget *parent) :
+    QDialog(parent),
+    ui(new Ui::Intro),
+    thread(0),
+    signalled(false)
+{
+    ui->setupUi(this);
+    ui->sizeWarningLabel->setText(ui->sizeWarningLabel->text().arg(BLOCK_CHAIN_SIZE/GB_BYTES));
+    startThread();
+}
+
+Intro::~Intro()
+{
+    delete ui;
+    /* Ensure thread is finished before it is deleted */
+    emit stopThread();
+    thread->wait();
+}
+
+QString Intro::getDataDirectory()
+{
+    return ui->dataDirectory->text();
+}
+
+void Intro::setDataDirectory(const QString &dataDir)
+{
+    ui->dataDirectory->setText(dataDir);
+    if(dataDir == getDefaultDataDirectory())
+    {
+        ui->dataDirDefault->setChecked(true);
+        ui->dataDirectory->setEnabled(false);
+        ui->ellipsisButton->setEnabled(false);
+    } else {
+        ui->dataDirCustom->setChecked(true);
+        ui->dataDirectory->setEnabled(true);
+        ui->ellipsisButton->setEnabled(true);
+    }
+}
+
+QString Intro::getDefaultDataDirectory()
+{
+    return GUIUtil::boostPathToQString(GetDefaultDataDir());
+}
+
+void Intro::pickDataDirectory()
+{
+    namespace fs = boost::filesystem;
+    QSettings settings;
+    /* If data directory provided on command line, no need to look at settings
+       or show a picking dialog */
+    if(!GetArg("-datadir", "").empty())
+        return;
+    /* 1) Default data directory for operating system */
+    QString dataDir = getDefaultDataDirectory();
+    /* 2) Allow QSettings to override default dir */
+    dataDir = settings.value("strDataDir", dataDir).toString();
+
+    if(!fs::exists(GUIUtil::qstringToBoostPath(dataDir)) || GetBoolArg("-choosedatadir", false))
+    {
+        /* If current default data directory does not exist, let the user choose one */
+        Intro intro;
+        intro.setDataDirectory(dataDir);
+        intro.setWindowIcon(QIcon(":icons/bitcoin"));
+
+        while(true)
+        {
+            if(!intro.exec())
+            {
+                /* Cancel clicked */
+                exit(0);
+            }
+            dataDir = intro.getDataDirectory();
+            try {
+                TryCreateDirectory(GUIUtil::qstringToBoostPath(dataDir));
+                break;
+            } catch(fs::filesystem_error &e) {
+                QMessageBox::critical(0, tr("Fedoracoin"),
+                    tr("Error: Specified data directory \"%1\" can not be created.").arg(dataDir));
+                /* fall through, back to choosing screen */
+            }
+        }
+
+        settings.setValue("strDataDir", dataDir);
+    }
+    /* Only override -datadir if different from the default, to make it possible to
+     * override -datadir in the bitcoin.conf file in the default data directory
+     * (to be consistent with bitcoind behavior)
+     */
+    if(dataDir != getDefaultDataDirectory())
+        SoftSetArg("-datadir", GUIUtil::qstringToBoostPath(dataDir).string()); // use OS locale for path setting
+}
+
+void Intro::setStatus(int status, const QString &message, quint64 bytesAvailable)
+{
+    switch(status)
+    {
+    case FreespaceChecker::ST_OK:
+        ui->errorMessage->setText(message);
+        ui->errorMessage->setStyleSheet("");
+        break;
+    case FreespaceChecker::ST_ERROR:
+        ui->errorMessage->setText(tr("Error") + ": " + message);
+        ui->errorMessage->setStyleSheet("QLabel { color: #800000 }");
+        break;
+    }
+    /* Indicate number of bytes available */
+    if(status == FreespaceChecker::ST_ERROR)
+    {
+        ui->freeSpace->setText("");
+    } else {
+        QString freeString = QString::number(bytesAvailable/GB_BYTES) + tr("GB of free space available");
+        if(bytesAvailable < BLOCK_CHAIN_SIZE)
+        {
+            freeString += " " + tr("(of %1GB needed)").arg(BLOCK_CHAIN_SIZE/GB_BYTES);
+            ui->freeSpace->setStyleSheet("QLabel { color: #800000 }");
+        } else {
+            ui->freeSpace->setStyleSheet("");
+        }
+        ui->freeSpace->setText(freeString + ".");
+    }
+    /* Don't allow confirm in ERROR state */
+    ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(status != FreespaceChecker::ST_ERROR);
+}
+
+void Intro::on_dataDirectory_textChanged(const QString &dataDirStr)
+{
+    /* Disable OK button until check result comes in */
+    ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
+    checkPath(dataDirStr);
+}
+
+void Intro::on_ellipsisButton_clicked()
+{
+    QString dir = QDir::toNativeSeparators(QFileDialog::getExistingDirectory(0, "Choose data directory", ui->dataDirectory->text()));
+    if(!dir.isEmpty())
+        ui->dataDirectory->setText(dir);
+}
+
+void Intro::on_dataDirDefault_clicked()
+{
+    setDataDirectory(getDefaultDataDirectory());
+}
+
+void Intro::on_dataDirCustom_clicked()
+{
+    ui->dataDirectory->setEnabled(true);
+    ui->ellipsisButton->setEnabled(true);
+}
+
+void Intro::startThread()
+{
+    thread = new QThread(this);
+    FreespaceChecker *executor = new FreespaceChecker(this);
+    executor->moveToThread(thread);
+
+    connect(executor, SIGNAL(reply(int,QString,quint64)), this, SLOT(setStatus(int,QString,quint64)));
+    connect(this, SIGNAL(requestCheck()), executor, SLOT(check()));
+    /*  make sure executor object is deleted in its own thread */
+    connect(this, SIGNAL(stopThread()), executor, SLOT(deleteLater()));
+    connect(this, SIGNAL(stopThread()), thread, SLOT(quit()));
+
+    thread->start();
+}
+
+void Intro::checkPath(const QString &dataDir)
+{
+    mutex.lock();
+    pathToCheck = dataDir;
+    if(!signalled)
+    {
+        signalled = true;
+        emit requestCheck();
+    }
+    mutex.unlock();
+}
+
+QString Intro::getPathToCheck()
+{
+    QString retval;
+    mutex.lock();
+    retval = pathToCheck;
+    signalled = false; /* new request can be queued now */
+    mutex.unlock();
+    return retval;
+}
diff --git a/code/train/C++/0072229_Window.cpp b/code/train/C++/0072229_Window.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fdbe4c2635e6c2e365afe18141a5876dd0469cbf
--- /dev/null
+++ b/code/train/C++/0072229_Window.cpp
@@ -0,0 +1,279 @@
+#include "Window.h"
+#include "GameEngineErrors.h"
+#include <iostream>
+
+namespace GameEngine
+{
+		Window::Window()
+		{
+		}
+
+
+		Window::~Window()
+		{
+		}
+
+		int Window::Create(const std::string& _windowName, int _screenWidth, int _screenHeight, const WindowCreationFlags& _windowFlags)
+		{
+				Uint32 flags = SDL_WINDOW_OPENGL; //base needed flag
+				m_screenWidth = _screenWidth;
+				m_screenHeight = _screenHeight;
+				//if any of the bitwise operations aren't 0, then it's true
+				if (!_windowFlags == WindowCreationFlags::NONE)
+				{
+						if (_windowFlags & WindowCreationFlags::INVISIBLE)
+						{
+								flags |= SDL_WINDOW_HIDDEN;
+						}
+						if (_windowFlags & WindowCreationFlags::FULLSCREEN)
+						{
+								flags |= SDL_WINDOW_FULLSCREEN;
+						}
+						if (_windowFlags & WindowCreationFlags::BORDERLESS)
+						{
+								flags |= SDL_WINDOW_BORDERLESS;
+						}
+						if (_windowFlags & WindowCreationFlags::FULLSCREEN_DESKTOP)
+						{
+								flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
+						}
+						if (_windowFlags & WindowCreationFlags::INPUT_GRABBED)
+						{
+								flags |= SDL_WINDOW_INPUT_GRABBED;
+						}
+						if (_windowFlags & WindowCreationFlags::MAXIMIZED)
+						{
+								flags |= SDL_WINDOW_MAXIMIZED;
+						}
+						if (_windowFlags & WindowCreationFlags::MINIMIZED)
+						{
+								flags |= SDL_WINDOW_MINIMIZED;
+						}
+						if (_windowFlags & WindowCreationFlags::RESIZABLE)
+						{
+								flags |= SDL_WINDOW_RESIZABLE;
+						}
+				}
+				//Create an SDL window
+				m_sdlWindow = SDL_CreateWindow(_windowName.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, _screenWidth, _screenHeight, flags);
+
+				if (m_sdlWindow == nullptr)
+				{
+						FatalError("SDL Window could not be created! ");
+				}
+
+				m_mouseFocus = true;
+				m_keyboardFocus = true;
+
+				InitGL();
+
+				return 0; //Success!
+		}
+		void Window::Close()
+		{
+				SDL_GL_DeleteContext(m_glContext);
+				SDL_DestroyWindow(m_sdlWindow);
+				SDL_Quit();
+		}
+		void Window::HandleEvent(SDL_Event & _event)
+		{
+				switch (_event.window.event)
+				{
+						case SDL_WINDOWEVENT_SHOWN:
+						{
+								//window is shown
+								break;
+						}
+						case SDL_WINDOWEVENT_HIDDEN:
+						{
+								//window is hidden
+								break;
+						}
+						case SDL_WINDOWEVENT_EXPOSED:
+						{
+								//the window is visible again, make it render !
+								break;
+						}
+						case SDL_WINDOWEVENT_MOVED:
+						{
+								//window has been moved
+								break;
+						}
+						case SDL_WINDOWEVENT_RESIZED:
+						{
+								//window has been resized
+								m_screenWidth = _event.window.data1;
+								m_screenHeight = _event.window.data2;
+								glViewport(0, 0, m_screenWidth, m_screenHeight);
+								m_wasResized = true;
+								break;
+						}
+						case SDL_WINDOWEVENT_SIZE_CHANGED:
+						{
+								//window's size has changed
+								m_screenWidth = _event.window.data1;
+								m_screenHeight = _event.window.data2;
+								glViewport(0, 0, m_screenWidth, m_screenHeight);
+								m_wasResized = true;
+								break;
+						}
+						case SDL_WINDOWEVENT_MINIMIZED:
+						{
+								//window was minimized
+								m_minimized = true;
+								break;
+						}
+						case SDL_WINDOWEVENT_MAXIMIZED:
+						{
+								//window was maximized
+								m_minimized = false;
+								break;
+						}
+						case SDL_WINDOWEVENT_RESTORED:
+						{
+								//window has been restored
+								m_minimized = false;
+								break;
+						}
+						case SDL_WINDOWEVENT_ENTER:
+						{
+								//mouse entered the window
+								m_mouseFocus = true;
+								break;
+						}
+						case SDL_WINDOWEVENT_LEAVE:
+						{
+								//mouse left the window
+								m_mouseFocus = false;
+								break;
+						}
+						case SDL_WINDOWEVENT_FOCUS_GAINED:
+						{
+								//window gained keyboard access/focus
+								m_keyboardFocus = true;
+								break;
+						}
+						case SDL_WINDOWEVENT_FOCUS_LOST:
+						{
+								//window lost keyboard access/focus
+								m_keyboardFocus = false;
+								break;
+						}
+						case SDL_WINDOWEVENT_CLOSE:
+						{
+								//window has been closed
+								break;
+						}
+#if SDL_VERSION_ATLEAST(2, 0, 5)
+						case SDL_WINDOWEVENT_TAKE_FOCUS:
+						{
+								//window has been offered a focus
+								std::cout << "SDL_WINDOWEVENT_TAKE_FOCUS" << std::endl;
+								break;
+						}
+						case SDL_WINDOWEVENT_HIT_TEST:
+						{
+								//window has a special hit test
+								std::cout << "SDL_WINDOWEVENT_HIT_TEST" << std::endl;
+								break;
+						}
+#endif
+						default:
+						{
+								//IMPOSSIBLE!
+								break;
+						}
+				}
+		}
+		void Window::SwapBuffer()
+		{
+				SDL_GL_SwapWindow(m_sdlWindow);
+		}
+		void Window::ChangeFullscreenState(const FullscreenState& _flags)
+		{
+				Uint32 screenType;
+
+				//if any of the bitwise operations aren't 0, then it's true
+				if (_flags == FullscreenState::FULLSCREEN)
+				{
+						screenType = SDL_WINDOW_FULLSCREEN_DESKTOP;
+						m_fullscreen = true;
+				}
+				else if (_flags == FullscreenState::BORDERLESS)
+				{
+						screenType = SDL_WINDOW_FULLSCREEN_DESKTOP;
+						m_fullscreen = false;
+				}
+				else if (_flags == FullscreenState::WINDOWED)
+				{
+						screenType = 0;
+						m_fullscreen = false;
+				}
+
+				SDL_SetWindowFullscreen(m_sdlWindow, screenType);
+				SDL_GetWindowSize(m_sdlWindow, &m_screenWidth, &m_screenHeight);
+				glViewport(0, 0, m_screenWidth, m_screenHeight);
+				m_wasResized = true;
+		}
+
+		void Window::InitGL()
+		{
+				//Set up our OpenGL context
+				m_glContext = SDL_GL_CreateContext(m_sdlWindow);
+				if (m_glContext == nullptr)
+				{
+						FatalError("SDL_GL context could not be created!");
+				}
+
+				//Set up glew
+				GLenum error = glewInit();
+				if (error != GLEW_OK)
+				{
+						FatalError("Could not initialize Glew!");
+				}
+
+				//check the openGL version
+				std::cout << "INFO: Using GLEW " << glewGetString(GLEW_VERSION) << std::endl;
+
+				std::cout << "INFO: OpenGL Vendor: " << glGetString(GL_VENDOR) << std::endl;
+				std::cout << "INFO: OpenGL Renderer: " << glGetString(GL_RENDERER) << std::endl;
+				std::cout << "INFO: OpenGL Version: " << glGetString(GL_VERSION) << std::endl;
+				std::cout << "INFO: OpenGL Shading Language Version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
+
+				//Set the background color to black
+				glClearColor(0.0f, 0.0f, 0.0f, 1.0);
+
+				//set vsync
+				SDL_GL_SetSwapInterval(0);
+
+				//Enable alpha blending
+				glEnable(GL_BLEND);
+				glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+				//Enable face culling
+				glEnable(GL_CULL_FACE);
+				glFrontFace(GL_CCW);
+				glCullFace(GL_BACK);
+
+				//Enable depth testing
+				glEnable(GL_DEPTH_TEST);
+				glDepthFunc(GL_LESS);
+
+				//Enable multisampling
+				glEnable(GL_MULTISAMPLE);
+
+				//Enable gamma correction
+				//glEnable(GL_FRAMEBUFFER_SRGB);
+
+				//Enable stencil testing
+				//glEnable(GL_STENCIL_TEST);
+				//glStencilFunc(GL_NOTEQUAL, 1, 0xFF);
+				//glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
+				//glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_REPLACE);
+				//glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_KEEP);
+
+				// Enable depth clamping
+				// glEnable(GL_DEPTH_CLAMP);
+		}
+}
+
diff --git a/code/train/C++/0072644_MaximumSubarray.cpp b/code/train/C++/0072644_MaximumSubarray.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8d2ea3da46a0c2d0ed8043108820de0d4c18e511
--- /dev/null
+++ b/code/train/C++/0072644_MaximumSubarray.cpp
@@ -0,0 +1,36 @@
+
+/**Find the contiguous subarray within an array (containing at least one number)
+ * which has the largest sum.
+ For example, given the array [−2,1,−3,4,−1,2,1,−5,4],
+ the contiguous subarray [4,−1,2,1] has the largest sum = 6.
+ * Created by Eugene on 12/6/2015.
+ */
+class Solution {
+public:
+    int maxSubArray(vector<int>& nums) {
+        int global = nums[0];
+        int local = nums[0];
+        for (int i = 1; i < nums.size(); ++i) {
+            local = max(nums[i], local+nums[i]);
+            global = max(local, global);
+        }
+        return global;
+    }
+};
+
+//public class MaximumSubarray {
+//
+//    public int maxSubArray(int[] nums) {
+//        if (nums == null || nums.length == 0) return 0;
+//        int len = nums.length;
+//        int local = nums[0];
+//        int global = nums[0];
+//        for (int k = 1; k < len; k++){
+//            //TODO 注意不是Math.max(local+nums[k], local); 若local+nums[k]<nums[k]"应该"直接抛弃k前面的所有数
+//            local = Math.max(local+nums[k], nums[k]);
+//            global = Math.max(local, global);
+//        }
+//        return global;
+//    }
+//
+//}
diff --git a/code/train/C++/0073224_qnavigatorwidget.cpp b/code/train/C++/0073224_qnavigatorwidget.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d818554cb1bd86fc30791100e562d63d07581ccb
--- /dev/null
+++ b/code/train/C++/0073224_qnavigatorwidget.cpp
@@ -0,0 +1,126 @@
+#include "qnavigatorwidget.h"
+#include <stdio.h>
+using namespace GMapping;
+
+
+QNavigatorWidget::QNavigatorWidget( QWidget * parent, const char * name, WFlags f)
+: QMapPainter(parent, name, f), dumper("navigator", 1){
+	robotPose=IntPoint(0,0);
+	robotHeading=0;
+	confirmLocalization=false;
+	repositionRobot=false;
+	startWalker=false;
+	enableMotion=false;
+	goHome=false;
+	trajectorySent=false;
+	writeImages=false;
+	drawRobot=true;
+	wantsQuit=false;
+}
+
+QNavigatorWidget::~QNavigatorWidget(){}
+
+
+void QNavigatorWidget::mousePressEvent ( QMouseEvent * e ){
+	QPoint p=e->pos();
+	int mx=p.x();
+	int my=height()-p.y();
+	if (!(e->state()&Qt::ShiftButton) && e->button()==Qt::LeftButton) {
+		if (trajectorySent)
+			trajectoryPoints.clear();
+		e->accept();
+		IntPoint p=IntPoint(mx, my);
+		trajectoryPoints.push_back(p);
+		trajectorySent=false;
+	} 
+	if (e->state()&Qt::ControlButton && e->button()==Qt::LeftButton){
+		e->accept();
+		robotPose=IntPoint(mx, my);
+		repositionRobot=true;
+		confirmLocalization=true;
+	}
+	if (e->state()&Qt::ControlButton && e->button()==Qt::RightButton){
+		e->accept();
+		IntPoint p(mx, my);
+		p=p-robotPose;
+		robotHeading=atan2(p.y, p.x);
+		repositionRobot=true;
+		confirmLocalization=true;
+	}
+}
+
+void QNavigatorWidget::keyPressEvent ( QKeyEvent * e ){
+	if (e->key()==Qt::Key_Delete){
+		e->accept();
+		if (!trajectoryPoints.empty())
+			trajectoryPoints.pop_back();
+	}
+	if (e->key()==Qt::Key_S){
+		e->accept();
+		enableMotion=!enableMotion;
+	}
+	if (e->key()==Qt::Key_W){
+		e->accept();
+		startWalker=!startWalker;
+	}
+	if (e->key()==Qt::Key_G){
+		e->accept();
+		startGlobalLocalization=true;
+	}
+	if (e->key()==Qt::Key_T){
+		e->accept();
+		trajectorySent=true;
+	}
+	if (e->key()==Qt::Key_R){
+		e->accept();
+		goHome=true;
+	}	
+	if (e->key()==Qt::Key_C){
+		e->accept();
+		confirmLocalization=true;
+		
+	}
+	if (e->key()==Qt::Key_Q){
+		e->accept();
+		wantsQuit=true;
+		
+	}
+	if (e->key()==Qt::Key_D){
+		e->accept();
+		drawRobot=!drawRobot;;
+		
+	}
+}
+
+void QNavigatorWidget::paintEvent ( QPaintEvent * ){
+	QPixmap pixmap(*m_pixmap);
+	QPainter painter(&pixmap);
+	if (trajectorySent)
+	painter.setPen(Qt::red);
+	bool first=true;
+	int oldx=0, oldy=0;
+	//paint the path
+	for (std::list<IntPoint>::const_iterator it=trajectoryPoints.begin(); it!=trajectoryPoints.end(); it++){
+		int x=it->x;
+		int y=height()-it->y;
+		if (! first)
+			painter.drawLine(oldx, oldy, x,y);
+		oldx=x;
+		oldy=y;
+		first=false;
+	}
+	//paint the robot
+	if (drawRobot){
+		painter.setPen(Qt::black);
+		int rx=robotPose.x;
+		int ry=height()-robotPose.y;
+		int robotSize=6;
+		painter.drawLine(rx, ry, 
+				rx+(int)(robotSize*cos(robotHeading)), ry-(int)(robotSize*sin(robotHeading)));
+		painter.drawEllipse(rx-robotSize, ry-robotSize, 2*robotSize, 2*robotSize);
+	}
+	if (writeImages){
+		dumper.dump(pixmap);
+	}
+	bitBlt(this,0,0,&pixmap,0,0,pixmap.width(),pixmap.height(),CopyROP);
+}
diff --git a/code/train/C++/0073712_TimerTable.cc b/code/train/C++/0073712_TimerTable.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4809c8a476db346cf699c11f17353984d0ec57d0
--- /dev/null
+++ b/code/train/C++/0073712_TimerTable.cc
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
+ * All rights reserved.
+ *
+ * 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 copyright holders 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.
+ */
+
+#include "mem/ruby/structures/TimerTable.hh"
+
+#include "mem/ruby/system/RubySystem.hh"
+
+TimerTable::TimerTable()
+    : m_next_time(0)
+{
+    m_consumer_ptr  = NULL;
+    m_next_valid = false;
+    m_next_address = 0;
+}
+
+bool
+TimerTable::isReady(Tick curTime) const
+{
+    if (m_map.empty())
+        return false;
+
+    if (!m_next_valid) {
+        updateNext();
+    }
+    assert(m_next_valid);
+    return (curTime >= m_next_time);
+}
+
+Addr
+TimerTable::nextAddress() const
+{
+    if (!m_next_valid) {
+        updateNext();
+    }
+    assert(m_next_valid);
+    return m_next_address;
+}
+
+void
+TimerTable::set(Addr address, Tick ready_time)
+{
+    assert(address == makeLineAddress(address));
+    assert(!m_map.count(address));
+
+    m_map[address] = ready_time;
+    assert(m_consumer_ptr != NULL);
+    m_consumer_ptr->scheduleEventAbsolute(ready_time);
+    m_next_valid = false;
+
+    // Don't always recalculate the next ready address
+    if (ready_time <= m_next_time) {
+        m_next_valid = false;
+    }
+}
+
+void
+TimerTable::unset(Addr address)
+{
+    assert(address == makeLineAddress(address));
+    assert(m_map.count(address));
+    m_map.erase(address);
+
+    // Don't always recalculate the next ready address
+    if (address == m_next_address) {
+        m_next_valid = false;
+    }
+}
+
+void
+TimerTable::print(std::ostream& out) const
+{
+}
+
+void
+TimerTable::updateNext() const
+{
+    if (m_map.empty()) {
+        assert(!m_next_valid);
+        return;
+    }
+
+    AddressMap::const_iterator i = m_map.begin();
+    AddressMap::const_iterator end = m_map.end();
+
+    m_next_address = i->first;
+    m_next_time = i->second;
+    ++i;
+
+    for (; i != end; ++i) {
+        if (i->second < m_next_time) {
+            m_next_address = i->first;
+            m_next_time = i->second;
+        }
+    }
+
+    m_next_valid = true;
+}
diff --git a/code/train/C++/0073837_q3membuf.cpp b/code/train/C++/0073837_q3membuf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e9e4a3a99540fd75c5bad3b8c13fe89ee4bf059f
--- /dev/null
+++ b/code/train/C++/0073837_q3membuf.cpp
@@ -0,0 +1,171 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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, Nokia gives you certain additional
+** rights. These rights are described in the Nokia 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.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "q3membuf_p.h"
+
+QT_BEGIN_NAMESPACE
+
+// *******************************************************************
+// QMembuf declaration and implementation
+// *******************************************************************
+
+/*  \internal
+    This class implements an efficient buffering of data that is often used by
+    asynchronous IO classes like QSocket, QHttp and QProcess.
+*/
+
+Q3Membuf::Q3Membuf() : _size(0), _index(0)
+{
+}
+
+Q3Membuf::~Q3Membuf()
+{
+    while (!buf.isEmpty())
+        delete buf.takeFirst();
+}
+
+/*! \internal
+    This function consumes \a nbytes bytes of data from the
+    buffer and copies it into \a sink. If \a sink is a 0 pointer
+    the data goes into the nirvana.
+*/
+bool Q3Membuf::consumeBytes(Q_ULONG nbytes, char *sink)
+{
+    if (nbytes <= 0 || (qint64)nbytes > _size)
+        return false;
+    _size -= nbytes;
+    while (!buf.isEmpty()) {
+        QByteArray *a = buf.first();
+        if ((int)(_index + nbytes) >= a->size()) {
+            // Here we skip the whole byte array and get the next later
+            int len = a->size() - _index;
+            if (sink) {
+                memcpy(sink, a->constData()+_index, len);
+                sink += len;
+            }
+            nbytes -= len;
+            buf.removeFirst();
+	    delete a;
+            _index = 0;
+            if (nbytes == 0)
+                break;
+        } else {
+            // Here we skip only a part of the first byte array
+            if (sink)
+                memcpy(sink, a->constData()+_index, nbytes);
+            _index += nbytes;
+            break;
+        }
+    }
+    return true;
+}
+
+/*! \internal
+    Scans for any occurrence of '\n' in the buffer. If \a store
+    is not 0 the text up to the first '\n' (or terminating 0) is
+    written to \a store, and a terminating 0 is appended to \a store
+    if necessary. Returns true if a '\n' was found; otherwise returns
+    false.
+*/
+bool Q3Membuf::scanNewline(QByteArray *store)
+{
+    if (_size == 0)
+        return false;
+    int i = 0; // index into 'store'
+    QByteArray *a = 0;
+    char *p;
+    int n;
+    bool retval = false;
+    for (int j = 0; j < buf.size(); ++j) {
+        a = buf.at(j);
+        p = a->data();
+        n = a->size();
+        if (!j) {
+            // first buffer
+            p += _index;
+            n -= _index;
+        }
+        if (store) {
+            while (n-- > 0) {
+                *(store->data()+i) = *p;
+                if (++i == (int)store->size())
+                    store->resize(store->size() < 256
+                                   ? 1024 : store->size()*4);
+                if (*p == '\n') {
+                    retval = true;
+                    goto end;
+                }
+                p++;
+            }
+        } else {
+            while (n-- > 0) {
+                if(*p == '\n')
+                    return true;
+                p++;
+            }
+        }
+    }
+ end:
+    if (store)
+        store->resize(i);
+    return retval;
+}
+
+int Q3Membuf::ungetch(int ch)
+{
+    if (buf.isEmpty() || _index==0) {
+        // we need a new QByteArray
+        QByteArray *ba = new QByteArray;
+        ba->resize(1);
+        buf.prepend(ba);
+        _size++;
+        (*ba)[0] = ch;
+    } else {
+        // we can reuse a place in the buffer
+        QByteArray *ba = buf.first();
+        _index--;
+        _size++;
+        (*ba)[(int)_index] = ch;
+    }
+    return ch;
+}
+
+QT_END_NAMESPACE
diff --git a/code/train/C++/0074177_EdgeIntersectionList.cpp b/code/train/C++/0074177_EdgeIntersectionList.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..17f0949449e9d700ad908929e1903179e639dfc4
--- /dev/null
+++ b/code/train/C++/0074177_EdgeIntersectionList.cpp
@@ -0,0 +1,254 @@
+/**********************************************************************
+ * $Id$
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.refractions.net
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Public Licence as published
+ * by the Free Software Foundation. 
+ * See the COPYING file for more information.
+ *
+ **********************************************************************/
+
+#include <geos/geomgraph.h>
+
+#ifndef DEBUG
+#define DEBUG 0
+#endif
+
+namespace geos {
+
+EdgeIntersectionList::EdgeIntersectionList(Edge *newEdge)
+{
+	list=new vector<EdgeIntersection*>();
+	edge=newEdge;
+}
+
+EdgeIntersectionList::~EdgeIntersectionList()
+{
+//	delete edge;
+	for(int i=0;i<(int)list->size();i++) {
+		delete (*list)[i];
+	}
+	delete list;
+}
+
+EdgeIntersection*
+EdgeIntersectionList::add(const Coordinate& coord, int segmentIndex, double dist)
+{
+#if DEBUG
+	cerr<<"["<<this<<"] EdgeIntersectionList::add("<<coord.toString()<<","<<segmentIndex<<","<<dist<<")"<<endl;
+#endif // DEBUG
+	vector<EdgeIntersection *>::iterator insertIt=list->begin();
+	bool isInList=findInsertionPoint(segmentIndex,dist,&insertIt);
+	EdgeIntersection *ei;
+	if (!isInList)
+	{
+#if DEBUG
+		cerr<<"  intersection not in list"<<endl;
+#endif // DEBUG
+		ei=new EdgeIntersection(coord,segmentIndex,dist);
+		list->insert(insertIt,ei);
+	}
+	else
+	{
+		ei=*insertIt;
+#if DEBUG
+		cerr<<"  intersection already in list (should merge z)"<<endl;
+		cerr<<"  current: "<<ei->coord.toString()<<endl;
+		cerr<<"  intersection: "<<coord.toString()<<endl;
+#endif // DEBUG
+	}
+	return ei;
+}
+
+vector<EdgeIntersection*>::iterator
+EdgeIntersectionList::iterator()
+{
+	return list->begin();
+}
+
+bool
+EdgeIntersectionList::isEmpty()
+{
+	return list->empty();
+}
+
+bool
+EdgeIntersectionList::findInsertionPoint(int segmentIndex, double dist,vector<EdgeIntersection*>::iterator *insertIt)
+{
+	vector<EdgeIntersection *>::iterator findIt=list->begin();
+	//bool found=false;
+	while(findIt<list->end()) {
+		EdgeIntersection *ei=*findIt;
+		findIt++;
+		int compare=ei->compare(segmentIndex, dist);
+		// intersection found - insertIt.next() will retrieve it
+		if (compare==0) return true;
+		// this ei is past the intersection location, so intersection was not found
+		if (compare>0) return false;
+		// this ei was before the intersection point, so move to next
+		(*insertIt)++;
+	}
+	return false;
+}
+
+bool
+EdgeIntersectionList::isIntersection(const Coordinate& pt)
+{
+	vector<EdgeIntersection *>::iterator it;
+	for (it=list->begin();it<list->end();it++) {
+		EdgeIntersection *ei=*it;
+		if (ei->coord==pt)
+			return true;
+	}
+	return false;
+}
+
+void
+EdgeIntersectionList::addEndpoints()
+{
+	int maxSegIndex=edge->pts->getSize()-1;
+	add(edge->pts->getAt(0), 0, 0.0);
+	add(edge->pts->getAt(maxSegIndex), maxSegIndex, 0.0);
+}
+
+void
+EdgeIntersectionList::addSplitEdges(vector<Edge*> *edgeList)
+{
+	// ensure that the list has entries for the first and last point
+	// of the edge
+	addEndpoints();
+	vector<EdgeIntersection *>::iterator it=list->begin();
+	// there should always be at least two entries in the list
+	EdgeIntersection *eiPrev=*it;
+	it++;
+	while (it<list->end()) {
+		EdgeIntersection *ei=*it;
+		Edge *newEdge=createSplitEdge(eiPrev,ei);
+		edgeList->push_back(newEdge);
+		eiPrev=ei;
+		it++;
+	}
+}
+
+Edge*
+EdgeIntersectionList::createSplitEdge(EdgeIntersection *ei0, EdgeIntersection *ei1)
+{
+#if DEBUG
+	cerr<<"["<<this<<"] EdgeIntersectionList::createSplitEdge()"<<endl;
+#endif // DEBUG
+	int npts=ei1->segmentIndex-ei0->segmentIndex+2;
+#if DEBUG
+	cerr<<"    npts:"<<npts<<endl;
+#endif // DEBUG
+
+	const Coordinate& lastSegStartPt=edge->pts->getAt(ei1->segmentIndex);
+
+	// if the last intersection point is not equal to the its segment
+	// start pt, add it to the points list as well.
+	// (This check is needed because the distance metric is not totally
+	// reliable!). The check for point equality is 2D only - Z values
+	// are ignored
+	bool useIntPt1=ei1->dist>0.0 || !ei1->coord.equals2D(lastSegStartPt);
+	if (!useIntPt1) {
+		npts--;
+#if DEBUG
+		cerr<<"    !useIntPt1 (npts:"<<npts<<")"<<endl;
+#endif // DEBUG
+	}
+	CoordinateSequence* pts=new DefaultCoordinateSequence(npts);
+	int ipt=0;
+	//Coordinate *c=new Coordinate(ei0->coord);
+	//pts->setAt(*c,ipt++);
+	//delete c;
+	pts->setAt(ei0->coord,ipt++);
+#if DEBUG
+	cerr<<"    pt"<<(ipt-1)<<": "<<pts->getAt(ipt-1).toString()<<endl;
+#endif // DEBUG
+	for(int i=ei0->segmentIndex+1; i<=ei1->segmentIndex;i++)
+	{
+		if ( ! useIntPt1 && ei1->segmentIndex == i )
+		{
+			pts->setAt(ei1->coord, ipt++);
+		}
+		else
+		{
+			pts->setAt(edge->pts->getAt(i),ipt++);
+		}
+#if DEBUG
+		cerr<<"    pt"<<(ipt-1)<<": "<<pts->getAt(ipt-1).toString()<<endl;
+#endif // DEBUG
+	}
+	if (useIntPt1)
+	{
+		pts->setAt(ei1->coord,ipt);
+#if DEBUG
+		cerr<<"    ustIntPt1: pt"<<(ipt-1)<<": "<<pts->getAt(ipt-1).toString()<<endl;
+#endif // DEBUG
+	}
+	return new Edge(pts, new Label(edge->getLabel()));
+}
+
+string
+EdgeIntersectionList::print()
+{
+	string out="Intersections: ";
+	vector<EdgeIntersection *>::iterator it;
+	for (it=list->begin();it<list->end();it++) {
+		EdgeIntersection *ei=*it;
+		out+=ei->print();
+	}
+	return out;
+}
+
+} // namespace
+
+/**********************************************************************
+ * $Log$
+ * Revision 1.10  2004/12/08 13:54:43  strk
+ * gcc warnings checked and fixed, general cleanups.
+ *
+ * Revision 1.9  2004/11/23 19:53:06  strk
+ * Had LineIntersector compute Z by interpolation.
+ *
+ * Revision 1.8  2004/11/22 13:02:12  strk
+ * Forced use if computed intersection point in ::createSplitEdge (for Z computation)
+ *
+ * Revision 1.7  2004/11/17 08:13:16  strk
+ * Indentation changes.
+ * Some Z_COMPUTATION activated by default.
+ *
+ * Revision 1.6  2004/11/04 19:08:06  strk
+ * Cleanups, initializers list, profiling.
+ *
+ * Revision 1.5  2004/10/21 22:29:54  strk
+ * Indentation changes and some more COMPUTE_Z rules
+ *
+ * Revision 1.4  2004/10/20 17:32:14  strk
+ * Initial approach to 2.5d intersection()
+ *
+ * Revision 1.3  2004/07/08 19:34:49  strk
+ * Mirrored JTS interface of CoordinateSequence, factory and
+ * default implementations.
+ * Added DefaultCoordinateSequenceFactory::instance() function.
+ *
+ * Revision 1.2  2004/07/02 13:28:26  strk
+ * Fixed all #include lines to reflect headers layout change.
+ * Added client application build tips in README.
+ *
+ * Revision 1.1  2004/03/19 09:48:45  ybychkov
+ * "geomgraph" and "geomgraph/indexl" upgraded to JTS 1.4
+ *
+ * Revision 1.18  2003/11/07 01:23:42  pramsey
+ * Add standard CVS headers licence notices and copyrights to all cpp and h
+ * files.
+ *
+ * Revision 1.17  2003/11/06 19:04:28  strk
+ * removed useless Coordinate copy in ::createSplitEdge()
+ *
+ **********************************************************************/
+
diff --git a/code/train/C++/0075443_solve.cpp b/code/train/C++/0075443_solve.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..287c0982568a507050dd961207bbf8988edea282
--- /dev/null
+++ b/code/train/C++/0075443_solve.cpp
@@ -0,0 +1,53 @@
+#include <cstdio>
+#include <iostream>
+#include <cstdlib>
+#include <vector>
+#include <algorithm>
+using namespace std;
+static inline void print(const vector<int> &v)
+{
+	for_each(v.begin(), v.end(), [](int i){cout << i << " ";});
+	cout << endl;
+}
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+	    int n = prices.size();
+	    if (n <= 1)
+		    return 0;
+	    vector<int> leftMin(n, 0);
+	    leftMin[0] = prices[0];
+	    for (int i = 1; i < n; ++i) {
+		    leftMin[i] = min(leftMin[i - 1], prices[i]);
+	    }
+	    vector<int> rightMax(n, 0);
+	    rightMax[0] = prices[n - 1];
+	    for (int i = n - 2, k = 1; i >=0; --i, k++)
+		    rightMax[k] = max(rightMax[k - 1], prices[i]);
+	    int left = 0, right = 0;
+	    int profit = 0;
+	    for (int i = 0; i < n; ++i) {
+		    left = max(left, prices[i] - leftMin[i]);
+		    right = rightMax[n - i - 1] - prices[i];
+		    profit = max(profit, left + right);
+	    }
+	    return profit;
+    }
+};
+int main(int argc, char **argv)
+{
+	Solution solution;
+	vector<int> prices;
+	int n;
+	while(scanf("%d", &n) != EOF) {
+		prices.clear();
+		for (int i = 0; i < n; ++i) {
+			int v;
+			scanf("%d", &v);
+			prices.push_back(v);
+		}
+		printf("maxProfit = %d\n", solution.maxProfit(prices));
+	}
+	return 0;
+
+}
diff --git a/code/train/C++/0076246_car.cpp b/code/train/C++/0076246_car.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..69463b9390015307f4385023038456e011ae5b03
--- /dev/null
+++ b/code/train/C++/0076246_car.cpp
@@ -0,0 +1,137 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** 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 Nokia Corporation and its Subsidiary(-ies) 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 "car.h"
+#include <QtGui/QtGui>
+#include <math.h>
+
+static const double Pi = 3.14159265358979323846264338327950288419717;
+
+QRectF Car::boundingRect() const
+{
+    return QRectF(-35, -81, 70, 115);
+}
+
+Car::Car() : color(Qt::green), wheelsAngle(0), speed(0)
+{
+    startTimer(1000 / 33);
+    setFlag(QGraphicsItem::ItemIsMovable, true);
+    setFlag(QGraphicsItem::ItemIsFocusable, true);
+}
+
+void Car::accelerate()
+{
+    if (speed < 10)
+        ++speed;
+}
+
+void Car::decelerate()
+{
+    if (speed > -10)
+        --speed;
+}
+
+void Car::turnLeft()
+{
+    if (wheelsAngle > -30)
+        wheelsAngle -= 5;
+}
+
+void Car::turnRight()
+{
+    if (wheelsAngle < 30)
+       wheelsAngle += 5;
+}
+
+void Car::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+{
+    Q_UNUSED(option);
+    Q_UNUSED(widget);
+
+    painter->setBrush(Qt::gray);
+    painter->drawRect(-20, -58, 40, 2); // front axel
+    painter->drawRect(-20, 7, 40, 2); // rear axel
+
+    painter->setBrush(color);
+    painter->drawRect(-25, -79, 50, 10); // front wing
+
+    painter->drawEllipse(-25, -48, 50, 20); // side pods
+    painter->drawRect(-25, -38, 50, 35); // side pods
+    painter->drawRect(-5, 9, 10, 10); // back pod
+
+    painter->drawEllipse(-10, -81, 20, 100); // main body
+
+    painter->drawRect(-17, 19, 34, 15); // rear wing
+
+    painter->setBrush(Qt::black);
+    painter->drawPie(-5, -51, 10, 15, 0, 180 * 16);
+    painter->drawRect(-5, -44, 10, 10); // cocpit
+
+    painter->save();
+    painter->translate(-20, -58);
+    painter->rotate(wheelsAngle);
+    painter->drawRect(-10, -7, 10, 15); // front left
+    painter->restore();
+
+    painter->save();
+    painter->translate(20, -58);
+    painter->rotate(wheelsAngle);
+    painter->drawRect(0, -7, 10, 15); // front left
+    painter->restore();
+
+    painter->drawRect(-30, 0, 12, 17); // rear left
+    painter->drawRect(19, 0, 12, 17);  // rear right
+}
+
+void Car::timerEvent(QTimerEvent *event)
+{
+    Q_UNUSED(event);
+
+    const qreal axelDistance = 54;
+    qreal wheelsAngleRads = (wheelsAngle * Pi) / 180;
+    qreal turnDistance = ::cos(wheelsAngleRads) * axelDistance * 2;
+    qreal turnRateRads = wheelsAngleRads / turnDistance;  // rough estimate
+    qreal turnRate = (turnRateRads * 180) / Pi;
+    qreal rotation = speed * turnRate;
+    
+    rotate(rotation);
+    translate(0, -speed);
+    update();
+}
diff --git a/code/train/C++/0076870_batch_seq_config_test.cc b/code/train/C++/0076870_batch_seq_config_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9217d088db0d100c66876a51c783cf658d9c91ff
--- /dev/null
+++ b/code/train/C++/0076870_batch_seq_config_test.cc
@@ -0,0 +1,219 @@
+/* Copyright 2020 The TensorFlow Authors. 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 <memory>
+#include <random>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include "absl/flags/flag.h"
+#include "absl/flags/parse.h"
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/experimental/delegates/hexagon/hexagon_delegate.h"
+#include "tensorflow/lite/interpreter.h"
+#include "tensorflow/lite/interpreter_builder.h"
+#include "tensorflow/lite/kernels/kernel_util.h"
+#include "tensorflow/lite/kernels/register.h"
+#include "tensorflow/lite/kernels/test_util.h"
+#include "tensorflow/lite/model_builder.h"
+#include "tensorflow/lite/testing/util.h"
+#include "tensorflow/lite/tools/benchmark/benchmark_utils.h"
+#include "tensorflow/lite/tools/logging.h"
+
+ABSL_FLAG(std::string, model_file_path, "", "Path to the test model file.");
+ABSL_FLAG(std::string, model_input_shapes, "",
+          "List of different input shapes for testing, the input will "
+          "resized for each one in order and tested. They Should be "
+          "separated by : and each shape has dimensions separated by ,");
+ABSL_FLAG(int, max_batch_size, -1,
+          "Maximum batch size for a single run by hexagon.");
+ABSL_FLAG(double, error_epsilon, 0.2,
+          "Maximum error allowed while diffing the output.");
+
+namespace tflite {
+namespace {
+// Returns a randomly generated data of size 'num_elements'.
+std::vector<uint8> GetData(int num_elements) {
+  std::vector<uint8> result(num_elements);
+  std::random_device random_engine;
+  std::uniform_int_distribution<uint32_t> distribution(0, 254);
+  std::generate_n(result.data(), num_elements, [&]() {
+    return static_cast<uint8>(distribution(random_engine));
+  });
+  return result;
+}
+
+// Returns the total number of elements.
+int NumElements(const std::vector<int>& shape) {
+  int num_elements = 1;
+  for (int dim : shape) num_elements *= dim;
+  return num_elements;
+}
+
+// Returns true if 'control' and 'exp' values match up to 'epsilon'
+bool DiffOutput(const std::vector<float>& control,
+                const std::vector<float>& exp, double epsilon) {
+  if (control.size() != exp.size()) {
+    TFLITE_LOG(ERROR) << "Mismatch size Expected" << control.size() << " got "
+                      << exp.size();
+    return false;
+  }
+  bool has_diff = false;
+  for (int i = 0; i < control.size(); ++i) {
+    if (abs(control[i] - exp[i]) > epsilon) {
+      TFLITE_LOG(ERROR) << control[i] << " " << exp[i];
+      has_diff = true;
+    }
+  }
+  return !has_diff;
+}
+
+bool DiffOutput(const std::vector<float>& control,
+                const std::vector<float>& exp) {
+  return DiffOutput(control, exp, absl::GetFlag(FLAGS_error_epsilon));
+}
+}  // namespace
+
+class TestModel {
+ public:
+  TestModel() : delegate_(nullptr, [](TfLiteDelegate* delegate) {}) {}
+
+  // Initialize the model by reading the model from file and build
+  // interpreter.
+  void Init() {
+    model_ = tflite::FlatBufferModel::BuildFromFile(
+        absl::GetFlag(FLAGS_model_file_path).c_str());
+    ASSERT_TRUE(model_ != nullptr);
+
+    resolver_.reset(new ops::builtin::BuiltinOpResolver());
+    InterpreterBuilder(*model_, *resolver_)(&interpreter_);
+    ASSERT_TRUE(interpreter_ != nullptr);
+  }
+
+  // Add Hexagon delegate to the graph.
+  void ApplyDelegate(int max_batch_size,
+                     const std::vector<int>& input_batch_dimensions,
+                     const std::vector<int>& output_batch_dimensions) {
+    TfLiteIntArray* input_batch_dim =
+        TfLiteIntArrayCreate(input_batch_dimensions.size());
+    TfLiteIntArray* output_batch_dim =
+        TfLiteIntArrayCreate(output_batch_dimensions.size());
+    for (int i = 0; i < input_batch_dimensions.size(); ++i)
+      input_batch_dim->data[i] = input_batch_dimensions[i];
+    for (int i = 0; i < output_batch_dimensions.size(); ++i)
+      output_batch_dim->data[i] = output_batch_dimensions[i];
+    ::TfLiteHexagonDelegateOptions options = {0};
+    options.enable_dynamic_batch_size = true;
+    options.max_batch_size = max_batch_size;
+    options.input_batch_dimensions = input_batch_dim;
+    options.output_batch_dimensions = output_batch_dim;
+    TfLiteDelegate* delegate = TfLiteHexagonDelegateCreate(&options);
+    ASSERT_TRUE(delegate != nullptr);
+    delegate_ = std::unique_ptr<TfLiteDelegate, void (*)(TfLiteDelegate*)>(
+        delegate, [](TfLiteDelegate* delegate) {
+          TfLiteHexagonDelegateDelete(delegate);
+        });
+    ASSERT_TRUE(interpreter_->ModifyGraphWithDelegate(delegate_.get()) ==
+                kTfLiteOk);
+  }
+
+  void Run(const std::vector<int>& input_shape,
+           const std::vector<uint8>& input_data) {
+    // Resize Inputs.
+    auto interpreter_inputs = interpreter_->inputs();
+    interpreter_->ResizeInputTensor(interpreter_inputs[0], input_shape);
+    ASSERT_EQ(kTfLiteOk, interpreter_->AllocateTensors());
+
+    TfLiteTensor* input_tensor =
+        interpreter_->tensor(interpreter_->inputs()[0]);
+    memcpy(input_tensor->data.raw, input_data.data(),
+           input_data.size() * sizeof(uint8));
+
+    ASSERT_EQ(kTfLiteOk, interpreter_->Invoke());
+  }
+
+  std::vector<float> GetOutput(int output_index) {
+    auto* tensor = interpreter_->output_tensor(output_index);
+    uint8* data = interpreter_->typed_output_tensor<uint8>(output_index);
+    std::vector<float> result;
+    result.resize(NumElements(tensor));
+    const auto scale =
+        reinterpret_cast<TfLiteAffineQuantization*>(tensor->quantization.params)
+            ->scale->data[0];
+    const auto zero_point =
+        reinterpret_cast<TfLiteAffineQuantization*>(tensor->quantization.params)
+            ->zero_point->data[0];
+    for (int i = 0; i < result.size(); ++i) {
+      result[i] = scale * (data[i] - zero_point);
+    }
+    return result;
+  }
+
+ private:
+  std::unique_ptr<TfLiteDelegate, void (*)(TfLiteDelegate*)> delegate_;
+  std::unique_ptr<FlatBufferModel> model_;
+  std::unique_ptr<tflite::OpResolver> resolver_;
+  std::unique_ptr<Interpreter> interpreter_;
+};
+
+std::vector<std::vector<int>> ParseInputShapes() {
+  std::vector<string> str_input_shapes;
+  benchmark::util::SplitAndParse(absl::GetFlag(FLAGS_model_input_shapes), ':',
+                                 &str_input_shapes);
+  std::vector<std::vector<int>> input_shapes(str_input_shapes.size());
+  for (int i = 0; i < str_input_shapes.size(); ++i) {
+    benchmark::util::SplitAndParse(str_input_shapes[i], ',', &input_shapes[i]);
+  }
+  return input_shapes;
+}
+
+TEST(HexagonDynamicBatch, MultipleResizes) {
+  int num_failed_tests = 0;
+  int num_test = 0;
+  auto test_input_shapes = ParseInputShapes();
+  auto default_model = std::make_unique<TestModel>();
+  auto delegated_model = std::make_unique<TestModel>();
+  default_model->Init();
+  delegated_model->Init();
+  delegated_model->ApplyDelegate(absl::GetFlag(FLAGS_max_batch_size), {0}, {0});
+  for (const auto& input_shape : test_input_shapes) {
+    const auto input = GetData(NumElements(input_shape));
+    default_model->Run(input_shape, input);
+    delegated_model->Run(input_shape, input);
+    const auto default_output = default_model->GetOutput(0);
+    const auto delegated_output = delegated_model->GetOutput(0);
+    if (!DiffOutput(default_output, delegated_output)) {
+      TFLITE_LOG(ERROR) << "Failed for input " << num_test;
+      num_failed_tests++;
+    }
+    num_test++;
+  }
+  if (num_failed_tests == 0) {
+    TFLITE_LOG(INFO) << "All Tests PASSED";
+  } else {
+    TFLITE_LOG(INFO) << "Failed " << num_failed_tests << " out of " << num_test;
+  }
+}
+}  // namespace tflite
+
+int main(int argc, char** argv) {
+  ::tflite::LogToStderr();
+  absl::ParseCommandLine(argc, argv);
+  testing::InitGoogleTest();
+
+  TfLiteHexagonInit();
+  int return_val = RUN_ALL_TESTS();
+  TfLiteHexagonTearDown();
+  return return_val;
+}
diff --git a/code/train/C++/0077413_focus_system.cpp b/code/train/C++/0077413_focus_system.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3d32dfcc545a15c5b6c8805e953ace91d610c76e
--- /dev/null
+++ b/code/train/C++/0077413_focus_system.cpp
@@ -0,0 +1,201 @@
+#include <cassert>
+#include "raycast/focus_system.hpp"
+#include "raycast/entity_manager.hpp"
+#include "raycast/spatial_system.hpp"
+#include "raycast/render_system.hpp"
+#include "raycast/time_service.hpp"
+#include "exception.hpp"
+#include "app_config.hpp"
+#include "utils.hpp"
+
+
+using std::vector;
+
+
+//===========================================
+// FocusSystem::FocusSystem
+//===========================================
+FocusSystem::FocusSystem(const AppConfig& appConfig, EntityManager& entityManager,
+  TimeService& timeService)
+  : SystemAccessor(entityManager),
+    m_appConfig(appConfig),
+    m_entityManager(entityManager),
+    m_timeService(timeService) {}
+
+//===========================================
+// FocusSystem::initialise
+//===========================================
+void FocusSystem::initialise() {
+  m_toolTipId = Component::getNextId();
+  CTextOverlay* toolTip = new CTextOverlay(m_toolTipId, "", Point(7.3, 4.8), 0.5, Qt::white, 1);
+
+  renderSys().addComponent(pComponent_t(toolTip));
+
+  m_focusDistance = spatialSys().sg.player->activationRadius;
+
+  m_initialised = true;
+}
+
+//===========================================
+// isWallDecal
+//===========================================
+static bool isWallDecal(const RenderSystem& renderSystem, const Intersection& X) {
+  if (renderSystem.hasComponent(X.entityId)) {
+    const CRender& c = renderSystem.getComponent(X.entityId);
+    return c.kind == CRenderKind::WALL_DECAL;
+  }
+
+  return false;
+}
+
+//===========================================
+// getZIndex
+//===========================================
+static int getZIndex(const RenderSystem& renderSystem, const Intersection& X) {
+  const CWallDecal& decal = DYNAMIC_CAST<const CWallDecal&>(renderSystem.getComponent(X.entityId));
+  return decal.zIndex;
+}
+
+//===========================================
+// FocusSystem::update
+//===========================================
+void FocusSystem::update() {
+  if (!m_initialised) {
+    initialise();
+  }
+
+  auto& renderSystem = renderSys();
+
+  CTextOverlay& toolTip = dynamic_cast<CTextOverlay&>(renderSystem.getComponent(m_toolTipId));
+  toolTip.text = "";
+
+  vector<pIntersection_t> intersections = spatialSys().entitiesAlong3dRay(Vec2f(1.0, 0), 0,
+    m_focusDistance);
+
+  if (intersections.size() > 0) {
+    auto first = intersections.begin();
+
+    int highestZ = -9999;
+    for (auto it = intersections.begin(); it != intersections.end(); ++it) {
+      if (!isWallDecal(renderSystem, **it)) {
+        break;
+      }
+
+      int z = getZIndex(renderSystem, **it);
+      if (z > highestZ) {
+        highestZ = z;
+        first = it;
+      }
+    }
+
+    pIntersection_t& X = *first;
+
+    auto it = m_components.find(X->entityId);
+    if (it != m_components.end()) {
+      CFocus& c = *it->second;
+
+      toolTip.text = c.hoverText;
+
+      if (c.onHover) {
+        c.onHover();
+      }
+    }
+  }
+}
+
+//===========================================
+// FocusSystem::deleteCaption
+//===========================================
+void FocusSystem::deleteCaption() {
+  m_timeService.cancelTimeout(m_captionTimeoutId);
+  m_entityManager.deleteEntity(m_captionBgId);
+  m_entityManager.deleteEntity(m_captionTextId);
+
+  m_captionBgId = -1;
+  m_captionTextId = -1;
+  m_captionTimeoutId = -1;
+}
+
+//===========================================
+// FocusSystem::showCaption
+//===========================================
+void FocusSystem::showCaption(entityId_t entityId) {
+  auto it = m_components.find(entityId);
+  if (it == m_components.end()) {
+    return;
+  }
+
+  const CFocus& c = *it->second;
+
+  deleteCaption();
+
+  auto& renderSystem = renderSys();
+
+  const Size& vp_wld = renderSystem.viewport();
+  const Size& vp_px = renderSystem.viewport_px();
+
+  double pxH = vp_wld.y / vp_px.y;
+  double pxW = vp_wld.x / vp_px.x;
+
+  double chH = 0.45;
+  double chH_px = chH / pxH;
+
+  QFont font = m_appConfig.monoFont;
+  font.setPixelSize(chH_px);
+
+  double margin = 0.2;
+
+  QFontMetrics fm(font);
+  double textW_px = fm.size(Qt::TextSingleLine, c.captionText.c_str()).width();
+  double textW = textW_px * pxW;
+
+  Size sz(2.0 * margin + textW, 2.0 * margin + chH);
+  Point bgPos(0.5 * (vp_wld.x - sz.x), 0.70 * (vp_wld.y - sz.y));
+  Point textPos = bgPos + Vec2f(margin, margin);
+
+  QColor bgColour(0, 0, 0, 120);
+  QColor textColour(210, 210, 0);
+
+  m_captionBgId = Component::getNextId();
+  m_captionTextId = Component::getNextId();
+
+  CColourOverlay* bgOverlay = new CColourOverlay(m_captionBgId, bgColour, bgPos, sz, 8);
+  CTextOverlay* textOverlay = new CTextOverlay(m_captionTextId, c.captionText, textPos, chH,
+    textColour, 9);
+
+  renderSystem.addComponent(pComponent_t(bgOverlay));
+  renderSystem.addComponent(pComponent_t(textOverlay));
+
+  m_captionTimeoutId = m_timeService.onTimeout([this]() {
+    deleteCaption();
+  }, 3.0);
+}
+
+//===========================================
+// FocusSystem::addComponent
+//===========================================
+void FocusSystem::addComponent(pComponent_t component) {
+  CFocus* ptr = dynamic_cast<CFocus*>(component.release());
+  m_components.insert(make_pair(ptr->entityId(), pCFocus_t(ptr)));
+}
+
+//===========================================
+// FocusSystem::hasComponent
+//===========================================
+bool FocusSystem::hasComponent(entityId_t entityId) const {
+  return m_components.count(entityId);
+}
+
+//===========================================
+// FocusSystem::getComponent
+//===========================================
+CFocus& FocusSystem::getComponent(entityId_t entityId) const {
+  return *m_components.at(entityId);
+}
+
+//===========================================
+// FocusSystem::removeEntity
+//===========================================
+void FocusSystem::removeEntity(entityId_t id) {
+  m_components.erase(id);
+}
diff --git a/code/train/C++/0077508_Typesetter.cpp b/code/train/C++/0077508_Typesetter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..06f692d4d2d42cc31b5925588744830cf595913b
--- /dev/null
+++ b/code/train/C++/0077508_Typesetter.cpp
@@ -0,0 +1,162 @@
+// Copyright (c) 2010-present Bifrost Entertainment AS and Tommy Nguyen
+// Distributed under the MIT License.
+// (See accompanying file LICENSE or copy at http://opensource.org/licenses/MIT)
+
+#include "Text/Typesetter.h"
+
+// clang-format off
+#include "ThirdParty/DisableWarnings.h"
+#include <hb.h>  // NOLINT(llvm-include-order)
+#include <hb-ft.h>
+#include "ThirdParty/ReenableWarnings.h"
+// clang-format on
+
+#include "Common/Logging.h"
+#include "Common/String.h"
+#include "Common/TypeCast.h"
+
+using rainbow::czstring;
+using rainbow::GlyphPosition;
+using rainbow::SpriteVertex;
+using rainbow::TextAttributes;
+using rainbow::Typesetter;
+using rainbow::Vec2f;
+
+namespace
+{
+    /// <summary>Horizontal/vertical resolution in dpi.</summary>
+    constexpr uint32_t kDPI = 96;
+
+    /// <summary>26.6 fixed-point pixel coordinates.</summary>
+    constexpr int kPixelFormat = 64;
+
+    template <typename Iterator>
+    void offset_by(Iterator begin, Iterator end, float offset)
+    {
+        std::for_each(
+            begin, end, [offset](auto&& glyph) { glyph.position.x -= offset; });
+    }
+
+    auto suggest_line_break(std::string_view text, int start) -> int
+    {
+        const auto length = rainbow::narrow_cast<int>(text.length());
+        int i = 0;
+        while (start + i < length && text[start + i] != '\n')
+            ++i;
+        return i;
+    }
+
+    constexpr auto to_vec2(hb_position_t x, hb_position_t y) -> Vec2f
+    {
+        return Vec2f{x / rainbow::narrow_cast<float>(kPixelFormat),
+                     y / rainbow::narrow_cast<float>(kPixelFormat)};
+    }
+}  // namespace
+
+Typesetter::Typesetter()
+{
+    buffer_ = hb_buffer_create();
+    R_ASSERT(hb_buffer_allocation_successful(buffer_),  //
+             "Failed to allocate HarfBuzz buffer");
+}
+
+Typesetter::~Typesetter()
+{
+    hb_buffer_destroy(buffer_);
+}
+
+auto Typesetter::draw_text(std::string_view text,
+                           const Vec2f& position,
+                           const TextAttributes& attributes,
+                           Vec2f* size) -> std::vector<SpriteVertex>
+{
+    auto glyph_positions = layout_text(text, attributes, size);
+    std::vector<SpriteVertex> vertices;
+    vertices.reserve(glyph_positions.size() * 4);
+    auto font_face = font_cache_.get(attributes.font_face);
+    for (auto&& glyph : glyph_positions)
+    {
+        auto vx = font_cache_.get_glyph(
+            font_face, attributes.font_size, glyph.glyph_index);
+        auto p = glyph.position + position;
+        vx[0].position += p;
+        vx[1].position += p;
+        vx[2].position += p;
+        vx[3].position += p;
+        vertices.insert(vertices.end(), vx.begin(), vx.end());
+    }
+    return vertices;
+}
+
+auto Typesetter::layout_text(std::string_view text,
+                             const TextAttributes& attributes,
+                             Vec2f* size) -> std::vector<GlyphPosition>
+{
+    std::vector<GlyphPosition> result;
+
+    auto font_face = font_cache_.get(attributes.font_face);
+    FT_Set_Char_Size(
+        font_face, 0, attributes.font_size * kPixelFormat, 0, kDPI);
+    const auto line_height =
+        font_face->size->metrics.height / narrow_cast<float>(kPixelFormat);
+    auto font = hb_ft_font_create(font_face, nullptr);
+    hb_ft_font_set_load_flags(font, FT_LOAD_DEFAULT);
+
+    float width = 0.0F;
+    int line_count = 0;
+    int start = 0;
+    const auto length = narrow_cast<int>(text.length());
+    while (start < length)
+    {
+        hb_buffer_reset(buffer_);
+
+        const int line_length = suggest_line_break(text, start);
+        hb_buffer_add_utf8(buffer_, text.data(), length, start, line_length);
+        hb_buffer_guess_segment_properties(buffer_);
+        hb_shape(font, buffer_, nullptr, 0);
+
+        unsigned int count;
+        auto infos = hb_buffer_get_glyph_infos(buffer_, &count);
+        auto positions = hb_buffer_get_glyph_positions(buffer_, &count);
+
+        Vec2f origin{0, -line_height * narrow_cast<float>(line_count)};
+        for (unsigned int i = 0; i < count; ++i)
+        {
+            const auto& p = positions[i];
+            result.push_back(
+                {infos[i].codepoint, origin + to_vec2(p.x_offset, p.y_offset)});
+            origin += to_vec2(p.x_advance, p.y_advance);
+        }
+
+        switch (attributes.text_alignment)
+        {
+            case TextAlignment::Left:
+                break;
+            case TextAlignment::Right:
+                offset_by(result.begin() + result.size() - count,
+                          result.end(),
+                          origin.x);
+                break;
+            case TextAlignment::Center:
+                offset_by(result.begin() + result.size() - count,
+                          result.end(),
+                          origin.x / 2);
+                break;
+        }
+
+        start += line_length + 1;  // Skip newline
+        ++line_count;
+
+        width = std::max(width, origin.x);
+    }
+
+    hb_font_destroy(font);
+
+    if (size != nullptr)
+    {
+        size->x = width;
+        size->y = line_height * narrow_cast<float>(line_count);
+    }
+
+    return result;
+}
diff --git a/code/train/C++/0077775_OutputWnd.cpp b/code/train/C++/0077775_OutputWnd.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..674db966bdb3bbf2d1871c38d8ca975f1787f7f1
--- /dev/null
+++ b/code/train/C++/0077775_OutputWnd.cpp
@@ -0,0 +1,199 @@
+
+#include "stdafx.h"
+
+#include "OutputWnd.h"
+#include "Resource.h"
+#include "MainFrm.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// COutputBar
+
+COutputWnd::COutputWnd()
+{
+}
+
+COutputWnd::~COutputWnd()
+{
+}
+
+BEGIN_MESSAGE_MAP(COutputWnd, CDockablePane)
+	ON_WM_CREATE()
+	ON_WM_SIZE()
+END_MESSAGE_MAP()
+
+int COutputWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)
+{
+	if (CDockablePane::OnCreate(lpCreateStruct) == -1)
+		return -1;
+
+	CRect rectDummy;
+	rectDummy.SetRectEmpty();
+
+	// Create tabs window:
+	if (!m_wndTabs.Create(CMFCTabCtrl::STYLE_FLAT, rectDummy, this, 1))
+	{
+		TRACE0("Failed to create output tab window\n");
+		return -1;      // fail to create
+	}
+
+	// Create output panes:
+	const DWORD dwStyle = LBS_NOINTEGRALHEIGHT | WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL;
+
+	if (!m_wndOutputBuild.Create(dwStyle, rectDummy, &m_wndTabs, 2) ||
+		!m_wndOutputDebug.Create(dwStyle, rectDummy, &m_wndTabs, 3) ||
+		!m_wndOutputFind.Create(dwStyle, rectDummy, &m_wndTabs, 4))
+	{
+		TRACE0("Failed to create output windows\n");
+		return -1;      // fail to create
+	}
+
+	UpdateFonts();
+
+	CString strTabName;
+	BOOL bNameValid;
+
+	// Attach list windows to tab:
+	bNameValid = strTabName.LoadString(IDS_BUILD_TAB);
+	ASSERT(bNameValid);
+	m_wndTabs.AddTab(&m_wndOutputBuild, strTabName, (UINT)0);
+	bNameValid = strTabName.LoadString(IDS_DEBUG_TAB);
+	ASSERT(bNameValid);
+	m_wndTabs.AddTab(&m_wndOutputDebug, strTabName, (UINT)1);
+	bNameValid = strTabName.LoadString(IDS_FIND_TAB);
+	ASSERT(bNameValid);
+	m_wndTabs.AddTab(&m_wndOutputFind, strTabName, (UINT)2);
+
+	// Fill output tabs with some dummy text (nothing magic here)
+	FillBuildWindow();
+	FillDebugWindow();
+	FillFindWindow();
+
+	return 0;
+}
+
+void COutputWnd::OnSize(UINT nType, int cx, int cy)
+{
+	CDockablePane::OnSize(nType, cx, cy);
+
+	// Tab control should cover the whole client area:
+	m_wndTabs.SetWindowPos (NULL, -1, -1, cx, cy, SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
+}
+
+void COutputWnd::AdjustHorzScroll(CListBox& wndListBox)
+{
+	CClientDC dc(this);
+	CFont* pOldFont = dc.SelectObject(&afxGlobalData.fontRegular);
+
+	int cxExtentMax = 0;
+
+	for (int i = 0; i < wndListBox.GetCount(); i ++)
+	{
+		CString strItem;
+		wndListBox.GetText(i, strItem);
+
+		cxExtentMax = max(cxExtentMax, (int)dc.GetTextExtent(strItem).cx);
+	}
+
+	wndListBox.SetHorizontalExtent(cxExtentMax);
+	dc.SelectObject(pOldFont);
+}
+
+void COutputWnd::FillBuildWindow()
+{
+	m_wndOutputBuild.AddString(_T("Build output is being displayed here."));
+	m_wndOutputBuild.AddString(_T("The output is being displayed in rows of a list view"));
+	m_wndOutputBuild.AddString(_T("but you can change the way it is displayed as you wish..."));
+}
+
+void COutputWnd::FillDebugWindow()
+{
+	m_wndOutputDebug.AddString(_T("Debug output is being displayed here."));
+	m_wndOutputDebug.AddString(_T("The output is being displayed in rows of a list view"));
+	m_wndOutputDebug.AddString(_T("but you can change the way it is displayed as you wish..."));
+}
+
+void COutputWnd::FillFindWindow()
+{
+	m_wndOutputFind.AddString(_T("Find output is being displayed here."));
+	m_wndOutputFind.AddString(_T("The output is being displayed in rows of a list view"));
+	m_wndOutputFind.AddString(_T("but you can change the way it is displayed as you wish..."));
+}
+
+void COutputWnd::UpdateFonts()
+{
+	m_wndOutputBuild.SetFont(&afxGlobalData.fontRegular);
+	m_wndOutputDebug.SetFont(&afxGlobalData.fontRegular);
+	m_wndOutputFind.SetFont(&afxGlobalData.fontRegular);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// COutputList1
+
+COutputList::COutputList()
+{
+}
+
+COutputList::~COutputList()
+{
+}
+
+BEGIN_MESSAGE_MAP(COutputList, CListBox)
+	ON_WM_CONTEXTMENU()
+	ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
+	ON_COMMAND(ID_EDIT_CLEAR, OnEditClear)
+	ON_COMMAND(ID_VIEW_OUTPUTWND, OnViewOutput)
+	ON_WM_WINDOWPOSCHANGING()
+END_MESSAGE_MAP()
+/////////////////////////////////////////////////////////////////////////////
+// COutputList message handlers
+
+void COutputList::OnContextMenu(CWnd* /*pWnd*/, CPoint point)
+{
+	CMenu menu;
+	menu.LoadMenu(IDR_OUTPUT_POPUP);
+
+	CMenu* pSumMenu = menu.GetSubMenu(0);
+
+	if (AfxGetMainWnd()->IsKindOf(RUNTIME_CLASS(CMDIFrameWndEx)))
+	{
+		CMFCPopupMenu* pPopupMenu = new CMFCPopupMenu;
+
+		if (!pPopupMenu->Create(this, point.x, point.y, (HMENU)pSumMenu->m_hMenu, FALSE, TRUE))
+			return;
+
+		((CMDIFrameWndEx*)AfxGetMainWnd())->OnShowPopupMenu(pPopupMenu);
+		UpdateDialogControls(this, FALSE);
+	}
+
+	SetFocus();
+}
+
+void COutputList::OnEditCopy()
+{
+	MessageBox(_T("Copy output"));
+}
+
+void COutputList::OnEditClear()
+{
+	MessageBox(_T("Clear output"));
+}
+
+void COutputList::OnViewOutput()
+{
+	CDockablePane* pParentBar = DYNAMIC_DOWNCAST(CDockablePane, GetOwner());
+	CMDIFrameWndEx* pMainFrame = DYNAMIC_DOWNCAST(CMDIFrameWndEx, GetTopLevelFrame());
+
+	if (pMainFrame != NULL && pParentBar != NULL)
+	{
+		pMainFrame->SetFocus();
+		pMainFrame->ShowPane(pParentBar, FALSE, FALSE, FALSE);
+		pMainFrame->RecalcLayout();
+
+	}
+}
diff --git a/code/train/C++/0078891_Merge_Intervals.cpp b/code/train/C++/0078891_Merge_Intervals.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..62c006e47f1352027cdcdb5857aafee4e80aea13
--- /dev/null
+++ b/code/train/C++/0078891_Merge_Intervals.cpp
@@ -0,0 +1,33 @@
+bool cmp(Interval a,Interval b){
+    return a.start<b.start;
+}
+
+class Solution {
+public:
+    vector<Interval> ans;
+    vector<Interval> merge(vector<Interval> &intervals) {
+        int len=intervals.size();
+        if(len<=1) return intervals;
+        Interval tmp;
+        bool f=false;
+        sort(intervals.begin(),intervals.end(),cmp);
+        for(int i=0;i<len;i++){
+            if(!f){
+                tmp=intervals[i];
+                f=true;
+            }
+            else{
+                if( intervals[i].start > tmp.end ){
+                    ans.push_back(tmp);
+                    f=false;
+                    i--;
+                }
+                else{
+                    tmp.end=(tmp.end>intervals[i].end?tmp.end:intervals[i].end);
+                }
+            }
+        }
+        ans.push_back(tmp);
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/code/train/C++/0079118_main.cpp b/code/train/C++/0079118_main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..517efe182412f0e45674e43a59c9b7a5dde45d73
--- /dev/null
+++ b/code/train/C++/0079118_main.cpp
@@ -0,0 +1,111 @@
+#include <iostream>
+#include <locale>
+#include <math.h>
+using namespace std;
+
+double f(double x)
+{
+	return pow(x, 3) - 2 * pow(x, 2) - 11 * x + 12;
+}
+
+double fh(double x)
+{
+	return 3 * pow(x, 2) - 4 * x - 11;
+}
+
+double findHord(double a, double b, double e) // a, b - ïðåäåëû õîðäû, e - íåîáõîäèìàÿ ïîãðåøíîñòü
+{
+	int count = 0;
+	while (fabs(b - a) >= e)
+	{
+		count++;
+		a = b - (b - a) * f(b) / (f(b) - f(a)); // i-1
+		b = a - (a - b) * f(a) / (f(a) - f(b)); // i
+	}
+	cout << '\t' << count << '\t';
+	return b;
+}
+
+double findIter(double x, double e) // x - òî÷êà âõîäà, e - íåîáõîäèìàÿ ïîãðåøíîñòü
+{
+	int count = 0;
+	double l, x_prev;
+	l = 1 / fh(x);
+	do {
+		if ((fh(x) > 0 && l < 0) || (fh(x) < 0 && l > 0)) l *= -1;
+		x_prev = x;
+		x = x-l*f(x);
+		count++;
+	} while (fabs(x_prev - x) >= e);
+	cout << '\t' << count<< '\t';
+	return x;
+}
+
+int main()
+{
+	setlocale(LC_ALL, "Russian");
+	double a = 0., b = 0., e = 0., x = 0.;
+
+	cout << "Äëÿ óðàâíåíèÿ x^3-2x^2-11x+12. // -3 1 4" << endl;
+	cout << "Ââåäèòå äàííûå î îòðåçêå, íà êîòîðîì áóäåì èñêàòü ïðîìåæóòêè: ";
+	cin >> a >> b;
+
+	bool isRun = false;
+	do{
+
+		int m = 0;
+		
+		cout << "Ââåäèòå ïîãðåøíîñòü: ";
+		cin >> e;
+		
+		cout << "\nÂûáèðèòå ìåòîä: 0 - õîðä, 1 - ïðîñòûõ èòåðàöèé\nÂàø âûáîð: ";
+		cin >> m;
+
+		if (m == 0)
+		{
+			double now = f(a), fut = 0.;
+			for (double i = a; i < b; i+=1.5)
+			{
+				fut = f(i + 1);
+
+				if ((now >= 0 && fut <= 0) || (now <= 0 && fut >= 0))
+				{
+					double zn = findHord(i, i + 1, e);
+					if (zn < 999 || zn > 999)
+					{
+						//cout << "Îòëàäêà: " << now << ", " << fut << ", èíòåðâàë (" << i << "," << i + 1 << ")\n";
+						cout << "Òî÷êà ïåðå÷å÷åíèÿ íà îòðåçêå [" << i << ", " << i + 1 << "], ïðèõîäèòñÿ íà (" << zn << ", 0)." << endl;
+					}
+				}
+				now = fut;
+			}
+		}
+		else
+		{
+			double now = f(a), fut = 0.;
+			for (double i = a; i < b; i ++)
+			{
+				fut = f(i + 1);
+				if ((now >= 0 && fut <= 0) || (now <= 0 && fut >= 0))
+				{
+					double zn = findIter(i, e);
+					if (zn < 999 || zn > 999)
+					{
+						//cout << "Îòëàäêà: " << now << ", " << fut << ", èíòåðâàë (" << i << "," << i + 1 << ")\n";
+						cout << "Òî÷êà ïåðå÷å÷åíèÿ, ïðè âõîæå â òî÷êå " << i << ", ïðèõîäèòñÿ íà (" << zn << ", 0)." << endl;
+					}
+				}
+				now = fut;
+			}
+		}
+		char run;
+		cout << "Õîòèòå ïðîäîëæèòü? (Y|N) ";
+		cin >> run;
+		if (run == 'Y' || run == 'y') isRun = true;
+		else isRun = false;
+	} while (isRun);
+
+	return 0;
+	cin.get();
+	cin.get();
+}
\ No newline at end of file
diff --git a/code/train/C++/0079162_ring_hash_lb.cc b/code/train/C++/0079162_ring_hash_lb.cc
new file mode 100644
index 0000000000000000000000000000000000000000..28b64bdefd753054b3bfe6ded936cd5102b4bc68
--- /dev/null
+++ b/code/train/C++/0079162_ring_hash_lb.cc
@@ -0,0 +1,202 @@
+#include "common/upstream/ring_hash_lb.h"
+
+#include <cstdint>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include "envoy/config/cluster/v3/cluster.pb.h"
+
+#include "common/common/assert.h"
+#include "common/upstream/load_balancer_impl.h"
+
+#include "absl/container/inlined_vector.h"
+#include "absl/strings/string_view.h"
+
+namespace Envoy {
+namespace Upstream {
+
+RingHashLoadBalancer::RingHashLoadBalancer(
+    const PrioritySet& priority_set, ClusterStats& stats, Stats::Scope& scope,
+    Runtime::Loader& runtime, Random::RandomGenerator& random,
+    const absl::optional<envoy::config::cluster::v3::Cluster::RingHashLbConfig>& config,
+    const envoy::config::cluster::v3::Cluster::CommonLbConfig& common_config)
+    : ThreadAwareLoadBalancerBase(priority_set, stats, runtime, random, common_config),
+      scope_(scope.createScope("ring_hash_lb.")), stats_(generateStats(*scope_)),
+      min_ring_size_(config ? PROTOBUF_GET_WRAPPED_OR_DEFAULT(config.value(), minimum_ring_size,
+                                                              DefaultMinRingSize)
+                            : DefaultMinRingSize),
+      max_ring_size_(config ? PROTOBUF_GET_WRAPPED_OR_DEFAULT(config.value(), maximum_ring_size,
+                                                              DefaultMaxRingSize)
+                            : DefaultMaxRingSize),
+      hash_function_(config ? config.value().hash_function()
+                            : HashFunction::Cluster_RingHashLbConfig_HashFunction_XX_HASH),
+      use_hostname_for_hashing_(
+          common_config.has_consistent_hashing_lb_config()
+              ? common_config.consistent_hashing_lb_config().use_hostname_for_hashing()
+              : false) {
+  // It's important to do any config validation here, rather than deferring to Ring's ctor,
+  // because any exceptions thrown here will be caught and handled properly.
+  if (min_ring_size_ > max_ring_size_) {
+    throw EnvoyException(fmt::format("ring hash: minimum_ring_size ({}) > maximum_ring_size ({})",
+                                     min_ring_size_, max_ring_size_));
+  }
+}
+
+RingHashLoadBalancerStats RingHashLoadBalancer::generateStats(Stats::Scope& scope) {
+  return {ALL_RING_HASH_LOAD_BALANCER_STATS(POOL_GAUGE(scope))};
+}
+
+HostConstSharedPtr RingHashLoadBalancer::Ring::chooseHost(uint64_t h, uint32_t attempt) const {
+  if (ring_.empty()) {
+    return nullptr;
+  }
+
+  // Ported from https://github.com/RJ/ketama/blob/master/libketama/ketama.c (ketama_get_server)
+  // I've generally kept the variable names to make the code easier to compare.
+  // NOTE: The algorithm depends on using signed integers for lowp, midp, and highp. Do not
+  //       change them!
+  int64_t lowp = 0;
+  int64_t highp = ring_.size();
+  int64_t midp = 0;
+  while (true) {
+    midp = (lowp + highp) / 2;
+
+    if (midp == static_cast<int64_t>(ring_.size())) {
+      midp = 0;
+      break;
+    }
+
+    uint64_t midval = ring_[midp].hash_;
+    uint64_t midval1 = midp == 0 ? 0 : ring_[midp - 1].hash_;
+
+    if (h <= midval && h > midval1) {
+      break;
+    }
+
+    if (midval < h) {
+      lowp = midp + 1;
+    } else {
+      highp = midp - 1;
+    }
+
+    if (lowp > highp) {
+      midp = 0;
+      break;
+    }
+  }
+
+  // If a retry host predicate is being applied, behave as if this host was not in the ring.
+  // Note that this does not guarantee a different host: e.g., attempt == ring_.size() or
+  // when the offset causes us to select the same host at another location in the ring.
+  if (attempt > 0) {
+    midp = (midp + attempt) % ring_.size();
+  }
+
+  return ring_[midp].host_;
+}
+
+using HashFunction = envoy::config::cluster::v3::Cluster::RingHashLbConfig::HashFunction;
+RingHashLoadBalancer::Ring::Ring(const NormalizedHostWeightVector& normalized_host_weights,
+                                 double min_normalized_weight, uint64_t min_ring_size,
+                                 uint64_t max_ring_size, HashFunction hash_function,
+                                 bool use_hostname_for_hashing, RingHashLoadBalancerStats& stats)
+    : stats_(stats) {
+  ENVOY_LOG(trace, "ring hash: building ring");
+
+  // We can't do anything sensible with no hosts.
+  if (normalized_host_weights.empty()) {
+    return;
+  }
+
+  // Scale up the number of hashes per host such that the least-weighted host gets a whole number
+  // of hashes on the ring. Other hosts might not end up with whole numbers, and that's fine (the
+  // ring-building algorithm below can handle this). This preserves the original implementation's
+  // behavior: when weights aren't provided, all hosts should get an equal number of hashes. In
+  // the case where this number exceeds the max_ring_size, it's scaled back down to fit.
+  const double scale =
+      std::min(std::ceil(min_normalized_weight * min_ring_size) / min_normalized_weight,
+               static_cast<double>(max_ring_size));
+
+  // Reserve memory for the entire ring up front.
+  const uint64_t ring_size = std::ceil(scale);
+  ring_.reserve(ring_size);
+
+  // Populate the hash ring by walking through the (host, weight) pairs in
+  // normalized_host_weights, and generating (scale * weight) hashes for each host. Since these
+  // aren't necessarily whole numbers, we maintain running sums -- current_hashes and
+  // target_hashes -- which allows us to populate the ring in a mostly stable way.
+  //
+  // For example, suppose we have 4 hosts, each with a normalized weight of 0.25, and a scale of
+  // 6.0 (because the max_ring_size is 6). That means we want to generate 1.5 hashes per host.
+  // We start the outer loop with current_hashes = 0 and target_hashes = 0.
+  //   - For the first host, we set target_hashes = 1.5. After one run of the inner loop,
+  //     current_hashes = 1. After another run, current_hashes = 2, so the inner loop ends.
+  //   - For the second host, target_hashes becomes 3.0, and current_hashes is 2 from before.
+  //     After only one run of the inner loop, current_hashes = 3, so the inner loop ends.
+  //   - Likewise, the third host gets two hashes, and the fourth host gets one hash.
+  //
+  // For stats reporting, keep track of the minimum and maximum actual number of hashes per host.
+  // Users should hopefully pay attention to these numbers and alert if min_hashes_per_host is too
+  // low, since that implies an inaccurate request distribution.
+
+  absl::InlinedVector<char, 196> hash_key_buffer;
+  double current_hashes = 0.0;
+  double target_hashes = 0.0;
+  uint64_t min_hashes_per_host = ring_size;
+  uint64_t max_hashes_per_host = 0;
+  for (const auto& entry : normalized_host_weights) {
+    const auto& host = entry.first;
+    const std::string& address_string =
+        use_hostname_for_hashing ? host->hostname() : host->address()->asString();
+    ASSERT(!address_string.empty());
+
+    hash_key_buffer.assign(address_string.begin(), address_string.end());
+    hash_key_buffer.emplace_back('_');
+    auto offset_start = hash_key_buffer.end();
+
+    // As noted above: maintain current_hashes and target_hashes as running sums across the entire
+    // host set. `i` is needed only to construct the hash key, and tally min/max hashes per host.
+    target_hashes += scale * entry.second;
+    uint64_t i = 0;
+    while (current_hashes < target_hashes) {
+      const std::string i_str = absl::StrCat("", i);
+      hash_key_buffer.insert(offset_start, i_str.begin(), i_str.end());
+
+      absl::string_view hash_key(static_cast<char*>(hash_key_buffer.data()),
+                                 hash_key_buffer.size());
+
+      const uint64_t hash =
+          (hash_function == HashFunction::Cluster_RingHashLbConfig_HashFunction_MURMUR_HASH_2)
+              ? MurmurHash::murmurHash2(hash_key, MurmurHash::STD_HASH_SEED)
+              : HashUtil::xxHash64(hash_key);
+
+      ENVOY_LOG(trace, "ring hash: hash_key={} hash={}", hash_key.data(), hash);
+      ring_.push_back({hash, host});
+      ++i;
+      ++current_hashes;
+      hash_key_buffer.erase(offset_start, hash_key_buffer.end());
+    }
+    min_hashes_per_host = std::min(i, min_hashes_per_host);
+    max_hashes_per_host = std::max(i, max_hashes_per_host);
+  }
+
+  std::sort(ring_.begin(), ring_.end(), [](const RingEntry& lhs, const RingEntry& rhs) -> bool {
+    return lhs.hash_ < rhs.hash_;
+  });
+  if (ENVOY_LOG_CHECK_LEVEL(trace)) {
+    for (const auto& entry : ring_) {
+      ENVOY_LOG(trace, "ring hash: host={} hash={}",
+                use_hostname_for_hashing ? entry.host_->hostname()
+                                         : entry.host_->address()->asString(),
+                entry.hash_);
+    }
+  }
+
+  stats_.size_.set(ring_size);
+  stats_.min_hashes_per_host_.set(min_hashes_per_host);
+  stats_.max_hashes_per_host_.set(max_hashes_per_host);
+}
+
+} // namespace Upstream
+} // namespace Envoy
diff --git a/code/train/C++/0079367_chunktrimmer_main.cc b/code/train/C++/0079367_chunktrimmer_main.cc
new file mode 100644
index 0000000000000000000000000000000000000000..67e27df6ea7feebb1e13812573dc756aa907175d
--- /dev/null
+++ b/code/train/C++/0079367_chunktrimmer_main.cc
@@ -0,0 +1,247 @@
+//---------------------------------------------------------- -*- Mode: C++ -*-
+// $Id: chunktrimmer_main.cc 403 2010-11-30 00:27:26Z sriramsrao $
+//
+// Created 2008/06/11
+//
+//
+// Copyright 2008 Quantcast Corp.
+//
+// This file is part of Kosmos File System (KFS).
+//
+// 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.
+//
+// \brief This works only on Linux:  Whenever chunks are moved to
+// lost+found, it is likely because we had trouble reading data off
+// disk.  We'd like to leave the "bad" sectors pinned while freeing up
+// the other readable sectors.  This takes out the bad sectors from
+// allocation while improving disk health.  On Linux, we use XFS
+// ioctl's to punch holes for all the readable data from a file, while
+// leaving the regions that return EIO pinned on disk.
+//
+//----------------------------------------------------------------------------
+
+#include <dirent.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <string>
+#include <boost/scoped_array.hpp>
+#include <iostream>
+
+#if defined(KFS_OS_NAME_LINUX) && defined(KFS_USE_XFS)
+#include <xfs/xfs.h>
+#endif
+
+using std::cout;
+using std::endl;
+using std::string;
+using boost::scoped_array;
+
+static void trimFile(string &fn, off_t filesz, bool verbose);
+
+int main(int argc, char **argv)
+{
+    char optchar;
+    bool help = false;
+    string pathname = "";
+    int res, count;
+    int ndaysOld = 5;
+    struct dirent **entries;
+    struct stat statBuf;
+    bool verbose = false;
+
+    while ((optchar = getopt(argc, argv, "hvd:n:")) != -1)
+    {
+        switch (optchar)
+        {
+        case 'd':
+            pathname = optarg;
+            break;
+        case 'v':
+            verbose = true;
+            break;
+        case 'n':
+            ndaysOld = atoi(optarg);
+            break;
+        case 'h':
+        default:
+            help = true;
+            break;
+        }
+    }
+
+    if ((help) || (pathname == ""))
+    {
+        cout << "Usage: " << argv[0] << " -d <pathname> {-n <days>} {-v} " << endl;
+        cout << "where, files older than n days are pruned" << endl;
+        exit(-1);
+    }
+
+    time_t now = time(0);
+
+    res = stat(pathname.c_str(), &statBuf);
+    if (res < 0)
+    {
+        cout << "Unable to open: " << pathname << endl;
+        exit(-1);
+    }
+    if (S_ISREG(statBuf.st_mode))
+    {
+        if ((now - statBuf.st_mtime) < (ndaysOld * 24 * 60 * 60))
+        {
+            cout << "Ignoring file: " << pathname << " since it is not old enough for pruning" << endl;
+            exit(0);
+        }
+        trimFile(pathname, statBuf.st_size, verbose);
+        exit(0);
+    }
+
+    count = scandir(pathname.c_str(), &entries, 0, alphasort);
+    if (count < 0)
+    {
+        cout << "Unable to open: " << pathname << endl;
+        exit(-1);
+    }
+
+
+    for (int i = 0; i < count; i++)
+    {
+        string fn = pathname;
+        fn = fn + "/" + entries[i]->d_name;
+        res = stat(fn.c_str(), &statBuf);
+        free(entries[i]);
+        if ((res < 0) || (!S_ISREG(statBuf.st_mode)) ||
+                (fn.rfind(".corrupt") != string::npos))
+        {
+            // either it is not a file or it has been trimmed earlier
+            // and renamed to .corrupt
+            continue;
+        }
+        if ((now - statBuf.st_mtime) < (ndaysOld * 24 * 60 * 60))
+        {
+            cout << "Ignoring file: " << fn << " since it is not old enough for pruning" << endl;
+            continue;
+        }
+        trimFile(fn, statBuf.st_size, verbose);
+    }
+    free(entries);
+    exit(0);
+}
+
+#if defined(KFS_OS_NAME_LINUX) && defined(KFS_USE_XFS)
+
+static const int oneMB = 1 << 20;
+static const int fourK = 4096;
+
+static int trimPart(int fd, off_t startP, off_t endP, int blkSz, int &numFreed, int &numKept);
+
+static void trimFile(string &fn, off_t filesz, bool verbose)
+{
+    int fd, res;
+    int numFreed = 0, numKept = 0;
+
+    fd = open(fn.c_str(), O_RDWR | O_DIRECT);
+    // fd = open(fn.c_str(), O_RDONLY | O_DIRECT);
+    if (fd < 0)
+    {
+        cout << "Unable to open: " << fn << endl;
+        return;
+    }
+    bool shouldPreserveFile = false;
+    off_t filePos = 0;
+    int dummy;
+    while (1)
+    {
+        // remember the filePos, since on a successful read it will be updated
+        filePos = lseek(fd, 0, SEEK_CUR);
+        // read in big chunks; if any fail, we will switch down to
+        // reading in 4k and pinning only the unreadable 4k blocks
+        res = trimPart(fd, filePos, filePos + oneMB, oneMB, numFreed, dummy);
+        if ((res == 0) || (filePos > filesz))
+        {
+            // hit EOF
+            break;
+        }
+        if (res < 0)
+        {
+            filePos = lseek(fd, filePos, SEEK_SET);
+            shouldPreserveFile = true;
+            trimPart(fd, filePos, filePos + oneMB, fourK, numFreed, numKept);
+        }
+    }
+    close(fd);
+    if (shouldPreserveFile)
+    {
+        string corruptFn = fn + ".corrupt";
+        rename(fn.c_str(), corruptFn.c_str());
+        cout << "Renamed: " << fn << " -> " << corruptFn << endl;
+        cout << "Filesize: " << filePos << endl;
+        cout << "Num 4k-blocks kept: " << numKept << endl;
+        cout << "Num 4k-blocks freed: " << numFreed << endl;
+    }
+    else
+    {
+        cout << "Non-corrupt file: " << fn << " ; so nuking" << endl;
+        unlink(fn.c_str());
+    }
+}
+
+static int
+trimPart(int fd, off_t startP, off_t endP, int blkSz, int &numFreed, int &numKept)
+{
+    static char *data = NULL;
+    xfs_flock64_t theFree = {0};
+    off_t currP = startP;
+    int retval = 1, res;
+
+    if (data == NULL)
+    {
+        data = (char *) memalign(fourK, oneMB * sizeof(char));
+    }
+    while (currP < endP)
+    {
+        if (currP >= endP)
+            break;
+        res = read(fd, data, blkSz);
+        if (res == 0)
+            return (retval == -1 ? -1 : 0);
+        if (res < 0)
+        {
+            // we couldn't read a block; so, reset the position and skip over the block
+            // we failed to read
+            currP = lseek(fd, currP + blkSz, SEEK_SET);
+            cout << "Couldn't read block at: " << currP - blkSz << " of len = " << blkSz << endl;
+            numKept += (blkSz / 4096);
+            // file needs to be preserved
+            retval = -1;
+            continue;
+        }
+        // got data, so free the block and punch a hole in the file
+        theFree.l_whence = 0;
+        theFree.l_start = currP;
+        theFree.l_len = res;
+        xfsctl(0, fd, XFS_IOC_UNRESVSP64, &theFree);
+        numFreed += (res / 4096);
+        currP += res;
+    }
+    return retval;
+}
+
+#else
+static void trimFile(string &fn, off_t filesz, bool verbose)
+{
+
+}
+#endif
diff --git a/code/train/C++/0079494_AirspaceSorter.cpp b/code/train/C++/0079494_AirspaceSorter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c73c357853c5ccb1d3238206d97e9d79afd6eef8
--- /dev/null
+++ b/code/train/C++/0079494_AirspaceSorter.cpp
@@ -0,0 +1,119 @@
+#include "AirspaceSorter.hpp"
+#include "Airspace/Airspaces.hpp"
+#include "AbstractAirspace.hpp"
+#include "AirspaceVisitor.hpp"
+#include "Geo/GeoVector.hpp"
+#include "Util/StringAPI.hpp"
+
+#include <algorithm>
+
+void
+AirspaceSelectInfo::ResetVector()
+{
+  vec.SetInvalid();
+}
+
+const GeoVector &
+AirspaceSelectInfo::GetVector(const GeoPoint &location,
+                              const FlatProjection &projection) const
+{
+  if (!vec.IsValid()) {
+    const GeoPoint closest_loc = airspace->ClosestPoint(location, projection);
+    vec = GeoVector(location, closest_loc);
+  }
+
+  return vec;
+}
+
+bool
+AirspaceFilterData::Match(const GeoPoint &location,
+                          const FlatProjection &projection,
+                          const AbstractAirspace &as) const
+{
+  if (cls != AirspaceClass::AIRSPACECLASSCOUNT && as.GetType() != cls)
+    return false;
+
+  if (name_prefix != nullptr && !as.MatchNamePrefix(name_prefix))
+    return false;
+
+  if (!negative(direction.Native())) {
+    const GeoPoint closest = as.ClosestPoint(location, projection);
+    const Angle bearing = location.Bearing(closest);
+    fixed direction_error = (bearing - direction).AsDelta().AbsoluteDegrees();
+    if (direction_error > fixed(18))
+      return false;
+  }
+
+  if (!negative(distance)) {
+    const GeoPoint closest = as.ClosestPoint(location, projection);
+    const fixed distance = location.Distance(closest);
+    if (distance > distance)
+      return false;
+  }
+
+  return true;
+}
+
+class AirspaceFilterVisitor final : public AirspaceVisitor {
+  GeoPoint location;
+  const FlatProjection &projection;
+  const AirspaceFilterData &filter;
+
+public:
+  AirspaceSelectInfoVector result;
+
+  AirspaceFilterVisitor(const GeoPoint &_location,
+                        const FlatProjection &_projection,
+                        const AirspaceFilterData &_filter)
+    :location(_location), projection(_projection), filter(_filter) {}
+
+  virtual void Visit(const AbstractAirspace &as) {
+    if (filter.Match(location, projection, as))
+      result.emplace_back(as);
+  }
+};
+
+static void
+SortByDistance(AirspaceSelectInfoVector &vec, const GeoPoint &location,
+               const FlatProjection &projection)
+{
+  auto compare = [&] (const AirspaceSelectInfo &elem1,
+                      const AirspaceSelectInfo &elem2) {
+    return elem1.GetVector(location, projection).distance <
+           elem2.GetVector(location, projection).distance;
+  };
+
+  std::sort(vec.begin(), vec.end(), compare);
+}
+
+static void
+SortByName(AirspaceSelectInfoVector &vec)
+{
+  auto compare = [&] (const AirspaceSelectInfo &elem1,
+                      const AirspaceSelectInfo &elem2) {
+    return StringCollate(elem1.GetAirspace().GetName(),
+                         elem2.GetAirspace().GetName()) < 0;
+  };
+
+  std::sort(vec.begin(), vec.end(), compare);
+}
+
+AirspaceSelectInfoVector
+FilterAirspaces(const Airspaces &airspaces, const GeoPoint &location,
+                const AirspaceFilterData &filter)
+{
+  AirspaceFilterVisitor visitor(location, airspaces.GetProjection(), filter);
+
+  if (!negative(filter.distance))
+    airspaces.VisitWithinRange(location, filter.distance, visitor);
+  else
+    for (const auto &i : airspaces)
+      visitor.Visit(i.GetAirspace());
+
+  if (negative(filter.direction.Native()) && negative(filter.distance))
+    SortByName(visitor.result);
+  else
+    SortByDistance(visitor.result, location, airspaces.GetProjection());
+
+  return visitor.result;
+}
diff --git a/code/train/C++/0079495_object_pool.cpp b/code/train/C++/0079495_object_pool.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6152c4749f3b60023450bf909800ea1da4487fcd
--- /dev/null
+++ b/code/train/C++/0079495_object_pool.cpp
@@ -0,0 +1,117 @@
+/**
+  * @purpose A simple object pool example
+  *
+  * @author  Ashish
+  * @license MIT license
+  * @version 1.0, Doxygen compatible comments
+  */
+
+#include<iostream>
+#include<string>
+#include<list>
+using namespace std;
+
+class Car {
+ private:
+    bool in_use_;
+    string rentee_;
+    string last_rentee_;
+
+ public:
+    Car()
+    : in_use_(false),
+    last_rentee_("NONE"),
+    rentee_("NONE") {
+    }
+
+    void set_in_use(bool status) {
+        in_use_ = true;
+    }
+
+    bool in_use(void) {
+        return in_use_;
+    }
+
+    void set_rentee(const string& given_rentee) {
+        rentee_ = given_rentee;
+    }
+
+    string rentee(void) {
+        return rentee_;
+    }
+
+    void set_last_rentee(const string& given_rentee) {
+        last_rentee_ = given_rentee;
+    }
+
+    string last_rentee(void) {
+        return last_rentee_;
+    }
+};
+
+class CarPool : public Car {
+ private:
+    list <Car*> car_list;  /// list STL to store object pointers
+
+ public:
+    static CarPool& get_instance() {  /// singleton objectpool instance
+        static CarPool instance;
+        return instance;
+    }
+
+    Car* get_car() {
+        Car* car = NULL;
+
+        if (car_list.empty()) {  /// case 1: Henry gets a brand new car for the first customer
+            car = new Car;
+        } else {
+            car = car_list.front();  /// case 2: Henry allots an already existing car to the customer
+            car_list.pop_front();
+        }
+
+        car->set_in_use(true);
+        return car;
+    }
+
+    Car* return_car(Car *given_car) {
+        if (given_car != NULL) {
+            given_car->set_in_use(false);
+            given_car->set_last_rentee(given_car->rentee());  /// Henry notes the previous customer name
+            given_car->set_rentee("NONE");
+
+            car_list.push_back(given_car);  /// The car has been returned to Henry's car lot
+            return NULL;
+        }
+    }
+
+ protected:
+    CarPool() {
+    }
+};
+
+int main() {
+    CarPool henrys_car_rental = CarPool::get_instance();  /// henry starts a car rental service
+
+    /// usecase 1 - alice is the first customer, she gets a brand new car
+    Car* alices = henrys_car_rental.get_car();  /// alice gets a car from henry's rental service
+    cout << "Alice's car was last rented to = " << alices->last_rentee() << endl;
+    alices->set_rentee("ALICE");  /// alice is now registered as the rentee and can drive the car
+    cout << "Alice's car is now rented to = " << alices->rentee() << endl;
+
+    /// usecase 2 - bob is the next customer, he also gets a new car
+    Car* bobs = henrys_car_rental.get_car();  /// bob also gets a car from henry's rental service
+    cout << "Bob's car was last rented to = " << bobs->last_rentee() << endl;
+    bobs->set_rentee("BOB");  /// the car is now resitered to BOB as rentee
+    cout << "Bob's car is now rented to = " << alices->rentee() << endl;
+    bobs = henrys_car_rental.return_car(bobs);  /// bob returns the car to henry's rental service
+
+    /// usecase 3 - fred is a customer, who gets the car bob has returned
+    Car* freds = henrys_car_rental.get_car();  /// fred gets bob's returned car from henry's rental service
+    cout << "Fred's car was last rented to = " << freds->last_rentee() << endl;
+    freds->set_rentee("FRED");  /// the car is now resitered to FRED as rentee
+    cout << "Fred's car is now rented to = " << freds->rentee() << endl;
+    freds = henrys_car_rental.return_car(freds);  /// fred returns the car to henry's rental service
+
+    return 0;
+}
+
diff --git a/code/train/C++/0079591_076.cpp b/code/train/C++/0079591_076.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c3049b8f1e59028528c51feeaae223c5729ca92
--- /dev/null
+++ b/code/train/C++/0079591_076.cpp
@@ -0,0 +1,58 @@
+/*============================================================
+Problem: Minimum Window Substring
+==============================================================
+Given a string S and a string T, find the minimum window in S 
+which will contain all the characters in T in complexity O(n).
+
+For example,
+S = "ADOBECODEBANC"
+T = "ABC"
+Minimum window is "BANC".
+
+Note:
+If there is no such window in S that covers all characters in T, 
+return the empty string "".
+
+If there are multiple such windows, you are guaranteed that 
+there will always be only one unique minimum window in S.
+============================================================*/
+class Solution {
+private:
+    bool needed[256] = {false};
+    int  counts[256] = {0};
+public:
+    string minWindow(string s, string t) {
+    	int sLen = s.size(), tLen = t.size();
+        if (sLen==0 || tLen==0) return "";
+        
+        for (int i=0; i<tLen; i++) {
+            needed[t[i]] = true;
+            counts[t[i]]++;
+        }
+        int start=0, minSize = INT_MAX, minStart, notMatchCount=tLen;  // start: the start index of the current WINDOW
+        for (int i=0; i<sLen; i++) {
+            if (needed[s[i]]) {  // vist a char we have to match
+                counts[s[i]]--;
+                if (counts[s[i]] >= 0)  // if another useful match is made, not matched minus 
+                    notMatchCount--;
+            }
+            if (notMatchCount==0) {  // now we can move the start of the WINDOW forward, when all matched
+                while (true) {
+                    if (needed[s[start]]) {  // the first char is a char we have to match
+                        if (counts[s[start]] < 0)  // have more matched ones of this char, can still move forward
+                            counts[s[start]]++;
+                        else
+                            break;
+                    }
+                    // if the first char is not what we want to match, just move forward
+                    start++;
+                }
+                if (minSize > i-start+1) {  // update the minimum WINDOW
+                    minSize = i-start+1;
+                    minStart = start;
+                }
+            }
+        }
+        return minSize==INT_MAX ? "" : s.substr(minStart, minSize);        
+    }
+};
\ No newline at end of file
diff --git a/code/train/C++/0080752_test.cpp b/code/train/C++/0080752_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..952966e6a9bcbb900779c1dc272449b9dda2f84f
--- /dev/null
+++ b/code/train/C++/0080752_test.cpp
@@ -0,0 +1,57 @@
+#include <iostream>
+#include <fstream>
+#include <math.h>
+#include <stdlib.h>
+#include <sys/time.h>
+using namespace std;
+long microtime()
+{
+	struct timeval tv;
+	if(gettimeofday(&tv, NULL) != 0)
+			return 0;
+	return (tv.tv_sec * 1000000) + tv.tv_usec;
+}
+int randnum(int a,int b){
+	return rand()%(b-a+1)+a;
+}
+void write(int w,int h,int size,int *terrain,int N){
+	ofstream f("input.txt");
+	f<<">WINDOW\n"<<w<<" "<<h<<endl;
+	f<<">BALL\n"<<size<<" "<<110<<endl;
+	f<<">TERRAIN\n";
+	for(int i=0;i<N;i++)
+		f<<terrain[2*i]<<" "<<terrain[2*i+1]<<endl;
+	f<<">TREES\n";
+}
+int main(){
+	int h,w,size;
+	srand(microtime());
+	h=randnum(400,600);
+	w=randnum(600,800);
+	int N=w*randnum(3,6)/100.0;
+	size=w*randnum(80,160)/100/N;
+	int *terrain;
+	terrain=new int[2*N];	
+	int passes=20;float a=1,f=1,A=h/2;
+	for(int j=0;j<passes;j++)
+	{
+		f=randnum(51,500)/50.0;//total oscillations
+
+		a=A*(randnum(50,85)/100.0)/f;
+		A-=a;
+		for(int i=0;i<N;i++){
+			if(j==0){
+				if(i==0)
+					terrain[2*i]=0;
+				else if(i==N-1)
+					terrain[2*i]=w;
+				else
+					terrain[2*i]=(i+randnum(-5,5)/20.0)*w/N;
+				terrain[2*i+1]=h/2;
+			}
+			terrain[2*i+1]+=a*sin(f*i*2*M_PI/N);
+		}
+	}
+	write(w,h,size,terrain,N);
+	return 0;
+}
diff --git a/code/train/C++/0080828_OAI_MAR2.cpp b/code/train/C++/0080828_OAI_MAR2.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..646562973a3d16903f7d4205e89b97451731c639
--- /dev/null
+++ b/code/train/C++/0080828_OAI_MAR2.cpp
@@ -0,0 +1,452 @@
+/*
+ * Seven Kingdoms: Ancient Adversaries
+ *
+ * Copyright 1997,1998 Enlight Software Ltd.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+//Filename   : OAI_MAR2.CPP
+//Description: AI functions for processing AI marine actions
+
+#include <OTOWN.h>
+#include <OREGIONS.h>
+#include <OU_MARI.h>
+#include <OF_HARB.h>
+#include <ONATION.h>
+
+//-------- Begin of function Nation::ai_sea_travel -------//
+//
+// action_x_loc, action_y_loc - location of the destination
+//
+// group_unit_array - array of units that will do the sea travel
+// instance_count - no. of units in the array
+//
+// action_para  - the action of units after they have arrived the region,
+//					   it is one of the following:
+//
+// SEA_ACTION_SETTLE		 	  - settle into a town
+//	SEA_ACTION_BUILD_CAMP 	  - build and assign to a firm
+//	SEA_ACTION_ASSIGN_TO_FIRM - assign to a firm
+//	SEA_ACTION_MOVE			  - just move to the destination
+//								 	    (this include moving to the location of a battle field.)
+//
+//---------------------------------------------//
+//
+// Procedures:
+// * 1. Locate a ship, build one if cannot locate any.
+// * 2. Assign the units to the ship.
+//   3. Move the ship to the destination region.
+//   4. Units disembark on the coast.
+//   5. Units move to the destination.
+//
+// This function deal with the 1st and 2nd procedures,
+// when they are finished, action ACTION_AI_SEA_TRAVEL2
+// will be added.
+//
+//---------------------------------------------//
+//
+int Nation::ai_sea_travel(ActionNode* actionNode)
+{
+	err_when( actionNode->instance_count < 1 ||
+				 actionNode->instance_count > ActionNode::MAX_ACTION_GROUP_UNIT );
+
+	Unit* unitPtr = unit_array[actionNode->group_unit_array[0]];
+
+	err_when( unitPtr->nation_recno != nation_recno );
+	err_when( !unitPtr->is_visible() );
+
+	//---- figure out the sea region id which the ship should appear ----//
+
+	int unitRegionId = world.get_region_id(unitPtr->next_x_loc(), unitPtr->next_y_loc());
+	int destRegionId = world.get_region_id(actionNode->action_x_loc, actionNode->action_y_loc);
+
+	int seaRegionId = region_array.get_sea_path_region_id(unitRegionId, destRegionId);
+
+	//------- 1. try to locate a ship --------//
+
+	int shipUnitRecno = ai_find_transport_ship(seaRegionId, unitPtr->next_x_loc(), unitPtr->next_y_loc());
+
+	if( !shipUnitRecno )
+		return -1;					// must return -1 instead of 0 as the action must be executed immediately otherwise the units will be assigned with other action and the unit list may no longer be valid
+
+	//---- if this ship is in the harbor, sail it out ----//
+
+	UnitMarine* unitMarine = (UnitMarine*) unit_array[shipUnitRecno];
+
+	if( unitMarine->unit_mode == UNIT_MODE_IN_HARBOR )
+	{
+		FirmHarbor*	firmHarbor = (FirmHarbor*) firm_array[unitMarine->unit_mode_para];
+
+		firmHarbor->sail_ship(unitMarine->sprite_recno, COMMAND_AI);
+	}
+
+	if( !unitMarine->is_visible() )		// no space in the sea for placing the ship 
+		return -1;
+
+	//------ 2. Assign the units to the ship -------//
+
+	unitMarine->ai_action_id = actionNode->action_id;
+
+	err_when( unit_res[unitMarine->unit_id]->unit_class != UNIT_CLASS_SHIP );
+
+	// ##### patch begin Gilbert 5/8 #######//
+	unit_array.assign_to_ship(unitMarine->next_x_loc(), unitMarine->next_y_loc(), 0, actionNode->group_unit_array, actionNode->instance_count, COMMAND_AI, unitMarine->sprite_recno );
+	// ##### patch end Gilbert 5/8 #######//
+
+	for( int i=0 ; i<actionNode->instance_count ; i++ )
+		unit_array[ actionNode->group_unit_array[i] ]->ai_action_id = actionNode->action_id;
+
+	actionNode->instance_count++;		// +1 for the ship
+
+	actionNode->processing_instance_count = actionNode->instance_count-1;		// -1 because when we return 1, it will be increased by 1 automatically
+	actionNode->action_para2 = 0;		// reset it, it is set in Nation::action_finished()
+
+	return 1;
+}
+//-------- End of function Nation::ai_sea_travel -------//
+
+
+//-------- Begin of function Nation::ai_sea_travel2 -------//
+//
+// action_x_loc, action_y_loc - location of the destination
+// action_para2 					- the recno of the ship
+//										  (this is set when the ship has moved to the beach,
+//											the function responsible for setting this is Nation::action_finished() )
+//
+//---------------------------------------------//
+//
+// Procedures:
+//   1. Locate a ship, build one if cannot locate any.
+//   2. Assign the units to the ship.
+// * 3. Move the ship to the destination region.
+//   4. Units disembark on the coast.
+//   5. Units move to the destination.
+//
+//---------------------------------------------//
+//
+int Nation::ai_sea_travel2(ActionNode* actionNode)
+{
+	if( unit_array.is_deleted(actionNode->action_para2) )
+		return -1;
+
+	UnitMarine* unitMarine = (UnitMarine*) unit_array[actionNode->action_para2];
+
+	if( unit_res[unitMarine->unit_id]->unit_class != UNIT_CLASS_SHIP )
+		return -1;
+
+	if( unitMarine->nation_recno != nation_recno )
+		return -1;
+
+	//--------------------------------------------------------//
+
+	int realDestXLoc, realDestYLoc;		// reference vars for returning vars. 
+
+	unitMarine->ship_to_beach( actionNode->action_x_loc, actionNode->action_y_loc, realDestXLoc, realDestYLoc );		// the real destination the ship is moving towards.
+	unitMarine->ai_action_id = actionNode->action_id;
+
+	return 1;
+}
+//-------- End of function Nation::ai_sea_travel2 -------//
+
+
+//-------- Begin of function Nation::ai_sea_travel3 -------//
+//
+// action_x_loc, action_y_loc - location of the destination
+// action_para2 					- the recno of the ship
+//
+//---------------------------------------------//
+//
+// Procedures:
+//   1. Locate a ship, build one if cannot locate any.
+//   2. Assign the units to the ship.
+//   3. Move the ship to the destination region.
+// * 4. Units disembark on the coast.
+// * 5. Units move to the destination.
+//
+//---------------------------------------------//
+//
+int Nation::ai_sea_travel3(ActionNode* actionNode)
+{
+	if( unit_array.is_deleted(actionNode->action_para2) )
+		return -1;
+
+	UnitMarine* unitMarine = (UnitMarine*) unit_array[actionNode->action_para2];
+
+	if( unit_res[unitMarine->unit_id]->unit_class != UNIT_CLASS_SHIP )
+		return -1;
+
+	if( unitMarine->nation_recno != nation_recno )
+		return -1;
+
+	//-------- 4. Units disembark on the coast. -------//
+
+	if( !unitMarine->can_unload_unit() )
+		return 0;
+
+	//--- make a copy of the recnos of the unit on the ship ---//
+
+	short unitRecnoArray[MAX_UNIT_IN_SHIP];
+	short unitCount;
+
+	memcpy( unitRecnoArray, unitMarine->unit_recno_array, sizeof(unitRecnoArray) );
+	unitCount = unitMarine->unit_count;
+
+	unitMarine->unload_all_units(COMMAND_AI);		// unload all units now
+
+	return 1;		// finish the action.
+
+/*
+	//---------- 5. Validate all units ----------//
+
+	for( int i=unitCount-1 ; i>=0 ; i-- )
+	{
+		if( unit_array.is_deleted( unitRecnoArray[i] ) ||
+			 unit_array[ unitRecnoArray[i] ]->nation_recno != nation_recno )
+		{
+			err_when( unitCount > MAX_UNIT_IN_SHIP );
+
+			m.del_array_rec( unitRecnoArray, unitCount, sizeof(unitRecnoArray[0]), i+1 );
+			unitCount--;
+		}
+	}
+
+	if( unitCount==0 )
+		return -1;
+
+	err_when( unitCount < 0 );
+
+	//--- 6. Unit actions after they have arrived the destination region ----//
+
+	int	destXLoc = actionNode->action_x_loc;
+	int	destYLoc = actionNode->action_y_loc;
+	Location* locPtr = world.get_loc(destXLoc, destYLoc);
+
+	switch(actionNode->action_para)
+	{
+		case SEA_ACTION_SETTLE:
+			if( locPtr->is_town() && town_array[locPtr->town_recno()]->nation_recno == nation_recno )
+			{
+				Town *townPtr = town_array[locPtr->town_recno()];
+				unit_array.assign(townPtr->loc_x1, townPtr->loc_y1, 0, COMMAND_AI, unitRecnoArray, unitCount);		// assign to an existing town
+			}
+			else  //-- if there is no town there, the unit will try to settle, if there is no space for settle, settle() will just have the units move to the destination
+			{
+				unit_array.settle(destXLoc, destYLoc, 0, COMMAND_AI, unitRecnoArray, unitCount);		// settle as a new town
+			}
+			break;
+
+		case SEA_ACTION_BUILD_CAMP:
+		{
+			Unit* unitPtr = unit_array[ unitRecnoArray[0] ];
+
+			unitPtr->build_firm(destXLoc, destYLoc, FIRM_CAMP, COMMAND_AI );
+
+			unitPtr->ai_action_id = actionNode->action_id;
+			actionNode->processing_instance_count++;
+			break;
+		}
+
+		case SEA_ACTION_ASSIGN_TO_FIRM:
+			if( check_firm_ready(destXLoc, destYLoc) )
+				unit_array.assign(destXLoc, destYLoc, 0, COMMAND_AI, unitRecnoArray, unitCount);
+			break;
+
+		case SEA_ACTION_MOVE:
+			unit_array.move_to(destXLoc, destYLoc, 0, unitRecnoArray, unitCount, COMMAND_AI);
+			break;
+
+		case SEA_ACTION_NONE:		// just transport them to the specific region and disemark and wait for their own actions
+			break;
+	}
+
+	//---------- set the action id. of the units ---------//
+
+	if( actionNode->action_para != SEA_ACTION_BUILD_CAMP )		// with the exception of SEA_ACTION_BUILD_CAMP, units in all other actions are immediately executed
+	{
+		for( int i=unitCount-1 ; i>=0 ; i-- )
+		{
+			unit_array[ unitRecnoArray[i] ]->ai_action_id = actionNode->action_id;
+			actionNode->processing_instance_count++;
+		}
+	}
+
+	//---------------------------------------------//
+
+	actionNode->processing_instance_count--;		// decrease it by one as it will be increased in process_action()
+
+	actionNode->instance_count = actionNode->processing_instance_count+1;		// set the instance count so process_action() won't cause error.
+
+	return 1;
+*/
+}
+//-------- End of function Nation::ai_sea_travel3 -------//
+
+
+//-------- Begin of function Nation::ai_find_transport_ship -------//
+//
+// Locate a ship for transporting units.
+//
+// <int> seaRegionId			 - region id. of the sea which the ship should appear in.
+// <int> unitXLoc, unitYLoc - the location of the units to be picked up,
+//									   try to select a harbor close to this location.
+// [int] findBest           - whether need to find the best ship or just return
+//									   one if there is one found. (default: 1)
+//
+// return: <int> the recno of the ship located.
+//
+int Nation::ai_find_transport_ship(int seaRegionId, int unitXLoc, int unitYLoc, int findBest)
+{
+	//------- locate a suitable ship --------//
+
+	UnitMarine* unitMarine;
+	int			curRating, bestRating=0, bestUnitRecno=0;
+
+	for( int i=0 ; i<ai_ship_count ; i++ )
+	{
+		unitMarine = (UnitMarine*) unit_array[ ai_ship_array[i] ];
+
+		err_when( unit_res[unitMarine->unit_id]->unit_class != UNIT_CLASS_SHIP );
+
+		if( unitMarine->unit_count > 0 ||										// if there are already units in the ship
+			 unit_res[unitMarine->unit_id]->carry_unit_capacity==0 )		// if the ship does not carry units
+		{
+			continue;
+		}
+
+		//------- if this ship is in the harbor ---------//
+
+		if( unitMarine->unit_mode == UNIT_MODE_IN_HARBOR )
+		{
+			FirmHarbor* firmHarbor = (FirmHarbor*) firm_array[unitMarine->unit_mode_para];
+
+			err_when( firmHarbor->firm_id != FIRM_HARBOR );
+
+			if( firmHarbor->sea_region_id != seaRegionId )
+				continue;
+		}
+
+		//--------- if this ship is on the sea ----------//
+
+		else
+		{
+			if( !unitMarine->is_ai_all_stop() )
+				continue;
+
+			if( unitMarine->region_id() != seaRegionId )
+				continue;
+
+			err_when( !unitMarine->is_visible() );
+
+			if( !unitMarine->is_visible() )
+				continue;
+		}
+
+		//--------- check if the sea region is matched ---------//
+
+		if( !findBest )		// return immediately when a suitable one is found
+			return unitMarine->sprite_recno;
+
+		curRating = world.distance_rating( unitXLoc, unitYLoc,
+						unitMarine->next_x_loc(), unitMarine->next_y_loc() );
+
+		curRating += (int)unitMarine->hit_points/10				// damage
+						 + (int)unitMarine->max_hit_points/10;	// ship class
+
+		if( curRating > bestRating )
+		{
+			bestRating 	  = curRating;
+			bestUnitRecno = unitMarine->sprite_recno;
+		}
+	}
+
+	return bestUnitRecno;
+}
+//-------- End of function Nation::ai_find_transport_ship -------//
+
+
+//-------- Begin of function Nation::ai_build_ship -------//
+//
+// <int> seaRegionId	- region id. of the sea the ship will sail on.
+//
+// <int> preferXLoc, preferYLoc - prefer selecting a harbor that
+//											 is close to this location.
+//
+// <int> needTransportUnit - 1 if need to transport units
+//								  	  0 if the ship is for trading
+//
+// return: <int> the recno of the ship that the harbor has building.
+//
+int Nation::ai_build_ship(int seaRegionId, int preferXLoc, int preferYLoc, int needTransportUnit)
+{
+	//------ select the harbor for building ship -----//
+
+	FirmHarbor *firmHarbor, *bestHarbor=NULL;
+	int	curRating, bestRating=0;
+
+	for( int i=0 ; i<ai_harbor_count ; i++ )
+	{
+		firmHarbor = (FirmHarbor*) firm_array[ ai_harbor_array[i] ];
+
+		err_when( firmHarbor->nation_recno != nation_recno );
+
+		if( !firmHarbor->can_build_ship() )
+			continue;
+
+		if( firmHarbor->sea_region_id != seaRegionId )
+			continue;
+
+		curRating = world.distance_rating( preferXLoc, preferYLoc,
+						firmHarbor->center_x, firmHarbor->center_y );
+
+		if( curRating > bestRating )
+		{
+			bestRating = curRating;
+			bestHarbor = firmHarbor;
+		}
+	}
+
+	if( !bestHarbor )
+		return 0;
+
+	//------ think about the type of ship to build -----//
+
+	int unitId;
+
+	if( needTransportUnit )
+	{
+		if( unit_res[UNIT_GALLEON]->get_nation_tech_level(nation_recno) > 0 )
+			unitId = UNIT_GALLEON;
+
+		else if( unit_res[UNIT_CARAVEL]->get_nation_tech_level(nation_recno) > 0 )
+			unitId = UNIT_GALLEON;
+
+		else
+			unitId = UNIT_VESSEL;
+	}
+	else
+	{
+		if( unit_res[UNIT_GALLEON]->get_nation_tech_level(nation_recno) > 0 )
+			unitId = UNIT_GALLEON;
+		else                       	// don't use Caravel as it can only transport 5 units at a time
+			unitId = UNIT_TRANSPORT;
+	}
+
+	bestHarbor->build_ship( unitId, COMMAND_AI );
+
+	return 1;
+}
+//-------- End of function Nation::ai_build_ship -------//
+
diff --git a/code/train/C++/0080987_pendinglidtracker.cpp b/code/train/C++/0080987_pendinglidtracker.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..42472425f393be35135721dbbca894f68843339e
--- /dev/null
+++ b/code/train/C++/0080987_pendinglidtracker.cpp
@@ -0,0 +1,73 @@
+// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#include "pendinglidtracker.h"
+#include <cassert>
+
+namespace proton {
+
+PendingLidTrackerBase::PendingLidTrackerBase() = default;
+PendingLidTrackerBase::~PendingLidTrackerBase() = default;
+
+ILidCommitState::State
+PendingLidTrackerBase::waitState(State state, uint32_t lid) const {
+    MonitorGuard guard(_mutex);
+    return waitFor(guard, state, lid);
+}
+
+ILidCommitState::State
+PendingLidTrackerBase::waitState(State state, const LidList & lids) const {
+    MonitorGuard guard(_mutex);
+    State lowest = State::COMPLETED;
+    for (uint32_t lid : lids) {
+        State next = waitFor(guard, state, lid);
+        if ((state == State::NEED_COMMIT) && next == state) {
+            return next;
+        }
+        lowest = std::min(next, lowest);
+    }
+    return lowest;
+}
+
+PendingLidTracker::PendingLidTracker() = default;
+
+PendingLidTracker::~PendingLidTracker() {
+    assert(_pending.empty());
+}
+
+IPendingLidTracker::Token
+PendingLidTracker::produce(uint32_t lid) {
+    std::lock_guard guard(_mutex);
+    _pending[lid]++;
+    return Token(lid, *this);
+}
+void
+PendingLidTracker::consume(uint32_t lid) {
+    std::lock_guard guard(_mutex);
+    auto found = _pending.find(lid);
+    assert (found != _pending.end());
+    assert (found->second > 0);
+    if (found->second == 1) {
+        _pending.erase(found);
+        _cond.notify_all();
+    } else {
+        found->second--;
+    }
+}
+
+ILidCommitState::State
+PendingLidTracker::waitFor(MonitorGuard & guard, State state, uint32_t lid) const {
+    for (auto found = _pending.find(lid); found != _pending.end(); found = _pending.find(lid)) {
+        if (state == State::NEED_COMMIT) {
+            return State::WAITING;
+        }
+        _cond.wait(guard);
+    }
+    return State::COMPLETED;
+}
+
+PendingLidTrackerBase::Snapshot
+PendingLidTracker::produceSnapshot() {
+    return Snapshot();
+}
+
+}
diff --git a/code/train/C++/0081416_WalkAlgorithm.cpp b/code/train/C++/0081416_WalkAlgorithm.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..df2c7ce432a1c36f8d70b62eee1e9f2ad5870f71
--- /dev/null
+++ b/code/train/C++/0081416_WalkAlgorithm.cpp
@@ -0,0 +1,203 @@
+/*
+4ti2 -- A software package for algebraic, geometric and combinatorial
+problems on linear spaces.
+
+Copyright (C) 2006 4ti2 team.
+Main author(s): Peter Malkin.
+
+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. 
+*/
+
+#include "WalkAlgorithm.h"
+#include "Completion.h"
+#include "VectorStream.h"
+#include "VectorArrayStream.h"
+#include "BinomialSet.h"
+#include "BinomialSetStream.h"
+#include "FlipCompletion.h"
+#include "BinomialFactory.h"
+#include "Globals.h"
+
+#include <iostream>
+#include <iomanip>
+#include <cstdlib>
+
+//#define DEBUG_4ti2(X) X
+#include "Debug.h"
+
+using namespace _4ti2_;
+
+WalkAlgorithm::WalkAlgorithm()
+{
+    costnew_start = 0;
+    costnew_end = 0;
+    costold_start = 0;
+    costold_end = 0;
+}
+
+WalkAlgorithm::~WalkAlgorithm()
+{
+}
+
+void
+WalkAlgorithm::compute(
+                Feasible& feasible,
+                const VectorArray& costold,
+                VectorArray& vs,
+                const VectorArray& costnew)
+{
+    DEBUG_4ti2(*out << "Cost1:\n" << costold << "\n";)
+    DEBUG_4ti2(*out << "Cost2:\n" << costnew << "\n";)
+    DEBUG_4ti2(*out << "VS:\n" << vs << "\n";)
+    assert(costold.get_number() > 0 && costnew.get_number() > 0);
+    t.reset();
+
+    // TODO: We might need to add cost vectors to the old and new costs.
+    VectorArray costall(costnew);
+    costall.insert(costold);
+
+    BinomialFactory factory(feasible, costall);
+
+    costnew_start = Binomial::cost_start;
+    costnew_end = Binomial::cost_start+costnew.get_number();
+    costold_start = costnew_end;
+    costold_end = Binomial::cost_end;
+
+    BinomialSet bs;
+    factory.convert(vs, bs, false);
+
+    TermOrder term_order(costnew_start, costnew_end, Binomial::rs_end);
+
+    // TODO: Perhaps the following value should be an command line option.
+    const int reduction_freq = 200;
+
+    int iteration = 0;
+    DEBUG_4ti2(*out << "\nBefore BINOMIALS:\n" << bs << "\n";)
+    int n;
+    Binomial b;
+    FlipCompletion alg;
+    while(!next(bs, term_order, n))
+    {
+        if (iteration % Globals::output_freq == 0) 
+        {
+            *out << "\r";
+            *out << std::setiosflags(std::ios_base::right);
+            *out << "Iteration = " << std::setw(6) << iteration;
+            *out << " Size = " << std::setw(6) << bs.get_number();
+            *out << " tvalue " << std::setw(6) << std::setprecision(4);
+            *out << std::resetiosflags(std::ios_base::right);
+            *out << std::setiosflags(std::ios_base::left);
+            *out << tvalue(bs[n]) << std::flush;
+            *out << std::resetiosflags(std::ios_base::left);
+        }
+        DEBUG_4ti2(*out << "Iteration " << iteration << "\n";)
+        DEBUG_4ti2(*out << "\nBefore BINOMIALS:\n" << bs << "\n";)
+        b = bs[n];
+        bs.remove(n);
+        if (!bs.reducable(b))
+        {
+            b.flip();
+            alg.algorithm(bs, b);
+            bs.add(b);
+            if (iteration % reduction_freq == 0)
+            { bs.minimal(); bs.reduced(); } 
+            DEBUG_4ti2(*out << "Size: " << std::setw(6) << bs.get_number() << "\n";)
+            DEBUG_4ti2(*out << "After BINOMIALS:\n" << bs << "\n";)
+            ++iteration;
+        }
+    }
+    bs.minimal();
+    bs.reduced();
+    factory.convert(bs, vs);
+    vs.sort();
+    bs.clear();
+
+    DEBUG_4ti2(*out << "VS:\n" << vs << "\n";)
+    *out << "\r" << Globals::context;
+    *out << "Iteration = " << std::setw(6) << iteration;
+    *out << " Size: " << std::setw(6) << vs.get_number();
+    *out << ", Time: " << t << " / ";
+    *out << Timer::global << " secs. Done." << std::endl;
+}
+
+IntegerType
+WalkAlgorithm::compare(const Binomial& b1, const Binomial& b2)
+{
+    IntegerType result;
+    for (int i = costnew_start; i < costnew_end; ++i)
+    {
+        for (int j = costold_start; j < costold_end; ++j)
+        {
+            result = b1[j]*b2[i]-b1[i]*b2[j];
+            if (result != 0) { return result; }
+        }
+        for (int j = 0; j < Binomial::rs_end; j++)
+        {
+            result = -b1[j]*b2[i]+b1[i]*b2[j];
+            if (result != 0) { return result; }
+        }
+    }
+    for (int i = 0; i < Binomial::rs_end; i++)
+    {
+        for (int j = costold_start; j < costold_end; ++j)
+        {
+            result = -b1[j]*b2[i]+b1[i]*b2[j];
+            if (result != 0) { return result; }
+        }
+        for (int j = 0; j < Binomial::rs_end; j++)
+        {
+            result = b1[j]*b2[i]-b1[i]*b2[j];
+            if (result != 0) { return result; }
+        }
+    }
+    std::cerr << "Software Error: unexpected execution.\n";
+    exit(1);
+    return 0;
+}
+
+RationalType
+WalkAlgorithm::tvalue(const Binomial& b)
+{
+    return (RationalType)b[costold_start]/(b[costold_start]-b[costnew_start]);
+}
+
+void
+WalkAlgorithm::tvector(Vector& c1, Vector& c2, Vector& v, Vector& tv)
+{
+    Vector::sub(c2, Vector::dot(c1,v), c1, Vector::dot(c2,v), tv);
+}
+
+bool
+WalkAlgorithm::next(const BinomialSet& bs, const TermOrder& term_order, int& min)
+{
+    min = 0;
+    while (min < bs.get_number())
+    {
+        if (TermOrder::direction(term_order, bs[min]) < 0) { break; }
+        else { ++min; }
+    }
+    if (min == bs.get_number()) { return true; }
+    DEBUG_4ti2(*out << min << " tvalue = " << tvalue(bs[min]) << "\n";)
+    for (int i = min+1; i < bs.get_number(); ++i)
+    {
+        if (TermOrder::direction(term_order, bs[i]) < 0)
+        {
+            DEBUG_4ti2(*out << i << " tvalue = " << tvalue(bs[i]) << "\n";)
+            if (compare(bs[min], bs[i]) < 0) { min = i; }
+        }
+    }
+    DEBUG_4ti2(*out << min << " min tvalue = " << tvalue(bs[min]) << "\n";)
+    return false;
+}
diff --git a/code/train/C++/0081629_ARIN_cache.cpp b/code/train/C++/0081629_ARIN_cache.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6b9bf39616a1d5f6ceb9d248a1a7590b38ea791c
--- /dev/null
+++ b/code/train/C++/0081629_ARIN_cache.cpp
@@ -0,0 +1,196 @@
+
+/*
+
+ ARIN_cache.cpp
+   
+   Copyright (c) 2003-2008 by Philippe Bourcier
+   
+   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, 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.
+
+*/
+
+#include <string>
+#include <string.h>
+#include <iostream>
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+using std::string;
+using std::cout;
+using std::endl;
+
+#define STRRET "\n"
+
+u_long ip2long(string ip_str) {
+const char *ip_chr=ip_str.c_str();
+struct in_addr addr;
+if(inet_aton(ip_chr, &addr)) return (u_long)ntohl((u_long)addr.s_addr);
+else return 0;
+}
+
+string php_strtok(string &str, string tok) {
+        size_t len=str.find_first_of(tok,0);
+        string tmpstr="";
+
+        if (len>0) {
+                tmpstr = str.substr(0,len);
+                if (len<str.size()) str=str.substr(len+1,str.size()-len+1);
+                else str="";
+        }
+        else {
+                tmpstr = str;
+                str ="";
+        }
+return tmpstr;
+}
+
+string php_trim(string str, string in="\n\r\t\v ") {
+        if(str=="") return "";
+        size_t a = str.find_first_not_of(in);
+        size_t b = str.find_last_not_of(in)+1;
+if(a!=b) return str.substr(a,b-a);
+else return "";
+}
+
+int php_substr_count(string str, string needle) {
+
+string::size_type lenstr=str.size();
+string::size_type len=needle.size();
+
+int count=0;
+int old = 0;
+int n = 0;
+
+
+if (len==0 || lenstr==0) { return(count); }
+
+if (len==1) {
+        for(size_t i=0;i<lenstr;i++) {
+                if (str[i]==needle[0]) { count++; }
+        } 
+}
+else {
+
+string p = str.substr(0,len);
+
+        for(int i=0,max=lenstr+len;i<max;i+=len) {
+                n = p.rfind(needle);
+                p = str.substr(0,i);
+                if (old!=n && n>=0) count++;
+                old = n;
+        }
+}
+
+return(count);
+
+}
+
+bool bigerx(string line) {
+if(line.find("-0-0-0-0)")<line.size() && line.find("-ERX-")<line.size()) return true;
+return false;
+}
+
+string do_whois(string whois_q) {
+
+        int s;
+        string whois="whois.arin.net";
+        const char *host=whois.c_str();
+        FILE *sfi, *sfo;
+        char buf[1024];
+        size_t len;
+        string result;
+        string tmp;
+
+        struct sockaddr_in server;
+        struct sockaddr_in local;
+        struct hostent *hostinfo;
+
+        int port = 43;
+
+        whois_q="! > "+whois_q;
+        const char *query=whois_q.c_str();
+
+        if((hostinfo=gethostbyname(host))==NULL) exit(1);
+
+        memset((char *) &local, 0, sizeof(struct sockaddr));
+
+        local.sin_family = AF_INET;
+        local.sin_port = htons(0);
+        memset((char *) &server, 0, sizeof(struct sockaddr));
+        memcpy((char *) &server.sin_addr, hostinfo->h_addr, hostinfo->h_length);
+        server.sin_family = AF_INET;
+        server.sin_port = htons(port);
+
+        if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) exit(1);
+        if(bind(s, (struct sockaddr *) &local, sizeof(struct sockaddr)) < 0) exit(1);
+        if (connect(s, (struct sockaddr *) &server, sizeof(struct sockaddr)) < 0) exit(1);
+
+        sfi = fdopen(s, "r");
+        sfo = fdopen(s, "w");
+
+        if (sfi == NULL || sfo == NULL) exit(1);
+
+        fprintf(sfo, "%s\r\n", query);
+        fflush(sfo);
+
+        while(fgets(buf, 1024, sfi)) {
+                len = strlen(buf);
+                while (len && isspace((int)buf[len-1])) buf[--len] = '\0';
+                tmp = string(buf);
+                if (tmp!="" && tmp.find("NET-")<tmp.size() && !bigerx(tmp)) result += php_trim(tmp.substr(tmp.find(")")+1)) + STRRET;
+        }
+
+return result;
+
+}
+
+void sqlmaker(string whoisres,string IR) {
+  size_t where;
+  int max=php_substr_count(whoisres,STRRET);
+  string line="";
+  string ipstart="";
+  string ipstop="";
+        for(int i=0;i<max;i++) {
+		line=php_strtok(whoisres,STRRET);
+                where=line.find_first_of("-",0);
+                if(where>0){
+                        ipstart=php_trim(line.substr(0,(where-1)));
+                        ipstop =php_trim(line.substr((where+2),(line.size()-1)));
+                        cout << "insert into ARIN_cache values ('" << IR << "', '" << ip2long(ipstart) << "', '" << ip2long(ipstop) << "');" << endl;
+                }
+        }
+}
+
+int main() {
+
+	sqlmaker(do_whois("RIPE"),"whois.ripe.net");
+	sqlmaker(do_whois("IANA"),"IANA");
+	sqlmaker(do_whois("APNIC"),"whois.apnic.net");
+	sqlmaker(do_whois("JAPANI"),"whois.v6nic.net");
+	sqlmaker(do_whois("LACNIC"),"whois.lacnic.net");
+	sqlmaker(do_whois("JNIC"),"whois.nic.ad.jp");
+	sqlmaker(do_whois("AFRINIC"),"whois.afrinic.net");
+
+return(0);
+
+}
+
diff --git a/code/train/C++/0081650_TrustRegionNewton.cpp b/code/train/C++/0081650_TrustRegionNewton.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..39ad886c9551f7e0ec75148308a1607b02eb0e03
--- /dev/null
+++ b/code/train/C++/0081650_TrustRegionNewton.cpp
@@ -0,0 +1,183 @@
+/*!
+ * 
+ *
+ * \brief       Trust-Region Newton-Step Method
+ * 
+ * 
+ * 
+ * 
+ *
+ * \author      O. Krause
+ * \date        2015
+ *
+ *
+ * \par Copyright 1995-2015 Shark Development Team
+ * 
+ * <BR><HR>
+ * This file is part of Shark.
+ * <http://image.diku.dk/shark/>
+ * 
+ * Shark 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 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * Shark 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 Shark.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#define SHARK_COMPILE_DLL
+#include <shark/Algorithms/GradientDescent/TrustRegionNewton.h>
+#include <shark/LinAlg/solveSystem.h>
+
+using namespace shark;
+
+namespace{
+	/// \brief Compute the maximal step size given point z, direction, and trust region radius delta.
+	double borderDistance(
+		RealVector const& z, 
+		RealVector const& direction,
+		double delta
+	){
+		double z2=norm_sqr(z);
+		double d2=norm_sqr(direction);
+		assert(z2 <= d2);   // otherwise z is outside the trust region and the square root will give a NaN
+
+		//find tau such that ||z+tau*d||=delta
+		//using p-q formula
+		double p = 2*inner_prod(direction,z)/d2;
+		double q=(z2-sqr(delta))/d2;
+
+		double tau = p/2 + std::sqrt(sqr(p/2) - q);
+		return tau;	
+	}
+
+	/// \brief Compute the function value improvement from step, residual, and gradient.
+	double errorDifference(RealVector const& step, RealVector const& residual, RealVector const& gradient){
+		double diff = inner_prod(residual,step)+inner_prod(gradient,step);
+		return diff/2;
+	}
+
+	/// \brief CG-Variant that finds an approximate solution inside a trust region.
+	///
+	/// This variant of CG runs until either the solution is sufficiently accurate
+	/// (norm of the gradient below the given tolerance) or the step hits the border
+	/// of the trust region.
+	///
+	/// Returns the improvement in function value and the solution as a pair.
+	///
+	/// Algorithm 7.1 in Wright, Nocedal: Numerical Optimization
+	std::pair<double,RealVector> trustRegionCG(
+		RealMatrix const& hessian,
+		RealVector gradient,
+		double tolerance,   // bound on the norm of the gradient
+		double delta        // trust region size (radius)
+	){
+		RealVector residual = gradient;
+		RealVector direction = -gradient;
+		std::pair<double,RealVector> solution(0.0,RealVector(residual.size(),0.0));
+		RealVector& step = solution.second;
+		
+		double currentNormRes2 = norm_sqr(residual);
+		if( currentNormRes2 <sqr(tolerance))
+			return solution;
+
+		for(std::size_t iter = 0; iter != 10*gradient.size(); ++iter ){//numerical safeguard(should never be called)
+			RealVector Hdir=prod(hessian,direction);
+			double normH=inner_prod(direction, Hdir);
+			// if our Hessian is not positive definite then we just run to the boundary
+			if(normH <= 0){
+				double tau= borderDistance(step,direction,delta);
+				noalias(step) += tau*direction;
+				noalias(residual) += tau*Hdir;
+				solution.first=errorDifference(step,residual,gradient);
+				return solution;
+			}
+			double alpha = currentNormRes2/normH;   // compute step size
+			// if the step brings us to the boundary then return the boundary point
+			if(norm_sqr(step+alpha*direction) >= sqr(delta)){
+				double tau= borderDistance(step,direction,delta);
+				noalias(step) += tau*direction;
+				noalias(residual) += tau*Hdir;
+				solution.first=errorDifference(step,residual,gradient);
+				return solution;
+			}
+			//update point, residual and direction
+			noalias(step) +=alpha*direction;
+			noalias(residual) +=alpha*Hdir;
+			double normRes2 = norm_sqr(residual);
+
+			// check accuracy-based stopping criterion
+			if(normRes2 < sqr(tolerance)){
+				solution.first=errorDifference(step,residual,gradient);
+				return solution;
+			}
+			double beta = normRes2/currentNormRes2;
+			noalias(direction) *= beta;
+			noalias(direction) -= residual;
+			currentNormRes2 = normRes2;
+		}
+		return solution; // added by CI
+	}
+}
+
+TrustRegionNewton::TrustRegionNewton()
+{
+	m_features |= REQUIRES_VALUE;
+	m_features |= REQUIRES_FIRST_DERIVATIVE;
+	m_features |= REQUIRES_SECOND_DERIVATIVE;
+}
+
+void TrustRegionNewton::init(ObjectiveFunctionType& objectiveFunction, SearchPointType const& startingPoint, double initialDelta) {
+	checkFeatures(objectiveFunction);
+	objectiveFunction.init();
+
+	m_delta = initialDelta;
+	m_minImprovementRatio = 0.1;
+	
+	m_best.point = startingPoint;
+	m_best.value = objectiveFunction.evalDerivative(m_best.point,m_derivatives);
+}
+
+void TrustRegionNewton::step(const ObjectiveFunctionType& objectiveFunction) {
+	//compute step in approximated sub-system
+	double gradNorm_2 = norm_2( m_derivatives.gradient);
+	//Computing the forcing schedule for the solution
+	//we set the tolerance in terms of the gradient norm, that is epsilon = gamma*||g||. If we set gamma<1 to a constant value
+	//the solution found will approach the optimum linearly. more exactly in a quadratic model with exact hessian, the gradient
+	//after k iterations will have length gamma^k*||g|| (assuming the trust-region bound is not a problem).
+	//thus gamma in a quadratic model is exactly the convergence constant. To obtain superlinear convergence, we have to
+	//find a schedule such that gamma ->0. This can be achieved by setting gamma =sqrt(||g||) once the gradient norm is smaller than sqrt(0.5).
+	//we choose gamma such that we have linear convergence as long as we are far away from the optimum, (defined as ||g||>=1) 
+	//and sqrt(||g||) when we are close. We could use a faster converging schedule, but it is not clear whether this is always good on a 
+	//non-quadratic function, even though in the end quadratic convergence is obtained - however getting close enough might take a long time 
+	//if we spend too much time on solving the newton steps before we enter this region(which might be extremely small!)
+	//The initial guess of 0.5 might be too optimistic and we still spend a lot of time on finding the solution, but this is hugely problem dependent.
+	double gamma =std::min(0.5,std::sqrt(gradNorm_2));
+	double tolerance = gamma* gradNorm_2;
+	std::pair<double,RealVector> solution =  trustRegionCG(m_derivatives.hessian, m_derivatives.gradient, tolerance, m_delta);
+	if (solution.first == 0) return;//we are done
+
+	//calculate the function value improvement of the point compared to the model prediction
+	double newValue = objectiveFunction(m_best.point + solution.second);
+	double functionImprovement = newValue - m_best.value;
+	double rho = functionImprovement / solution.first;   // improvement relative to model forecast
+
+	//update trust region size if the observed improvement is large or very small compared to the prediction
+	if(rho < 0.25){
+		m_delta /= 4;   // shrink trust region size
+	}else if(rho > 0.75 && norm_sqr(solution.second) > 0.99*sqr(m_delta)){
+		m_delta *= 2;   // grow trust region size
+	}
+
+	//accept the point only if the improvement is significant
+	if(rho >= m_minImprovementRatio){
+		noalias(m_best.point) +=solution.second;
+		m_best.value = objectiveFunction.evalDerivative(m_best.point,m_derivatives);
+	}
+}
diff --git a/code/train/C++/0081891_tx_verify.cpp b/code/train/C++/0081891_tx_verify.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ae98b609e6599720b68f4962474e231ebe6a829b
--- /dev/null
+++ b/code/train/C++/0081891_tx_verify.cpp
@@ -0,0 +1,253 @@
+// Copyright (c) 2017-2017 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "tx_verify.h"
+
+#include "consensus.h"
+#include "primitives/transaction.h"
+#include "script/interpreter.h"
+#include "validation.h"
+
+// TODO remove the following dependencies
+#include "chain.h"
+#include "coins.h"
+#include "utilmoneystr.h"
+
+bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime)
+{
+    if (tx.nLockTime == 0)
+        return true;
+    if ((int64_t)tx.nLockTime < ((int64_t)tx.nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
+        return true;
+    for (const auto& txin : tx.vin) {
+        if (!(txin.nSequence == CTxIn::SEQUENCE_FINAL))
+            return false;
+    }
+    return true;
+}
+
+std::pair<int, int64_t> CalculateSequenceLocks(const CTransaction &tx, int flags, std::vector<int>* prevHeights, const CBlockIndex& block)
+{
+    assert(prevHeights->size() == tx.vin.size());
+
+    // Will be set to the equivalent height- and time-based nLockTime
+    // values that would be necessary to satisfy all relative lock-
+    // time constraints given our view of block chain history.
+    // The semantics of nLockTime are the last invalid height/time, so
+    // use -1 to have the effect of any height or time being valid.
+    int nMinHeight = -1;
+    int64_t nMinTime = -1;
+
+    // tx.nVersion is signed integer so requires cast to unsigned otherwise
+    // we would be doing a signed comparison and half the range of nVersion
+    // wouldn't support BIP 68.
+    bool fEnforceBIP68 = static_cast<uint32_t>(tx.nVersion) >= 2
+                         && flags & LOCKTIME_VERIFY_SEQUENCE;
+
+    // Do not enforce sequence numbers as a relative lock time
+    // unless we have been instructed to
+    if (!fEnforceBIP68) {
+        return std::make_pair(nMinHeight, nMinTime);
+    }
+
+    for (size_t txinIndex = 0; txinIndex < tx.vin.size(); txinIndex++) {
+        const CTxIn& txin = tx.vin[txinIndex];
+
+        // Sequence numbers with the most significant bit set are not
+        // treated as relative lock-times, nor are they given any
+        // consensus-enforced meaning at this point.
+        if (txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_DISABLE_FLAG) {
+            // The height of this input is not relevant for sequence locks
+            (*prevHeights)[txinIndex] = 0;
+            continue;
+        }
+
+        int nCoinHeight = (*prevHeights)[txinIndex];
+
+        if (txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG) {
+            int64_t nCoinTime = block.GetAncestor(std::max(nCoinHeight-1, 0))->GetMedianTimePast();
+            // NOTE: Subtract 1 to maintain nLockTime semantics
+            // BIP 68 relative lock times have the semantics of calculating
+            // the first block or time at which the transaction would be
+            // valid. When calculating the effective block time or height
+            // for the entire transaction, we switch to using the
+            // semantics of nLockTime which is the last invalid block
+            // time or height.  Thus we subtract 1 from the calculated
+            // time or height.
+
+            // Time-based relative lock-times are measured from the
+            // smallest allowed timestamp of the block containing the
+            // txout being spent, which is the median time past of the
+            // block prior.
+            nMinTime = std::max(nMinTime, nCoinTime + (int64_t)((txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_MASK) << CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) - 1);
+        } else {
+            nMinHeight = std::max(nMinHeight, nCoinHeight + (int)(txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_MASK) - 1);
+        }
+    }
+
+    return std::make_pair(nMinHeight, nMinTime);
+}
+
+bool EvaluateSequenceLocks(const CBlockIndex& block, std::pair<int, int64_t> lockPair)
+{
+    assert(block.pprev);
+    int64_t nBlockTime = block.pprev->GetMedianTimePast();
+    if (lockPair.first >= block.nHeight || lockPair.second >= nBlockTime)
+        return false;
+
+    return true;
+}
+
+bool SequenceLocks(const CTransaction &tx, int flags, std::vector<int>* prevHeights, const CBlockIndex& block)
+{
+    return EvaluateSequenceLocks(block, CalculateSequenceLocks(tx, flags, prevHeights, block));
+}
+
+unsigned int GetLegacySigOpCount(const CTransaction& tx)
+{
+    unsigned int nSigOps = 0;
+    for (const auto& txin : tx.vin)
+    {
+        nSigOps += txin.scriptSig.GetSigOpCount(false);
+    }
+    for (const auto& txout : tx.vout)
+    {
+        nSigOps += txout.scriptPubKey.GetSigOpCount(false);
+    }
+    return nSigOps;
+}
+
+unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& inputs)
+{
+    if (tx.IsCoinBase())
+        return 0;
+
+    unsigned int nSigOps = 0;
+    for (unsigned int i = 0; i < tx.vin.size(); i++)
+    {
+        const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
+        assert(!coin.IsSpent());
+        const CTxOut &prevout = coin.out;
+        if (prevout.scriptPubKey.IsPayToScriptHash())
+            nSigOps += prevout.scriptPubKey.GetSigOpCount(tx.vin[i].scriptSig);
+    }
+    return nSigOps;
+}
+
+unsigned int GetTransactionSigOpCount(const CTransaction& tx, const CCoinsViewCache& inputs, int flags)
+{
+    unsigned int nSigOps = GetLegacySigOpCount(tx);
+
+    if (tx.IsCoinBase())
+        return nSigOps;
+
+    if (flags & SCRIPT_VERIFY_P2SH) {
+        nSigOps += GetP2SHSigOpCount(tx, inputs);
+    }
+
+    return nSigOps;
+}
+
+bool CheckTransaction(const CTransaction& tx, CValidationState &state)
+{
+    bool allowEmptyTxInOut = false;
+    if (tx.nType == TRANSACTION_QUORUM_COMMITMENT) {
+        allowEmptyTxInOut = true;
+    }
+
+    // Basic checks that don't depend on any context
+    if (!allowEmptyTxInOut && tx.vin.empty())
+        return state.DoS(10, false, REJECT_INVALID, "bad-txns-vin-empty");
+    if (!allowEmptyTxInOut && tx.vout.empty())
+        return state.DoS(10, false, REJECT_INVALID, "bad-txns-vout-empty");
+    // Size limits
+    if (::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION) > MAX_LEGACY_BLOCK_SIZE)
+        return state.DoS(100, false, REJECT_INVALID, "bad-txns-oversize");
+    if (tx.vExtraPayload.size() > MAX_TX_EXTRA_PAYLOAD)
+        return state.DoS(100, false, REJECT_INVALID, "bad-txns-payload-oversize");
+
+    // Check for negative or overflow output values
+    CAmount nValueOut = 0;
+    for (const auto& txout : tx.vout)
+    {
+        if (txout.nValue < 0)
+            return state.DoS(100, false, REJECT_INVALID, "bad-txns-vout-negative");
+        if (txout.nValue > MAX_MONEY)
+            return state.DoS(100, false, REJECT_INVALID, "bad-txns-vout-toolarge");
+        nValueOut += txout.nValue;
+        if (!MoneyRange(nValueOut))
+            return state.DoS(100, false, REJECT_INVALID, "bad-txns-txouttotal-toolarge");
+    }
+
+    // Check for duplicate inputs
+    std::set<COutPoint> vInOutPoints;
+    for (const auto& txin : tx.vin)
+    {
+        if (!vInOutPoints.insert(txin.prevout).second)
+            return state.DoS(100, false, REJECT_INVALID, "bad-txns-inputs-duplicate");
+    }
+
+    if (tx.IsCoinBase())
+    {
+        size_t minCbSize = 2;
+        if (tx.nType == TRANSACTION_COINBASE) {
+            // With the introduction of CbTx, coinbase scripts are not required anymore to hold a valid block height
+            minCbSize = 1;
+        }
+        if (tx.vin[0].scriptSig.size() < minCbSize || tx.vin[0].scriptSig.size() > 100)
+            return state.DoS(100, false, REJECT_INVALID, "bad-cb-length");
+    }
+    else
+    {
+        for (const auto& txin : tx.vin)
+            if (txin.prevout.IsNull())
+                return state.DoS(10, false, REJECT_INVALID, "bad-txns-prevout-null");
+    }
+
+    return true;
+}
+
+bool Consensus::CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee)
+{
+    // are the actual inputs available?
+    if (!inputs.HaveInputs(tx)) {
+        return state.DoS(100, false, REJECT_INVALID, "bad-txns-inputs-missingorspent", false,
+                         strprintf("%s: inputs missing/spent", __func__));
+    }
+
+    CAmount nValueIn = 0;
+    for (unsigned int i = 0; i < tx.vin.size(); ++i) {
+        const COutPoint &prevout = tx.vin[i].prevout;
+        const Coin& coin = inputs.AccessCoin(prevout);
+        assert(!coin.IsSpent());
+
+        // If prev is coinbase, check that it's matured
+        if (coin.IsCoinBase() && nSpendHeight - coin.nHeight < COINBASE_MATURITY) {
+            return state.Invalid(false,
+                REJECT_INVALID, "bad-txns-premature-spend-of-coinbase",
+                strprintf("tried to spend coinbase at depth %d", nSpendHeight - coin.nHeight));
+        }
+
+        // Check for negative or overflow input values
+        nValueIn += coin.out.nValue;
+        if (!MoneyRange(coin.out.nValue) || !MoneyRange(nValueIn)) {
+            return state.DoS(100, false, REJECT_INVALID, "bad-txns-inputvalues-outofrange");
+        }
+    }
+
+    const CAmount value_out = tx.GetValueOut();
+    if (nValueIn < value_out) {
+        return state.DoS(100, false, REJECT_INVALID, "bad-txns-in-belowout", false,
+            strprintf("value in (%s) < value out (%s)", FormatMoney(nValueIn), FormatMoney(value_out)));
+    }
+
+    // Tally transaction fees
+    const CAmount txfee_aux = nValueIn - value_out;
+    if (!MoneyRange(txfee_aux)) {
+        return state.DoS(100, false, REJECT_INVALID, "bad-txns-fee-outofrange");
+    }
+
+    txfee = txfee_aux;
+    return true;
+}
diff --git a/code/train/C++/0082258_dumper.cpp b/code/train/C++/0082258_dumper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3c1a1f8daec7e46f15ae770c3528c46afb7c83f2
--- /dev/null
+++ b/code/train/C++/0082258_dumper.cpp
@@ -0,0 +1,232 @@
+#include "generator/dumper.hpp"
+
+#include "search/search_index_values.hpp"
+#include "search/search_trie.hpp"
+
+#include "indexer/classificator.hpp"
+#include "indexer/feature_processor.hpp"
+#include "indexer/trie_reader.hpp"
+#include "indexer/search_delimiters.hpp"
+#include "indexer/search_string_utils.hpp"
+
+#include "coding/multilang_utf8_string.hpp"
+
+#include "base/logging.hpp"
+
+#include <algorithm>
+#include <functional>
+#include <iostream>
+#include <map>
+#include <vector>
+
+using namespace std;
+
+namespace
+{
+template <typename TValue>
+struct SearchTokensCollector
+{
+  SearchTokensCollector() : m_currentS(), m_currentCount(0) {}
+
+  void operator()(strings::UniString const & s, TValue const & /* value */)
+  {
+    if (m_currentS != s)
+    {
+      if (m_currentCount > 0)
+        m_tokens.emplace_back(m_currentCount, m_currentS);
+      m_currentS = s;
+      m_currentCount = 0;
+    }
+    ++m_currentCount;
+  }
+
+  void Finish()
+  {
+    if (m_currentCount > 0)
+      m_tokens.emplace_back(m_currentCount, m_currentS);
+    sort(m_tokens.begin(), m_tokens.end(), greater<pair<uint32_t, strings::UniString>>());
+  }
+
+  vector<pair<uint32_t, strings::UniString>> m_tokens;
+  strings::UniString m_currentS;
+  uint32_t m_currentCount;
+};
+}  // namespace
+
+namespace feature
+{
+  class TypesCollector
+  {
+    vector<uint32_t> m_currFeatureTypes;
+
+  public:
+    typedef map<vector<uint32_t>, size_t> value_type;
+    value_type m_stats;
+    size_t m_namesCount;
+    size_t m_totalCount;
+
+    TypesCollector() : m_namesCount(0), m_totalCount(0) {}
+
+    void operator()(FeatureType & f, uint32_t)
+    {
+      ++m_totalCount;
+      string s1, s2;
+      f.GetPreferredNames(s1, s2);
+      if (!s1.empty())
+        ++m_namesCount;
+
+      m_currFeatureTypes.clear();
+      f.ForEachType([this](uint32_t type)
+      {
+        m_currFeatureTypes.push_back(type);
+      });
+      CHECK(!m_currFeatureTypes.empty(), ("Feature without any type???"));
+
+      auto found = m_stats.insert(make_pair(m_currFeatureTypes, 1));
+      if (!found.second)
+        found.first->second++;
+    }
+  };
+
+  template <class T>
+  static bool SortFunc(T const & first, T const & second)
+  {
+    return first.second > second.second;
+  }
+
+  void DumpTypes(string const & fPath)
+  {
+    TypesCollector doClass;
+    feature::ForEachFromDat(fPath, doClass);
+
+    typedef pair<vector<uint32_t>, size_t> stats_elem_type;
+    typedef vector<stats_elem_type> vec_to_sort;
+    vec_to_sort vecToSort(doClass.m_stats.begin(), doClass.m_stats.end());
+    sort(vecToSort.begin(), vecToSort.end(), &SortFunc<stats_elem_type>);
+
+    for (vec_to_sort::iterator it = vecToSort.begin(); it != vecToSort.end(); ++it)
+    {
+      cout << it->second << " ";
+      for (size_t i = 0; i < it->first.size(); ++i)
+        cout << classif().GetFullObjectName(it->first[i]) << " ";
+      cout << endl;
+    }
+    cout << "Total features: " << doClass.m_totalCount << endl;
+    cout << "Features with names: " << doClass.m_namesCount << endl;
+  }
+
+  ///////////////////////////////////////////////////////////////////
+
+  typedef map<int8_t, map<strings::UniString, pair<unsigned int, string> > > TokensContainerT;
+  class PrefixesCollector
+  {
+  public:
+    TokensContainerT m_stats;
+
+    void operator()(int8_t langCode, string const & name)
+    {
+      CHECK(!name.empty(), ("Feature name is empty"));
+
+      vector<strings::UniString> tokens;
+      search::SplitUniString(search::NormalizeAndSimplifyString(name),
+                             MakeBackInsertFunctor(tokens), search::Delimiters());
+
+      if (tokens.empty())
+        return;
+
+      for (size_t i = 1; i < tokens.size(); ++i)
+      {
+        strings::UniString s;
+        for (size_t numTokens = 0; numTokens < i; ++numTokens)
+        {
+          s.append(tokens[numTokens].begin(), tokens[numTokens].end());
+          s.push_back(' ');
+        }
+        pair<TokensContainerT::mapped_type::iterator, bool> found =
+            m_stats[langCode].insert(make_pair(s, make_pair(1U, name)));
+        if (!found.second)
+          found.first->second.first++;
+      }
+    }
+
+    void operator()(FeatureType & f, uint32_t)
+    {
+      f.ForEachName(*this);
+    }
+  };
+
+  static size_t const MIN_OCCURRENCE = 3;
+
+  void Print(int8_t langCode, TokensContainerT::mapped_type const & container)
+  {
+    typedef pair<strings::UniString, pair<unsigned int, string> > NameElemT;
+    typedef vector<NameElemT> VecToSortT;
+
+    VecToSortT v(container.begin(), container.end());
+    sort(v.begin(), v.end(), &SortFunc<NameElemT>);
+
+    // do not display prefixes with low occurrences
+    if (v[0].second.first > MIN_OCCURRENCE)
+    {
+      cout << "Language code: " << StringUtf8Multilang::GetLangByCode(langCode) << endl;
+
+      for (VecToSortT::iterator it = v.begin(); it != v.end(); ++it)
+      {
+        if (it->second.first <= MIN_OCCURRENCE)
+          break;
+        cout << it->second.first << " " << strings::ToUtf8(it->first);
+        cout << " \"" << it->second.second << "\"" << endl;
+      }
+    }
+  }
+
+  void DumpPrefixes(string const & fPath)
+  {
+    PrefixesCollector doClass;
+    feature::ForEachFromDat(fPath, doClass);
+    for (TokensContainerT::iterator it = doClass.m_stats.begin();
+         it != doClass.m_stats.end(); ++it)
+    {
+      Print(it->first, it->second);
+    }
+  }
+
+  void DumpSearchTokens(string const & fPath, size_t maxTokensToShow)
+  {
+    using TValue = FeatureIndexValue;
+
+    FilesContainerR container(make_unique<FileReader>(fPath));
+    feature::DataHeader header(container);
+    serial::CodingParams codingParams(trie::GetCodingParams(header.GetDefCodingParams()));
+
+    auto const trieRoot = trie::ReadTrie<ModelReaderPtr, ValueList<TValue>>(
+        container.GetReader(SEARCH_INDEX_FILE_TAG), SingleValueSerializer<TValue>(codingParams));
+
+    SearchTokensCollector<TValue> f;
+    trie::ForEachRef(*trieRoot, f, strings::UniString());
+    f.Finish();
+
+    for (size_t i = 0; i < min(maxTokensToShow, f.m_tokens.size()); ++i)
+    {
+      auto const & s = f.m_tokens[i].second;
+      cout << f.m_tokens[i].first << " " << strings::ToUtf8(s) << endl;
+    }
+  }
+
+  void DumpFeatureNames(string const & fPath, string const & lang)
+  {
+    int8_t const langIndex = StringUtf8Multilang::GetLangIndex(lang);
+    auto printName = [&](int8_t langCode, string const & name) {
+      CHECK(!name.empty(), ("Feature name is empty"));
+      if (langIndex == StringUtf8Multilang::kUnsupportedLanguageCode)
+        cout << StringUtf8Multilang::GetLangByCode(langCode) << ' ' << name << endl;
+      else if (langCode == langIndex)
+        cout << name << endl;
+    };
+
+    feature::ForEachFromDat(fPath, [&](FeatureType & f, uint32_t)
+                            {
+                              f.ForEachName(printName);
+                            });
+  }
+}  // namespace feature
diff --git a/code/train/C++/0082877_C.cpp b/code/train/C++/0082877_C.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..15b609ddfe8d5a9909016fbcf87e5f6de846844d
--- /dev/null
+++ b/code/train/C++/0082877_C.cpp
@@ -0,0 +1,135 @@
+#include<stdio.h>
+#include<stdlib.h>
+#include<time.h>
+#include<math.h>
+#include<assert.h>
+#include<string.h>
+#include<iostream>
+#include<algorithm>
+#include<numeric>
+#include<vector>
+#include<string>
+#include<set>
+#include<map>
+#include<queue>
+#include<list>
+#include<sstream>
+using namespace std;
+#define LOOP(x,y,z) for((x)=(y);(x)<=(z);(x)++)
+#define LOOPB(x,y,z) for((x)=(y);(x)<(z);(x)++)
+#define RLOOP(x,y,z) for((x)=(y);(x)>=(z);(x)--)
+#define RLOOPB(x,y,z) for((x)=(y);(x)>(z);(x)--)
+#define MAX(x,y) ((x)>(y)?(x):(y))
+#define MIN(x,y) ((x)<(y)?(x):(y))
+#define ABS(x) ((x)<0?-(x):(x))
+#define PI 3.1415926535898
+const int oo=1<<29;
+int i,j,k,A,p,m,n,B,s,t,tt,cas,l;
+long long int wtf,ans,AA,BB;
+int a[510],aa[510],amax=-oo,amaxi;
+bool has[10101],flag;
+typedef struct {long long int v;int r;} node;
+vector<node> f;
+node tmp;
+inline bool cmp(const node& a,const node& b){
+    return a.v<b.v;
+}
+
+inline bool eq(const node& a,const node& b){
+    return a.v==b.v;
+}
+
+inline bool jiao(){
+    AA=MAX(f[p].v,A);
+    BB=MIN(f[p+1].v-1,B);
+    if(AA>BB)return false;
+    return true;
+}
+
+inline long long gcd(long long a,long long b){
+    long long c;
+    while(b){
+        c=b;
+        b=a%b;
+        a=c;
+    }
+    return a;
+}
+
+inline int lcm(const long long& a,const long long b){
+    long long tmp=gcd(a,b);
+    if(tmp==0){
+        flag=true;
+        return -1;
+    }
+    return a*b/tmp;
+}
+
+inline long long LCM(){
+    int i;
+    long long ll=aa[0];
+    LOOPB(i,1,n)
+        ll=lcm(ll,aa[i]);
+    return ll;
+}
+
+int main()
+{
+#ifndef ONLINE_JUDGE
+freopen("in.txt","r",stdin);
+freopen("out","w",stdout);
+#endif
+while(scanf("%d%d%d",&n,&A,&B)!=EOF){
+    memset(has,0,sizeof(has));
+    f.clear();ans=0;i=0;
+    LOOPB(j,0,n){
+        scanf("%d",&a[i]);
+        if(has[a[i]])continue;
+        has[a[i]]=true;
+        aa[i]=0;
+        if(a[i]>amax){
+            amax=a[i];
+            amaxi=i;
+        }
+        wtf=a[i];
+        tmp.r=i;
+        while(wtf<=B){
+            tmp.v=wtf;
+            f.push_back(tmp);
+            wtf*=a[i];
+        }
+        tmp.v=wtf;
+        f.push_back(tmp);
+        i++;
+    }
+    n=i;
+    sort(f.begin(),f.end(),cmp);
+    /*LOOPB(i,0,f.size())
+        cout<<f[i].v<<' '<<f[i].r<<' ';
+    cout<<endl;*/
+    p=0;
+
+    while(p!=f.size()){
+        flag=false;
+        while(!jiao()&&p!=f.size()){
+            aa[f[p].r]++;
+            p++;
+        }
+        if(p==f.size())break;
+        aa[f[p].r]++;
+        if(aa[amaxi]<=0)goto L1;
+        l=LCM();
+        if(flag||l==0)goto L1;
+        /*cout<<"!"<<AA<<','<<BB<<' '<<l<<endl;
+        LOOPB(i,0,n)
+            cout<<aa[i]<<' ';
+        cout<<endl;*/
+        AA=AA+((AA%l)?l-AA%l:0);
+        if(AA>BB)goto L1;
+        ans+=((BB-AA)/l)+1;
+        L1:
+            p++;
+    }
+    cout<<ans<<endl;
+}
+}
diff --git a/code/train/C++/0083203_simsettings.cpp b/code/train/C++/0083203_simsettings.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9adafdfd1b0afeb364fdb97dc67bfb1bca289586
--- /dev/null
+++ b/code/train/C++/0083203_simsettings.cpp
@@ -0,0 +1,99 @@
+#include "simsettings.h"
+
+#include <QDebug>
+#include <limits>
+
+#include <element/clock.h>
+
+#include <nodes/qneconnection.h>
+
+#include <QStack>
+
+SimSettings::SimSettings( Scene *scn ) : QObject( dynamic_cast< QObject* >( scn ) ), timer( this ) {
+  scene = scn;
+  timer.setInterval( GLOBALCLK );
+  connect( &timer, &QTimer::timeout, this, &SimSettings::update );
+}
+
+SimSettings::~SimSettings( ) {
+
+}
+
+int SimSettings::calculatePriority( UnitOperation *elm,
+                                             QMap< UnitOperation*, bool > &beingvisited,
+                                             QMap< UnitOperation*, int > &priority ) {
+  if( !elm ) {
+    return( 0 );
+  }
+  if( beingvisited.contains( elm ) && ( beingvisited[ elm ] == true ) ) {
+
+    return( 0 );
+  }
+  if( priority.contains( elm ) ) {
+    return( priority[ elm ] );
+  }
+  beingvisited[ elm ] = true;
+  int max = 0;
+  for( QNEPort *port : elm->outputs( ) ) {
+    for( QNEConnection *conn : port->connections( ) ) {
+      QNEPort *sucessor = conn->otherPort( port );
+      if( sucessor ) {
+        max = qMax( calculatePriority( sucessor->unitOperation( ), beingvisited, priority ), max );
+      }
+    }
+  }
+  int p = max + 1;
+  priority[ elm ] = p;
+  beingvisited[ elm ] = false;
+  return( p );
+}
+
+QVector< UnitOperation* > SimSettings::sortElements( QVector< UnitOperation* > elms ) {
+  QMap< UnitOperation*, bool > beingvisited;
+  QMap< UnitOperation*, int > priority;
+  for( UnitOperation *elm : elms ) {
+    calculatePriority( elm, beingvisited, priority );
+  }
+  std::sort( elms.begin( ), elms.end( ), [ priority ]( UnitOperation *e1, UnitOperation *e2 ) {
+    return( priority[ e2 ] < priority[ e1 ] );
+  } );
+
+  return( elms );
+}
+
+void SimSettings::update( ) {
+  QVector< UnitOperation* > elements = scene->getElements( );
+  if( Clock::reset ) {
+    for( UnitOperation *elm : elements ) {
+      if( elm->elementType( ) == ElementType::CLOCK ) {
+        Clock *clk = dynamic_cast< Clock* >( elm );
+        if( clk ) {
+          clk->resetClock( );
+        }
+      }
+    }
+    Clock::reset = false;
+  }
+  if( elements.isEmpty( ) ) {
+    return;
+  }
+  for( UnitOperation *elm : sortedElements ) {
+    elm->updateLogic( );
+  }
+}
+
+void SimSettings::stop( ) {
+  timer.stop( );
+}
+
+void SimSettings::start( ) {
+  timer.start( );
+  Clock::reset = true;
+  reSortElms();
+}
+
+void SimSettings::reSortElms( ) {
+  COMMENT( "Re-sorting elements", 0 );
+  QVector< UnitOperation* > elements = scene->getElements( );
+  sortedElements = sortElements( elements );
+}
diff --git a/code/train/C++/0083836_core_types.cpp b/code/train/C++/0083836_core_types.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6ff5c7c6b7d3f595478875ef08ab90f66a0f4241
--- /dev/null
+++ b/code/train/C++/0083836_core_types.cpp
@@ -0,0 +1,73 @@
+#include "core_types.h"
+#include "error_macros.h"
+
+#include <QVariant>
+#include <QDebug>
+
+bool Interval::isInTimePeriod(qint64 start, qint64 end) const
+{
+    return ((start >= startTime && end <= endTime)
+             ||
+            (start >= startTime && end >= startTime && endTime >= start)
+             ||
+            (start <= startTime && end >= startTime));
+}
+
+void Activity::updateStartAndEndTime()
+{
+    qint64 min = INT64_MAX, max = INT64_MIN;
+    if (intervals.count() == 0) return;
+
+    for (const Interval & interval : intervals)
+    {
+        if (interval.startTime < min) min = interval.startTime;
+        if (interval.endTime   > max) max = interval.endTime;
+    }
+
+    startTime = min;
+    endTime   = max;
+}
+
+bool Activity::belongsToTimePeriod(qint64 startTime, qint64 endTime) const
+{
+    if (intervals.count() == 0)
+    {
+        return (startTime >= this->startTime && endTime <= this->endTime)
+                ||
+               (startTime >= this->startTime && endTime >= this->startTime && this->endTime >= startTime)
+                ||
+               (startTime <= this->startTime && endTime >= this->startTime);
+    }
+
+    for (const Interval & interval : intervals)
+    {
+        /* this one is better i guess
+        (startTime >= interval.startTime && endTime >= interval.startTime && interval.endTime >= startTime)
+        ||
+        (startTime <= interval.startTime && endTime >= interval.startTime);
+        */
+       if ((startTime >= interval.startTime && endTime <= interval.endTime)
+            ||
+           (startTime >= interval.startTime && endTime >= interval.startTime && interval.endTime >= startTime)
+            ||
+           (startTime <= interval.startTime && endTime >= interval.startTime))
+       {
+           return true;
+       }
+    }
+
+    return false;
+}
+
+
+qint64 Activity::duration() const
+{
+    qint64 duration = 0;
+
+    for (const Interval & interval : intervals)
+    {
+        duration += interval.duration();
+    }
+
+    return duration;
+}
diff --git a/code/train/C++/0084217_Sink.cpp b/code/train/C++/0084217_Sink.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..903b675fdd56e3ae56e166677801ae5b3e1d4073
--- /dev/null
+++ b/code/train/C++/0084217_Sink.cpp
@@ -0,0 +1,279 @@
+//===-- Sink.cpp - Code Sinking -------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass moves instructions into successor blocks, when possible, so that
+// they aren't executed on paths where their results aren't needed.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/ValueTracking.h"
+#include "llvm/IR/CFG.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/Dominators.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+using namespace llvm;
+
+#define DEBUG_TYPE "sink"
+
+STATISTIC(NumSunk, "Number of instructions sunk");
+STATISTIC(NumSinkIter, "Number of sinking iterations");
+
+namespace {
+  class Sinking : public FunctionPass {
+    DominatorTree *DT;
+    LoopInfo *LI;
+    AliasAnalysis *AA;
+    const DataLayout *DL;
+
+  public:
+    static char ID; // Pass identification
+    Sinking() : FunctionPass(ID) {
+      initializeSinkingPass(*PassRegistry::getPassRegistry());
+    }
+
+    bool runOnFunction(Function &F) override;
+
+    void getAnalysisUsage(AnalysisUsage &AU) const override {
+      AU.setPreservesCFG();
+      FunctionPass::getAnalysisUsage(AU);
+      AU.addRequired<AliasAnalysis>();
+      AU.addRequired<DominatorTreeWrapperPass>();
+      AU.addRequired<LoopInfo>();
+      AU.addPreserved<DominatorTreeWrapperPass>();
+      AU.addPreserved<LoopInfo>();
+    }
+  private:
+    bool ProcessBlock(BasicBlock &BB);
+    bool SinkInstruction(Instruction *I, SmallPtrSetImpl<Instruction*> &Stores);
+    bool AllUsesDominatedByBlock(Instruction *Inst, BasicBlock *BB) const;
+    bool IsAcceptableTarget(Instruction *Inst, BasicBlock *SuccToSinkTo) const;
+  };
+} // end anonymous namespace
+
+char Sinking::ID = 0;
+INITIALIZE_PASS_BEGIN(Sinking, "sink", "Code sinking", false, false)
+INITIALIZE_PASS_DEPENDENCY(LoopInfo)
+INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
+INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
+INITIALIZE_PASS_END(Sinking, "sink", "Code sinking", false, false)
+
+FunctionPass *llvm::createSinkingPass() { return new Sinking(); }
+
+/// AllUsesDominatedByBlock - Return true if all uses of the specified value
+/// occur in blocks dominated by the specified block.
+bool Sinking::AllUsesDominatedByBlock(Instruction *Inst,
+                                      BasicBlock *BB) const {
+  // Ignoring debug uses is necessary so debug info doesn't affect the code.
+  // This may leave a referencing dbg_value in the original block, before
+  // the definition of the vreg.  Dwarf generator handles this although the
+  // user might not get the right info at runtime.
+  for (Use &U : Inst->uses()) {
+    // Determine the block of the use.
+    Instruction *UseInst = cast<Instruction>(U.getUser());
+    BasicBlock *UseBlock = UseInst->getParent();
+    if (PHINode *PN = dyn_cast<PHINode>(UseInst)) {
+      // PHI nodes use the operand in the predecessor block, not the block with
+      // the PHI.
+      unsigned Num = PHINode::getIncomingValueNumForOperand(U.getOperandNo());
+      UseBlock = PN->getIncomingBlock(Num);
+    }
+    // Check that it dominates.
+    if (!DT->dominates(BB, UseBlock))
+      return false;
+  }
+  return true;
+}
+
+bool Sinking::runOnFunction(Function &F) {
+  DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
+  LI = &getAnalysis<LoopInfo>();
+  AA = &getAnalysis<AliasAnalysis>();
+  DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
+  DL = DLP ? &DLP->getDataLayout() : nullptr;
+
+  bool MadeChange, EverMadeChange = false;
+
+  do {
+    MadeChange = false;
+    DEBUG(dbgs() << "Sinking iteration " << NumSinkIter << "\n");
+    // Process all basic blocks.
+    for (Function::iterator I = F.begin(), E = F.end();
+         I != E; ++I)
+      MadeChange |= ProcessBlock(*I);
+    EverMadeChange |= MadeChange;
+    NumSinkIter++;
+  } while (MadeChange);
+
+  return EverMadeChange;
+}
+
+bool Sinking::ProcessBlock(BasicBlock &BB) {
+  // Can't sink anything out of a block that has less than two successors.
+  if (BB.getTerminator()->getNumSuccessors() <= 1 || BB.empty()) return false;
+
+  // Don't bother sinking code out of unreachable blocks. In addition to being
+  // unprofitable, it can also lead to infinite looping, because in an
+  // unreachable loop there may be nowhere to stop.
+  if (!DT->isReachableFromEntry(&BB)) return false;
+
+  bool MadeChange = false;
+
+  // Walk the basic block bottom-up.  Remember if we saw a store.
+  BasicBlock::iterator I = BB.end();
+  --I;
+  bool ProcessedBegin = false;
+  SmallPtrSet<Instruction *, 8> Stores;
+  do {
+    Instruction *Inst = I;  // The instruction to sink.
+
+    // Predecrement I (if it's not begin) so that it isn't invalidated by
+    // sinking.
+    ProcessedBegin = I == BB.begin();
+    if (!ProcessedBegin)
+      --I;
+
+    if (isa<DbgInfoIntrinsic>(Inst))
+      continue;
+
+    if (SinkInstruction(Inst, Stores))
+      ++NumSunk, MadeChange = true;
+
+    // If we just processed the first instruction in the block, we're done.
+  } while (!ProcessedBegin);
+
+  return MadeChange;
+}
+
+static bool isSafeToMove(Instruction *Inst, AliasAnalysis *AA,
+                         SmallPtrSetImpl<Instruction *> &Stores) {
+
+  if (Inst->mayWriteToMemory()) {
+    Stores.insert(Inst);
+    return false;
+  }
+
+  if (LoadInst *L = dyn_cast<LoadInst>(Inst)) {
+    AliasAnalysis::Location Loc = AA->getLocation(L);
+    for (Instruction *S : Stores)
+      if (AA->getModRefInfo(S, Loc) & AliasAnalysis::Mod)
+        return false;
+  }
+
+  if (isa<TerminatorInst>(Inst) || isa<PHINode>(Inst))
+    return false;
+
+  return true;
+}
+
+/// IsAcceptableTarget - Return true if it is possible to sink the instruction
+/// in the specified basic block.
+bool Sinking::IsAcceptableTarget(Instruction *Inst,
+                                 BasicBlock *SuccToSinkTo) const {
+  assert(Inst && "Instruction to be sunk is null");
+  assert(SuccToSinkTo && "Candidate sink target is null");
+
+  // It is not possible to sink an instruction into its own block.  This can
+  // happen with loops.
+  if (Inst->getParent() == SuccToSinkTo)
+    return false;
+
+  // If the block has multiple predecessors, this would introduce computation
+  // on different code paths.  We could split the critical edge, but for now we
+  // just punt.
+  // FIXME: Split critical edges if not backedges.
+  if (SuccToSinkTo->getUniquePredecessor() != Inst->getParent()) {
+    // We cannot sink a load across a critical edge - there may be stores in
+    // other code paths.
+    if (!isSafeToSpeculativelyExecute(Inst, DL))
+      return false;
+
+    // We don't want to sink across a critical edge if we don't dominate the
+    // successor. We could be introducing calculations to new code paths.
+    if (!DT->dominates(Inst->getParent(), SuccToSinkTo))
+      return false;
+
+    // Don't sink instructions into a loop.
+    Loop *succ = LI->getLoopFor(SuccToSinkTo);
+    Loop *cur = LI->getLoopFor(Inst->getParent());
+    if (succ != nullptr && succ != cur)
+      return false;
+  }
+
+  // Finally, check that all the uses of the instruction are actually
+  // dominated by the candidate
+  return AllUsesDominatedByBlock(Inst, SuccToSinkTo);
+}
+
+/// SinkInstruction - Determine whether it is safe to sink the specified machine
+/// instruction out of its current block into a successor.
+bool Sinking::SinkInstruction(Instruction *Inst,
+                              SmallPtrSetImpl<Instruction *> &Stores) {
+
+  // Don't sink static alloca instructions.  CodeGen assumes allocas outside the
+  // entry block are dynamically sized stack objects.
+  if (AllocaInst *AI = dyn_cast<AllocaInst>(Inst))
+    if (AI->isStaticAlloca())
+      return false;
+
+  // Check if it's safe to move the instruction.
+  if (!isSafeToMove(Inst, AA, Stores))
+    return false;
+
+  // FIXME: This should include support for sinking instructions within the
+  // block they are currently in to shorten the live ranges.  We often get
+  // instructions sunk into the top of a large block, but it would be better to
+  // also sink them down before their first use in the block.  This xform has to
+  // be careful not to *increase* register pressure though, e.g. sinking
+  // "x = y + z" down if it kills y and z would increase the live ranges of y
+  // and z and only shrink the live range of x.
+
+  // SuccToSinkTo - This is the successor to sink this instruction to, once we
+  // decide.
+  BasicBlock *SuccToSinkTo = nullptr;
+
+  // Instructions can only be sunk if all their uses are in blocks
+  // dominated by one of the successors.
+  // Look at all the postdominators and see if we can sink it in one.
+  DomTreeNode *DTN = DT->getNode(Inst->getParent());
+  for (DomTreeNode::iterator I = DTN->begin(), E = DTN->end();
+      I != E && SuccToSinkTo == nullptr; ++I) {
+    BasicBlock *Candidate = (*I)->getBlock();
+    if ((*I)->getIDom()->getBlock() == Inst->getParent() &&
+        IsAcceptableTarget(Inst, Candidate))
+      SuccToSinkTo = Candidate;
+  }
+
+  // If no suitable postdominator was found, look at all the successors and
+  // decide which one we should sink to, if any.
+  for (succ_iterator I = succ_begin(Inst->getParent()),
+      E = succ_end(Inst->getParent()); I != E && !SuccToSinkTo; ++I) {
+    if (IsAcceptableTarget(Inst, *I))
+      SuccToSinkTo = *I;
+  }
+
+  // If we couldn't find a block to sink to, ignore this instruction.
+  if (!SuccToSinkTo)
+    return false;
+
+  DEBUG(dbgs() << "Sink" << *Inst << " (";
+        Inst->getParent()->printAsOperand(dbgs(), false);
+        dbgs() << " -> ";
+        SuccToSinkTo->printAsOperand(dbgs(), false);
+        dbgs() << ")\n");
+
+  // Move the instruction.
+  Inst->moveBefore(SuccToSinkTo->getFirstInsertionPt());
+  return true;
+}
diff --git a/code/train/C++/0084258_data.cpp b/code/train/C++/0084258_data.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..86e4972abc062c381bc5336a59eee49f3ace917b
--- /dev/null
+++ b/code/train/C++/0084258_data.cpp
@@ -0,0 +1,154 @@
+#include <iostream>
+#include <sstream>
+#include <assert.h>
+
+#include <sstream>
+#include "data.hpp"
+
+
+
+auto Data::Sensowna(int dzien, int miesiac, int rok) -> void
+{
+    bool kontrolaROK = false;
+    bool kontrolaMIESIAC = false;
+    bool kontrolaDZIEN = false;
+
+    if (0 <= rok)
+    {
+        kontrolaROK = true;
+    }
+
+    if(1 <= miesiac && miesiac <= 12)
+    {
+        kontrolaMIESIAC = true;
+    }
+
+    if(miesiac == 2)
+    {
+        if(Przestepny(rok) && 1 <= dzien && dzien <= 29) kontrolaDZIEN = true;
+        if(!Przestepny(rok) && 1 <= dzien && dzien <= 28) kontrolaDZIEN = true;
+    }
+    else if(((miesiac % 2 == 1 && miesiac <= 7)
+            || (miesiac % 2 == 0 && miesiac >= 8))
+            && (1 <= dzien && dzien <= 31))
+                kontrolaDZIEN = true;
+    else if(1 <= dzien && dzien <= 31) kontrolaDZIEN = true;
+
+    if(!kontrolaDZIEN)
+        throw zlyDZIEN{};
+    if(!kontrolaMIESIAC)
+        throw zlyMIESIAC{};
+    if(!kontrolaROK)
+        throw zlyROK{};
+}
+
+
+auto Data::Dzien() -> int const
+{
+    return dzien_;
+}
+
+auto Data::Miesiac() -> int const
+{
+    return miesiac_;
+}
+
+auto Data::Rok() -> int const
+{
+    return rok_;
+}
+
+auto Data::zlyD() -> bool const
+{
+    return zlyD_;
+}
+
+auto Data::zlyM() -> bool const
+{
+    return zlyM_;
+}
+
+auto Data::zlyR() -> bool const
+{
+    return zlyR_;
+}
+
+
+auto Data::Przestepny(int rok) -> bool
+{
+    rok = abs(rok);
+    return((rok%4 == 0 && rok%100 != 0) || rok%400 == 0);
+}
+
+Data::Data()
+{
+    rok_ = miesiac_ = dzien_ = 1;
+}
+
+Data::Data(int dzien, int miesiac, int rok)
+{
+    zlyD_ = false;
+    zlyM_ = false;
+    zlyR_ = false;
+
+
+    try
+    {
+    dzien_ = dzien;
+    miesiac_ = miesiac;
+    rok_ = rok;
+
+    Sensowna(dzien, miesiac, rok);
+    }
+
+    catch(zlyDZIEN& zd)
+    {
+       zlyD_ = true;
+    }
+    catch(zlyMIESIAC& zm)
+    {
+        zlyM_ = true;
+    }
+    catch(zlyROK& zr)
+    {
+        zlyR_ = true;
+    }
+}
+
+std::istream& operator>>(std::istream& we, Data &D)
+{
+    int dzien, miesiac, rok;
+    we >> dzien >> miesiac >> rok;
+    if (we)
+    {
+        D = Data(dzien, miesiac, rok);
+    }
+    else
+        we.setstate(std::ios_base::failbit);
+    return we;
+}
+
+Data pobieranieData(std::string polecenie)
+{
+    std::string wejscie;
+    Data wyjscie(1, 1, 1);
+
+    std::cout << polecenie;
+    std::getline(std::cin, wejscie);
+    std::istringstream strumien(wejscie);
+    strumien >> std::skipws >> wyjscie;
+
+  //  while (!strumien || wyjscie.zlyR() || wyjscie.zlyM() || wyjscie.zlyD())
+    while (!strumien)
+    {
+        strumien.ignore(1000, '\n');
+        strumien.clear();
+        std::cout << "Coś poszło nie tak, podaj date jeszcze raz (format DD MM YYYY): ";
+        std::cin.clear();
+        std::getline(std::cin, wejscie);
+        strumien.str (wejscie);
+        strumien >> std::skipws >> wyjscie;
+    }
+
+    return(wyjscie);
+}
diff --git a/code/train/C++/0084364_D.cpp b/code/train/C++/0084364_D.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0fe07ec61fbb88eca80caf269942c3a25a9cb3ba
--- /dev/null
+++ b/code/train/C++/0084364_D.cpp
@@ -0,0 +1,74 @@
+//#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include<stdio.h>
+#include<cstring>
+#include<cmath>
+#include<string>
+#include<algorithm>
+#include<iostream>
+#include<vector>
+#include<queue>
+#include<map>
+#include<set>
+#include<stack>
+#include<bitset>
+#include<time.h>
+
+#define Msn(x,y) (memset((x),0,sizeof((x[0]))*(y+1)))
+#define msn(x) (memset((x),0,sizeof((x))))
+#define msx(x,y) (memset((x),0x7f,sizeof((x[0]))*(y+3)))
+#define fuck(x) cerr << #x << " <- " << x << endl
+#define acer cout<<"sb"<<endl
+#define mkp(x,y) (make_pair(x,y))
+#define fi first
+#define se second
+#define ture true
+#define lch  (id<<1)
+#define rch (id<<1|1)
+
+typedef long long ll;
+using namespace std;
+const int maxn=4004;
+ll dp[maxn][3];
+int T;
+int n,m;
+int a,v;
+int main()
+{
+    scanf("%d",&T);
+    for(int _=1;_<=T;_++)
+    {
+        msn(dp);
+        scanf("%d%d",&n,&m);
+        m*=2;
+        ll ans=0;
+        for(int i=0;i<n;i++)
+        {
+            scanf("%d%d",&a,&v);
+            int aa=a*2;
+            ans=max(ans,(ll)v);
+            for(int j=1;j<=m;j++)
+            {
+                if(j>=aa)
+                {
+                    dp[j-aa][0]=max(dp[j-aa][0],dp[j][0]+v);
+                    dp[j-aa][1]=max(dp[j-aa][1],dp[j][1]+v);
+                    dp[j-aa][2]=max(dp[j-aa][2],dp[j][2]+v);
+                }
+                if(j>=a)
+                {
+                    dp[j-a][1]=max(dp[j-a][1],dp[j][0]+v);
+                    dp[j-a][2]=max(dp[j-a][2],dp[j][1]+v);
+                }
+            }
+        }
+
+//        fuck(dp[2][0]);
+        for(int j=0;j<=m;j++)
+        {
+            for(int k=0;k<=2;k++)ans=max(ans,dp[j][k]);
+        }
+//        fuck(ans);
+        printf("Case #%d: %lld\n",_,ans);
+    }
+    return 0;
+}
diff --git a/code/train/C++/0084611_main.cpp b/code/train/C++/0084611_main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..00be17c2d3560023f4abbb302daad62742bcb64d
--- /dev/null
+++ b/code/train/C++/0084611_main.cpp
@@ -0,0 +1,146 @@
+//
+//  main.cpp
+//  Q1034
+//
+//  Created by Pumpkin Lee on 2/6/14.
+//  Copyright (c) 2014 Pumpkin Lee. All rights reserved.
+//
+
+#include <iostream>
+#include <cstring>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+
+using namespace std;
+
+struct Edge {
+    int v, w;
+    int weight;
+};
+
+struct Graph {
+    
+    Graph(int v): adjList(v), degree(v, 0) {
+        nV = v;
+    }
+    
+    void addEdge(Edge *e) {
+        adjList[e->v].push_back(e);
+        adjList[e->w].push_back(e);
+        
+        degree[e->v] += e->weight;
+        degree[e->w] += e->weight;
+    }
+
+    int nV;
+    vector<vector<Edge *>> adjList;
+    vector<int> degree;
+};
+
+struct DFS {
+    
+    DFS(Graph *g) {
+        this->g = g;
+        isVisited = new bool[g->nV];
+        memset(isVisited, 0, sizeof(bool) * g->nV);
+        
+        for (int i=0; i<g->nV; ++i) {
+            if (!isVisited[i]) {
+                set<int> comp;
+                dfs(i, comp);
+                components.push_back(comp);
+            }
+        }
+    }
+    
+    void dfs(int v, set<int> &comp) {
+        comp.insert(v);
+        isVisited[v] = true;
+        vector<Edge *> &adj = g->adjList[v];
+        for (int i=0; i<adj.size(); ++i) {
+            Edge *e = adj[i];
+            int w = e->v == v ? e->w : e->v;
+            if (!isVisited[w]) {
+                dfs(w, comp);
+            }
+        }
+    }
+    
+    Graph *g;
+    vector<set<int>> components;
+    bool *isVisited;
+};
+
+int main(int argc, const char * argv[])
+{
+    int nRecord, threshold;
+    scanf("%d %d", &nRecord, &threshold);
+    
+    map<string, int> nameTable;
+    vector<string> names;
+    vector<Edge *> edges;
+    for (int i=0; i<nRecord; ++i) {
+        Edge *e = new Edge();
+        string a, b;
+        cin >> a >> b >> e->weight;
+        
+        map<string, int>::iterator it = nameTable.find(a);
+        if (it == nameTable.end()) {
+            e->v = static_cast<int>(names.size());
+            nameTable.insert(pair<string, int>(a, e->v));
+            names.push_back(a);
+        } else {
+            e->v = it->second;
+        }
+        it = nameTable.find(b);
+        if (it == nameTable.end()) {
+            e->w = static_cast<int>(names.size());
+            nameTable.insert(pair<string, int>(b, e->w));
+            names.push_back(b);
+        } else {
+            e->w = it->second;
+        }
+        
+        edges.push_back(e);
+    }
+    
+    Graph *g = new Graph(static_cast<int>(names.size()));
+    for (int i=0; i<edges.size(); ++i) {
+        g->addEdge(edges[i]);
+    }
+    
+    DFS dfs(g);
+    vector<pair<string, int>> result;
+    for (int i=0; i<dfs.components.size(); ++i) {
+        set<int> &comp = dfs.components[i];
+        if (comp.size() <= 2) continue;
+        int sum = 0;
+        int maxPos = -1;
+        int max = INT32_MIN;
+        for (set<int>::iterator it=comp.begin(); it!=comp.end(); ++it) {
+            int degree = g->degree[*it];
+            sum += degree;
+            if (degree > max) {
+                max = degree;
+                maxPos = *it;
+            }
+        }
+        sum /= 2;
+        if (sum > threshold) {
+            result.push_back(pair<string, int>(names[maxPos], comp.size()));
+        }
+    }
+    
+    printf("%ld\n", result.size());
+    sort(result.begin(), result.end());
+    for (int i=0; i<result.size(); ++i) {
+        printf("%s %d\n", result[i].first.data(), result[i].second);
+    }
+    
+    return 0;
+}
+
+// 理清思路，用好数据结构
diff --git a/code/train/C++/0085038_Preprocessor.cpp b/code/train/C++/0085038_Preprocessor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8c61a3aa21be697275a4856424a89f7e99bdc93e
--- /dev/null
+++ b/code/train/C++/0085038_Preprocessor.cpp
@@ -0,0 +1,178 @@
+#include "QDataStdAfx.h"
+#include "data/Sink.h"
+#include "data/Source.h"
+#include "data/Data_Pack.h"
+#include "data/File_System.h"
+#include "util/Preprocessor.h"
+
+using namespace q;
+using namespace util;
+
+Preprocessor::Preprocessor(data::File_System& fs, Path const& root, Flags flags)
+	: m_file_system(fs)
+	, m_flags(flags)
+    , m_root(root)
+{
+
+}
+
+std::string Preprocessor::resolve_comments(std::string const& src)
+{
+	std::string::size_type off = src.find('/');
+	if (off == std::string::npos || off == src.size() - 1)
+	{
+		return src;
+	}
+
+	std::string::size_type last_off = 0;
+	std::string::size_type block_start = 0;
+	std::string result;
+	int block_level = 0;
+	while (true)
+	{
+		if (block_level == 0 && last_off != off)
+		{
+			result += src.substr(last_off, off - last_off);
+		}
+		last_off = off;
+		if (off == std::string::npos)
+		{
+			break;
+		}
+
+		if (src[off + 1] == '/' && block_level == 0) //line comment
+		{
+			auto end = src.find_first_of("\n\r", off);
+			if (m_flags[Flag::SPACES_FOR_COMMENTS])
+			{
+				result.append(end - off, ' ');
+			}
+			off = end;
+			last_off = off;
+		}
+		else if (block_level > 0 && off > 0 && src[off - 1] == '*') //end block comment
+		{
+			block_level--;
+			if (block_level == 0)
+			{
+				auto last = block_start;
+				auto pos = src.find_first_of("\r\n", block_start);
+				while (true)
+				{
+					bool found_new_line = true;
+					if (pos > off || pos == std::string::npos) //no moar new lines? process the last one only
+					{
+						pos = off + 1;
+						found_new_line = false;
+					}
+
+					if (m_flags[Flag::SPACES_FOR_COMMENTS])
+					{
+						result.append(pos - last, ' ');
+					}
+					if (found_new_line)
+					{
+						result.append("\r\n");
+					}
+
+					if (pos >= off)
+					{
+						break;
+					}
+					last = src.find_first_not_of("\r\n", pos);
+					pos = src.find_first_of("\r\n", last);
+				}
+				last_off = off + 1;//to skip the / as well
+			}
+		}
+		else if (src[off + 1] == '*') //start block comment
+		{
+			if (block_level == 0)
+			{
+				block_start = off;
+			}
+			block_level++;
+		}
+
+		off = src.find('/', off + 1); //find next possible comment start
+	}
+
+	return result;
+}
+
+std::string Preprocessor::resolve_includes(Path const& path, std::string const& source)
+{
+	if (source.empty())
+	{
+		return source;
+	}
+
+	std::string src = m_flags[Flag::IGNORE_COMMENTS] ? source : resolve_comments(source);
+
+	std::string res = src;
+    auto off = res.find("#include");
+	while (off != res.npos)
+	{
+		int start_off = off + 8;
+        auto end_off = res.find("\n", start_off);
+		if (end_off == res.npos)
+		{
+			end_off = res.length();
+		}
+
+		std::string filename = res.substr(start_off, end_off - start_off);
+		int qsoff = filename.find_first_of('"');
+		int qeoff = filename.find_last_of('"');
+		if (qsoff != qeoff)
+		{
+			filename = filename.substr(qsoff + 1, qeoff - qsoff - 1);
+		}
+
+        Path new_path(path.get_sub_path(0, -1) + std::string(filename));
+		auto link = m_file_system.open(new_path);
+		if (!link)
+		{
+            QLOGE("Cannot open file '{}' while preprocessing", new_path);
+			return src;
+		}
+
+		auto contents = data::read_whole_source_as_string<std::string>(*link);
+
+		contents = resolve_includes(new_path, contents);
+		auto new_res = res.substr(0, off);
+		new_res += contents;
+        if (end_off < res.length())
+		{
+			new_res += res.substr(end_off + 1, res.length() - (end_off + 1));
+		}
+		res = new_res;
+
+		off = res.find("#include", end_off);
+	}
+
+	return res;
+}
+
+std::string Preprocessor::preprocess(std::string const& source)
+{
+	if (source.empty())
+	{
+		return source;
+	}
+
+	std::string src(source.c_str());
+
+	//first comments - then includes, to void resolving the comented includes
+	if (!m_flags[Flag::IGNORE_COMMENTS])
+	{
+		src = resolve_comments(src);
+	}
+
+	if (!m_flags[Flag::IGNORE_INCLUDES])
+	{
+		src = resolve_includes(m_root, src);
+	}
+
+    return src;
+}
+
diff --git a/code/train/C++/0086391_Timer.cpp b/code/train/C++/0086391_Timer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..af569c1fd7f0a5069893da53723c6e15dc360a9a
--- /dev/null
+++ b/code/train/C++/0086391_Timer.cpp
@@ -0,0 +1,255 @@
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+// ******************************************************************
+// *
+// *  This file is part of the Cxbx project.
+// *
+// *  Cxbx and Cxbe are free software; you can redistribute them
+// *  and/or modify them 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 recieved a copy of the GNU General Public License
+// *  along with this program; see the file COPYING.
+// *  If not, write to the Free Software Foundation, Inc.,
+// *  59 Temple Place - Suite 330, Bostom, MA 02111-1307, USA.
+// *
+// *  (c) 2018      ergo720
+// *
+// *  All rights reserved
+// *
+// ******************************************************************
+
+#include <core\kernel\exports\xboxkrnl.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+#include <thread>
+#include <vector>
+#include <mutex>
+#include "Timer.h"
+#include "common\util\CxbxUtil.h"
+#include "core\kernel\init\CxbxKrnl.h"
+#include "core\kernel\support\EmuFS.h"
+#ifdef __linux__
+#include <time.h>
+#endif
+
+// More precise sleep, but with increased CPU usage
+void SleepPrecise(std::chrono::steady_clock::time_point targetTime)
+{
+	using namespace std::chrono;
+	// If we don't need to wait, return right away
+
+	// TODO use waitable timers?
+	// TODO fetch the timer resolution to determine the sleep threshold?
+	// TODO adaptive wait? https://blat-blatnik.github.io/computerBear/making-accurate-sleep-function/
+
+	// Try to sleep for as much of the wait as we can
+	// to save CPU usage / power
+	// We expect sleep to overshoot, so give ourselves some extra time
+	// Note currently we ask Windows to give us 1ms timer resolution
+	constexpr auto sleepThreshold = 2ms; // Minimum remaining time before we attempt to use sleep
+
+	auto sleepFor = (targetTime - sleepThreshold) - steady_clock::now();
+	auto sleepMs = duration_cast<milliseconds>(sleepFor).count();
+
+	// Sleep if required
+	if (sleepMs >= 0) {
+		Sleep((DWORD)sleepMs);
+	}
+
+	// Spin wait
+	while (steady_clock::now() < targetTime) {
+		;
+	}
+}
+
+// Virtual clocks will probably become useful once LLE CPU is implemented, but for now we don't need them.
+// See the QEMUClockType QEMU_CLOCK_VIRTUAL of XQEMU for more info.
+#define CLOCK_REALTIME 0
+//#define CLOCK_VIRTUALTIME  1
+
+
+// Vector storing all the timers created
+static std::vector<TimerObject*> TimerList;
+// The frequency of the high resolution clock of the host, and the start time
+int64_t HostQPCFrequency, HostQPCStartTime;
+// Lock to acquire when accessing TimerList
+std::mutex TimerMtx;
+
+
+// Returns the current time of the timer
+uint64_t GetTime_NS(TimerObject* Timer)
+{
+#ifdef _WIN32
+	uint64_t Ret = Timer_GetScaledPerformanceCounter(SCALE_S_IN_NS);
+#elif __linux__
+	static struct timespec ts;
+	clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
+	uint64_t Ret = Muldiv64(ts.tv_sec, SCALE_S_IN_NS, 1) + ts.tv_nsec;
+#else
+#error "Unsupported OS"
+#endif
+	return Ret;
+}
+
+// Calculates the next expire time of the timer
+static inline uint64_t GetNextExpireTime(TimerObject* Timer)
+{
+	return GetTime_NS(Timer) + Timer->ExpireTime_MS.load();
+}
+
+// Deallocates the memory of the timer
+void Timer_Destroy(TimerObject* Timer)
+{
+	unsigned int index, i;
+	std::lock_guard<std::mutex>lock(TimerMtx);
+	
+	index = TimerList.size();
+	for (i = 0; i < index; i++) {
+		if (Timer == TimerList[i]) {
+			index = i;
+		}
+	}
+
+	assert(index != TimerList.size());
+	delete Timer;
+	TimerList.erase(TimerList.begin() + index);
+}
+
+void Timer_Shutdown()
+{
+	unsigned i, iXboxThreads = 0;
+	TimerMtx.lock();
+
+	for (i = 0; i < TimerList.size(); i++) {
+		TimerObject* Timer = TimerList[i];
+		// We only need to terminate host threads.
+		if (!Timer->IsXboxTimer) {
+			Timer_Exit(Timer);
+		}
+		// If the thread is xbox, we need to increment for while statement check
+		else {
+			iXboxThreads++;
+		}
+	}
+
+	// Only perform wait for host threads, otherwise xbox threads are
+	// already handled within xbox kernel for shutdown process. See CxbxrKrnlSuspendThreads function.
+	int counter = 0;
+	while (iXboxThreads != TimerList.size()) {
+		if (counter >= 8) {
+			break;
+		}
+		TimerMtx.unlock();
+		std::this_thread::sleep_for(std::chrono::milliseconds(500));
+		TimerMtx.lock();
+		counter++;
+	}
+	TimerList.clear();
+	TimerMtx.unlock();
+}
+
+// Thread that runs the timer
+void NTAPI ClockThread(void *TimerArg)
+{
+	TimerObject *Timer = static_cast<TimerObject *>(TimerArg);
+	if (!Timer->Name.empty()) {
+		CxbxSetThreadName(Timer->Name.c_str());
+	}
+	if (!Timer->IsXboxTimer) {
+		g_AffinityPolicy->SetAffinityOther();
+	}
+
+	uint64_t NewExpireTime = GetNextExpireTime(Timer);
+
+	while (true) {
+		if (GetTime_NS(Timer) > NewExpireTime) {
+			if (Timer->Exit.load()) {
+				Timer_Destroy(Timer);
+				return;
+			}
+			Timer->Callback(Timer->Opaque);
+			NewExpireTime = GetNextExpireTime(Timer);
+		}
+		Sleep(1); // prevent burning the cpu
+	}
+}
+
+// Changes the expire time of a timer
+void Timer_ChangeExpireTime(TimerObject* Timer, uint64_t Expire_ms)
+{
+	Timer->ExpireTime_MS.store(Expire_ms);
+}
+
+// Destroys the timer
+void Timer_Exit(TimerObject* Timer)
+{
+	Timer->Exit.store(true);
+}
+
+// Allocates the memory for the timer object
+TimerObject* Timer_Create(TimerCB Callback, void* Arg, std::string Name, bool IsXboxTimer)
+{
+	std::lock_guard<std::mutex>lock(TimerMtx);
+	TimerObject* pTimer = new TimerObject;
+	pTimer->Type = CLOCK_REALTIME;
+	pTimer->Callback = Callback;
+	pTimer->ExpireTime_MS.store(0);
+	pTimer->Exit.store(false);
+	pTimer->Opaque = Arg;
+	pTimer->Name = Name.empty() ? "Unnamed thread" : std::move(Name);
+	pTimer->IsXboxTimer = IsXboxTimer;
+	TimerList.emplace_back(pTimer);
+
+	return pTimer;
+}
+
+// Starts the timer
+// Expire_MS must be expressed in NS
+void Timer_Start(TimerObject* Timer, uint64_t Expire_MS)
+{
+	Timer->ExpireTime_MS.store(Expire_MS);
+	if (Timer->IsXboxTimer) {
+		xbox::HANDLE hThread;
+		xbox::PsCreateSystemThread(&hThread, xbox::zeroptr, ClockThread, Timer, FALSE);
+	}
+	else {
+		std::thread(ClockThread, Timer).detach();
+	}
+}
+
+// Retrives the frequency of the high resolution clock of the host
+void Timer_Init()
+{
+#ifdef _WIN32
+	QueryPerformanceFrequency(reinterpret_cast<LARGE_INTEGER*>(&HostQPCFrequency));
+	QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER*>(&HostQPCStartTime));
+#elif __linux__
+	ClockFrequency = 0;
+#else
+#error "Unsupported OS"
+#endif
+}
+
+int64_t Timer_GetScaledPerformanceCounter(int64_t Period)
+{
+	LARGE_INTEGER currentQPC;
+	QueryPerformanceCounter(&currentQPC);
+
+	// Scale frequency with overflow avoidance, like in std::chrono
+	// https://github.com/microsoft/STL/blob/6d2f8b0ed88ea6cba26cc2151f47f678442c1663/stl/inc/chrono#L703
+	const int64_t currentTime = currentQPC.QuadPart - HostQPCStartTime;
+	const int64_t whole = (currentTime / HostQPCFrequency) * Period;
+	const int64_t part  = (currentTime % HostQPCFrequency) * Period / HostQPCFrequency;
+
+	return whole + part;
+}
+
diff --git a/code/train/C++/0086664_RWLockTest.cpp b/code/train/C++/0086664_RWLockTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d492473d64f9111f1e39e66512e54917a8904c4f
--- /dev/null
+++ b/code/train/C++/0086664_RWLockTest.cpp
@@ -0,0 +1,216 @@
+//
+// RWLockTest.cpp
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "RWLockTest.h"
+#include "CppUnit/TestCaller.h"
+#include "CppUnit/TestSuite.h"
+#include "Poco/RWLock.h"
+#include "Poco/Thread.h"
+#include "Poco/Runnable.h"
+
+
+using Poco::RWLock;
+using Poco::Thread;
+using Poco::Runnable;
+
+
+class RWLockRunnable: public Runnable
+{
+public:
+	RWLockRunnable(RWLock& lock, volatile int& counter): _lock(lock), _counter(counter), _ok(true)
+	{
+	}
+	
+	void run()
+	{
+		int lastCount = 0;
+		for (int i = 0; i < 10000; ++i)
+		{
+			_lock.readLock();
+			lastCount = _counter;
+			for (int k = 0; k < 100; ++k)
+			{
+				if (_counter != lastCount) _ok = false;
+				Thread::yield();
+			}
+			_lock.unlock();
+			_lock.writeLock();
+			for (int k = 0; k < 100; ++k)
+			{
+				--_counter;
+				Thread::yield();
+			}
+			for (int k = 0; k < 100; ++k)
+			{
+				++_counter;
+				Thread::yield();
+			}
+			++_counter;
+			if (_counter <= lastCount) _ok = false;
+			_lock.unlock();
+		}
+	}
+	
+	bool ok() const
+	{
+		return _ok;
+	}
+	
+private:
+	RWLock& _lock;
+	volatile int& _counter;
+	bool _ok;
+};
+
+
+class RWTryLockRunnable: public Runnable
+{
+public:
+	RWTryLockRunnable(RWLock& lock, volatile int& counter): _lock(lock), _counter(counter), _ok(true)
+	{
+	}
+	
+	void run()
+	{
+		int lastCount = 0;
+		for (int i = 0; i < 10000; ++i)
+		{
+			while (!_lock.tryReadLock()) Thread::yield();
+			lastCount = _counter;
+			for (int k = 0; k < 100; ++k)
+			{
+				if (_counter != lastCount) _ok = false;
+				Thread::yield();
+			}
+			_lock.unlock();
+			while (!_lock.tryWriteLock()) Thread::yield();
+			for (int k = 0; k < 100; ++k)
+			{
+				--_counter;
+				Thread::yield();
+			}
+			for (int k = 0; k < 100; ++k)
+			{
+				++_counter;
+				Thread::yield();
+			}
+			++_counter;
+			if (_counter <= lastCount) _ok = false;
+			_lock.unlock();
+		}
+	}
+	
+	bool ok() const
+	{
+		return _ok;
+	}
+	
+private:
+	RWLock& _lock;
+	volatile int& _counter;
+	bool _ok;
+};
+
+
+RWLockTest::RWLockTest(const std::string& name): CppUnit::TestCase(name)
+{
+}
+
+
+RWLockTest::~RWLockTest()
+{
+}
+
+
+void RWLockTest::testLock()
+{
+	RWLock lock;
+	int counter = 0;
+	RWLockRunnable r1(lock, counter);
+	RWLockRunnable r2(lock, counter);
+	RWLockRunnable r3(lock, counter);
+	RWLockRunnable r4(lock, counter);
+	RWLockRunnable r5(lock, counter);
+	Thread t1;
+	Thread t2;
+	Thread t3;
+	Thread t4;
+	Thread t5;
+	t1.start(r1);
+	t2.start(r2);
+	t3.start(r3);
+	t4.start(r4);
+	t5.start(r5);
+	t1.join();
+	t2.join();
+	t3.join();
+	t4.join();
+	t5.join();
+	assertTrue (counter == 50000);
+	assertTrue (r1.ok());
+	assertTrue (r2.ok());
+	assertTrue (r3.ok());
+	assertTrue (r4.ok());
+	assertTrue (r5.ok());
+}
+
+
+void RWLockTest::testTryLock()
+{
+	RWLock lock;
+	int counter = 0;
+	RWTryLockRunnable r1(lock, counter);
+	RWTryLockRunnable r2(lock, counter);
+	RWTryLockRunnable r3(lock, counter);
+	RWTryLockRunnable r4(lock, counter);
+	RWTryLockRunnable r5(lock, counter);
+	Thread t1;
+	Thread t2;
+	Thread t3;
+	Thread t4;
+	Thread t5;
+	t1.start(r1);
+	t2.start(r2);
+	t3.start(r3);
+	t4.start(r4);
+	t5.start(r5);
+	t1.join();
+	t2.join();
+	t3.join();
+	t4.join();
+	t5.join();
+	assertTrue (counter == 50000);
+	assertTrue (r1.ok());
+	assertTrue (r2.ok());
+	assertTrue (r3.ok());
+	assertTrue (r4.ok());
+	assertTrue (r5.ok());
+}
+
+
+void RWLockTest::setUp()
+{
+}
+
+
+void RWLockTest::tearDown()
+{
+}
+
+
+CppUnit::Test* RWLockTest::suite()
+{
+	CppUnit::TestSuite* pSuite = new CppUnit::TestSuite("RWLockTest");
+
+	CppUnit_addLongTest(pSuite, RWLockTest, testLock);
+	CppUnit_addLongTest(pSuite, RWLockTest, testTryLock);
+
+	return pSuite;
+}
diff --git a/code/train/C++/0087177_AudioProducer.cpp b/code/train/C++/0087177_AudioProducer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..72c7cf0f244ac485c03d8dbcd00b6f88340816e6
--- /dev/null
+++ b/code/train/C++/0087177_AudioProducer.cpp
@@ -0,0 +1,242 @@
+#include "AudioProducer.h"
+#include <QtEndian>
+#include <fstream>
+#include "sploosh.pb.h"
+#include "utils/term_msg.h"
+#include "utils/macros.h"
+#include "transfer/FMMTransferEval.h"
+
+using namespace std;
+
+static const int SR = 44100;
+static const double TS = 3;    // synthesize sound for at most 3 seconds
+
+AudioProducer::AudioProducer(const QSettings& settings, const QDir& dataDir): 
+        device_(NULL), normalizeScale_(-1.)
+{
+    ////// load data
+    QString filename;
+    // --- load vertex map ---
+    {
+        QString ff = settings.value("modal/vtx_map").toString();
+        QFileInfo fInfo(ff);
+        filename = fInfo.isRelative() ? dataDir.filePath(ff) : ff;
+    }
+    load_vertex_map(filename);
+
+    // --- load modal shape matrix ---
+    {
+        QString ff = settings.value("modal/shape").toString();
+        QFileInfo fInfo(ff);
+        filename = fInfo.isRelative() ? dataDir.filePath(ff) : ff;
+    }
+
+    modal_ = new ModalModel(
+        filename.toStdString(),
+        settings.value("modal/density").toDouble(),
+        settings.value("modal/alpha").toDouble(),
+        settings.value("modal/beta").toDouble() );
+
+    mForce_.resize( modal_->num_modes() );
+
+    // --- load moments ---
+    {
+        QString ff = settings.value("transfer/moments").toString();
+        QFileInfo fInfo(ff);
+        filename = fInfo.isRelative() ? dataDir.filePath(ff) : ff;
+    }
+    load_moments(filename);
+
+    // --- setup audio output device ---
+    const QString devStr = settings.value("audio/device").toString();
+
+    foreach(const QAudioDeviceInfo &deviceInfo, 
+            QAudioDeviceInfo::availableDevices(QAudio::AudioOutput)) 
+        if ( devStr == deviceInfo.deviceName() )
+            device_ = new QAudioDeviceInfo( deviceInfo );
+
+    if ( !device_ ) 
+    {
+        PRINT_ERROR("Cannot find the specified audio device\n");
+        SHOULD_NEVER_HAPPEN(-2);
+    }
+
+    // --- allocate data buffer ---
+    init();
+}
+
+AudioProducer::~AudioProducer()
+{
+    delete device_;
+    delete audioOutput_;
+
+    for(size_t i = 0;i < transfer_.size();++ i) delete transfer_[i];
+}
+
+void AudioProducer::load_moments(const QString& filename)
+{
+    sploosh::ModalMoments mms;
+    ifstream fin( filename.toStdString().c_str(), ios::binary );
+    if ( !mms.ParseFromIstream(&fin) )
+    {
+        PRINT_ERROR("Cannot real protobuf file: %s\n", filename.toStdString().c_str());
+        SHOULD_NEVER_HAPPEN(-1);
+    }
+
+    const int nmms = (int)mms.moment_size();
+    PRINT_MSG("%d moments are detected\n", nmms);
+    if ( nmms < modal_->num_modes() )
+    {
+        PRINT_ERROR("Number of moments (%d) is smaller than the number of modes (%d)\n", nmms, modal_->num_modes());
+        SHOULD_NEVER_HAPPEN(-2);
+    } // end if
+
+    QFileInfo checkConfig(filename);
+    QString dir = checkConfig.absoluteDir().absolutePath(); //.toStdString() << endl;
+    transfer_.resize( modal_->num_modes() );
+    for(int mi = 0;mi < modal_->num_modes();++ mi)
+    {
+        transfer_[mi] = new FMMTransferEval( mms.moment(mi), dir.toStdString() );
+    }
+}
+
+/*
+ * Vertex map to map from surface vertex to tet vertex
+ */
+void AudioProducer::load_vertex_map(const QString& filename)
+{
+    int id1, id2;
+
+    std::ifstream fin( filename.toStdString().c_str() );
+    if ( fin.fail() )
+    {
+        PRINT_ERROR("Cannot read file: %s\n", filename.toStdString().c_str());
+        SHOULD_NEVER_HAPPEN(2);
+    }
+    fin >> numFixed_ >> id1;    // # of fixed vertices in tet mesh 
+                                // & total number of surface vertices
+    PRINT_MSG("  # of fixed vertices: %d\n", numFixed_);
+    vidS2T_.resize(id1);
+    for(size_t i = vidS2T_.size();i > 0;-- i)
+    {
+        fin >> id1 >> id2;
+        if ( id2 >= vidS2T_.size() )
+        {
+            PRINT_ERROR("Id2 is out of range in geometry file\n");
+            SHOULD_NEVER_HAPPEN(3);
+        }
+        vidS2T_[id2] = id1;
+    }
+    if ( fin.fail() )
+    {
+        PRINT_ERROR("Error occurred while reading file: %s\n", filename.toStdString().c_str());
+        SHOULD_NEVER_HAPPEN(2);
+    }
+    fin.close();
+}
+
+void AudioProducer::init()
+{
+    // setup audio format
+    format_.setSampleRate(SR);
+    format_.setChannelCount( stereo_ ? 2 : 1 );
+    format_.setSampleSize(16);
+    format_.setCodec("audio/pcm");
+    format_.setByteOrder(QAudioFormat::LittleEndian);
+    format_.setSampleType(QAudioFormat::SignedInt);
+
+    // now check the format
+    if ( !device_->isFormatSupported(format_) ) 
+    {
+        PRINT_ERROR("The specified format cannot be supported\n");
+        SHOULD_NEVER_HAPPEN(-2);
+    }
+
+    // create buffer 
+    const qint64 len = 
+        (SR * TS * format_.channelCount() * format_.sampleSize() / 8);
+    buffer_.resize(len);
+    soundBuffer_.resize( SR * TS * format_.channelCount() );
+
+    // create the IO device
+    audioIO_.close();
+    audioIO_.setBuffer( &buffer_ );
+    audioIO_.open( QIODevice::ReadOnly );
+    
+    audioOutput_ = new QAudioOutput( *device_, format_ );
+}
+
+void AudioProducer::play(const Tuple3ui& tri, const Vector3d& dir, const Point3d& cam)
+{
+    audioIO_.close();
+
+    // ====== fill the buffer ======
+    //// for now, only do the single-channel synthesis
+    single_channel_synthesis(tri, dir, cam);
+    /*
+    unsigned char *ptr = reinterpret_cast<unsigned char *>(buffer_.data());
+    const int channelBytes = format_.sampleSize() / 8;
+    for(int ii = 0;ii < SR * TS; ++ ii)
+    {
+        const qreal x = sin( 2. * M_PI * 200. * static_cast<double>(ii) / static_cast<double>(SR) );
+        const qint16 value = static_cast<qint16>(x * 32767);    // integer value
+
+        qToLittleEndian<qint16>(value, ptr);
+        ptr += channelBytes;
+    }
+    */
+
+    audioIO_.open( QIODevice::ReadOnly );
+    audioOutput_->reset();
+
+    audioOutput_->start( &audioIO_ );
+}
+
+void AudioProducer::single_channel_synthesis(const Tuple3ui& tri, const Vector3d& dir, const Point3d& cam)
+{
+    //// force in modal space
+    memset( mForce_.data(), 0, sizeof(double)*mForce_.size() );
+    modal_->accum_modal_impulse( vidS2T_[tri.x]-numFixed_, &dir, mForce_.data() );
+    modal_->accum_modal_impulse( vidS2T_[tri.y]-numFixed_, &dir, mForce_.data() );
+    modal_->accum_modal_impulse( vidS2T_[tri.z]-numFixed_, &dir, mForce_.data() );
+
+    const vector<double>& omegaD = modal_->damped_omega();
+    const vector<double>& c      = modal_->damping_vector();
+
+    //// multiply with the impulse response of each modes
+    memset( soundBuffer_.data(), 0, sizeof(double)*soundBuffer_.size() );
+    const int totTicks = SR*TS;
+    for(int i = 0;i < modal_->num_modes();++ i)
+    {
+        FMMTransferEval::TComplex trans = transfer_[i]->eval( cam );
+
+        const double SS = mForce_[i] * abs(trans) / omegaD[i];
+
+        for(int ti = 0;ti < totTicks;++ ti)
+        {
+            const double ts = static_cast<double>(ti) / static_cast<double>(SR);    // time
+            const double amp = exp(- c[i]*0.5*ts );    // exp(-xi * omega * t)
+            if ( amp < 1E-5 ) break;
+            soundBuffer_[ti] += amp * SS * sin( omegaD[i]*ts );  // sin(omega_d * t)
+        }
+    } // end for
+
+    //// normalize the sound only for the first time, so the sound volume can change as camera moves
+    if ( normalizeScale_ < 0. )
+    {
+        double AMP = 0;
+        for(int ti = 0;ti < totTicks;++ ti)
+            AMP = std::max( AMP, abs(soundBuffer_[ti]) );
+        normalizeScale_ = 0.6 / AMP;
+    } // end if
+
+    unsigned char *ptr = reinterpret_cast<unsigned char *>(buffer_.data());
+    const int channelBytes = format_.sampleSize() / 8;
+    for(int ti = 0;ti < totTicks;++ ti)
+    {
+        const qint16 value = static_cast<qint16>( soundBuffer_[ti] * normalizeScale_ * 32767 );
+        qToLittleEndian<qint16>(value, ptr);
+        ptr += channelBytes;
+    }
+}
+
diff --git a/code/train/C++/0087425_ankastremesnetcismi.cpp b/code/train/C++/0087425_ankastremesnetcismi.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..995a18ccd820bf8b580217715d3f6c8bc3650cb2
--- /dev/null
+++ b/code/train/C++/0087425_ankastremesnetcismi.cpp
@@ -0,0 +1,117 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Ramazan Utku
+** Contact: ramazanutku@gmail.com
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $UKIRIS_BEGIN_LICENSE:BSD$
+** 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."
+**
+** TURKISH
+** Her hakkı saklıdır.
+** Değişiklik yapılarak veya yapılmaksızın, yeniden dağıtmak veya kaynak ve ikili biçimlerde
+** kullanmak, aşağıdaki koşullar yerine getirildiği takdirde serbesttir:
+**
+**  * Kaynak kodun yeniden dağıtımı; yukarıdaki telif hakkı uyarısını, şartlar listesini ve
+**    aşağıdaki ret yazısını muhafaza etmelidir.
+**  * İkili biçimde yeniden dağıtımında; yukarıdaki telif hakkı uyarısı, şartlar listesi ve
+**    aşağıdaki ret yazısı dağıtımla birlikte gelen belgelendirmede ve/veya diğer materyallerde
+**    tekrarlanmalıdır.
+**
+** İŞBU YAZILIM TELİF HAKKI SAHİPLERİ VE KATKIDA BULUNANLAR TARAFINDAN OLDUĞU GİBİ” SAĞLANMIŞTIR
+** VE TİCARETE ELVERİŞLİLİK VE ÖZEL BİR AMACA UYGUNLUK İÇİN KAPALI BİR TAAHHÜT DE DAHİL OLMAK ÜZERE
+** VE BUNUNLA KISITLI OLMAKSIZIN HER TÜRLÜ AÇIK YA DA KAPALI TAAHHÜT REDDEDİLMİŞTİR.
+** HİÇBİR KOŞULDA TELİF HAKKI SAHİPLERİ VE KATKIDA BULUNANLAR; HER NE SEBEPLE OLUŞMUŞSA VE SÖZLEŞMEDE,
+** KUSURSUZ SORUMLULUKTA, VEYA TAZMİNAT YÜKÜMLÜLÜĞÜNDE OLMAK ÜZERE HANGİ YÜKÜMLÜLÜK KURAMINDA
+** YER ALIRSA ALSIN,İŞBU YAZILIMIN KULLANIMIYLA ORTAYA ÇIKAN DOĞRUDAN, DOLAYLI, TESADÜFİ, ÖZEL,
+** CEZAİ VEYA BİR SEBEP SONUCUNDA OLUŞAN (YEDEK PARÇA VEYA HİZMETLERİN TEMİNİ; KULLANIM,
+** VERİ VEYA RANDIMAN KAYBI; YA DA İŞ KESİNTİSİ DE DAHİL OLMAK ÜZERE VE BUNUNLA KISITLI KALMAKSIZIN)
+** HERHANGİ BİR ZARAR İÇİN, BU GİBİ HASARLARIN OLASILIĞI HAKKINDA UYARILMIŞ OLSALAR BİLE, SİZE KARŞI
+** SORUMLU DEĞİLLERDİR.
+**
+** $UKIRIS_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "ankastremesnetcismi.h"
+
+AnkastreMesnetCismi::AnkastreMesnetCismi(CisimModeli *parent)
+    : cisimModelim(parent)
+{
+    tipim = cisimModelim->tipAl();
+    siram = cisimModelim->siraAl();
+}
+
+QPainterPath AnkastreMesnetCismi::shape() const
+{
+    QPainterPath yol;
+    yol.addRect(boundingRect());
+    return yol;
+}
+
+void AnkastreMesnetCismi::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+{
+    prepareGeometryChange();
+    painter->setRenderHint(QPainter::Antialiasing);
+    x = cisimModelim->noktaKonumuAl();
+    y = 0;
+    cisimModelim->tipAta(CisimModeli::AnkastreMesnet);
+
+    qreal _x = x-40;
+    qreal _y = -40;
+    qreal w = 60;
+    qreal h = 100;
+    if (cisimModelim->noktaKonumuAl() != 0) {
+        painter->rotate(180);
+        _x = -1 * _x;
+        _y = -1 * _y;
+        w = -1*w;
+        h = -1*h;
+    }
+    QPolygonF ankastreMesnetim;
+    cisimAlani.setRect(_x,_y,w,h);
+
+    ankastreMesnetim<< QPointF(-20,-40)
+                    << QPointF(-20,-10) << QPointF(0,-10)
+                    << QPointF(0,-5) << QPointF(10,-5)
+                    << QPointF(10,5) << QPointF(0,5)
+                    << QPointF(0,10) << QPointF(-20,10)
+                    << QPointF(-20,40);
+
+    painter->drawPolygon(ankastreMesnetim);
+    for (int i = -30; i < 50; i+=10) {
+        QPolygonF cizgi;
+        cizgi << QPointF(-30,i-10) << QPointF (-20,i);
+        painter->drawPolygon(cizgi);
+    }
+}
diff --git a/code/train/C++/0088954_X86FixupSetCC.cpp b/code/train/C++/0088954_X86FixupSetCC.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..924f429fc13885e32766e2eb53e6da4318dcd32e
--- /dev/null
+++ b/code/train/C++/0088954_X86FixupSetCC.cpp
@@ -0,0 +1,128 @@
+//===---- X86FixupSetCC.cpp - optimize usage of LEA instructions ----------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines a pass that fixes zero-extension of setcc patterns.
+// X86 setcc instructions are modeled to have no input arguments, and a single
+// GR8 output argument. This is consistent with other similar instructions
+// (e.g. movb), but means it is impossible to directly generate a setcc into
+// the lower GR8 of a specified GR32.
+// This means that ISel must select (zext (setcc)) into something like
+// seta %al; movzbl %al, %eax.
+// Unfortunately, this can cause a stall due to the partial register write
+// performed by the setcc. Instead, we can use:
+// xor %eax, %eax; seta %al
+// This both avoids the stall, and encodes shorter.
+//===----------------------------------------------------------------------===//
+
+#include "X86.h"
+#include "X86InstrInfo.h"
+#include "X86Subtarget.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/MachineInstrBuilder.h"
+#include "llvm/CodeGen/MachineRegisterInfo.h"
+
+using namespace llvm;
+
+#define DEBUG_TYPE "x86-fixup-setcc"
+
+STATISTIC(NumSubstZexts, "Number of setcc + zext pairs substituted");
+
+namespace {
+class X86FixupSetCCPass : public MachineFunctionPass {
+public:
+  X86FixupSetCCPass() : MachineFunctionPass(ID) {}
+
+  StringRef getPassName() const override { return "X86 Fixup SetCC"; }
+
+  bool runOnMachineFunction(MachineFunction &MF) override;
+
+private:
+  MachineRegisterInfo *MRI = nullptr;
+  const X86InstrInfo *TII = nullptr;
+
+  enum { SearchBound = 16 };
+
+  static char ID;
+};
+
+char X86FixupSetCCPass::ID = 0;
+}
+
+FunctionPass *llvm::createX86FixupSetCC() { return new X86FixupSetCCPass(); }
+
+bool X86FixupSetCCPass::runOnMachineFunction(MachineFunction &MF) {
+  bool Changed = false;
+  MRI = &MF.getRegInfo();
+  TII = MF.getSubtarget<X86Subtarget>().getInstrInfo();
+
+  SmallVector<MachineInstr*, 4> ToErase;
+
+  for (auto &MBB : MF) {
+    MachineInstr *FlagsDefMI = nullptr;
+    for (auto &MI : MBB) {
+      // Remember the most recent preceding eflags defining instruction.
+      if (MI.definesRegister(X86::EFLAGS))
+        FlagsDefMI = &MI;
+
+      // Find a setcc that is used by a zext.
+      // This doesn't have to be the only use, the transformation is safe
+      // regardless.
+      if (MI.getOpcode() != X86::SETCCr)
+        continue;
+
+      MachineInstr *ZExt = nullptr;
+      for (auto &Use : MRI->use_instructions(MI.getOperand(0).getReg()))
+        if (Use.getOpcode() == X86::MOVZX32rr8)
+          ZExt = &Use;
+
+      if (!ZExt)
+        continue;
+
+      if (!FlagsDefMI)
+        continue;
+
+      // We'd like to put something that clobbers eflags directly before
+      // FlagsDefMI. This can't hurt anything after FlagsDefMI, because
+      // it, itself, by definition, clobbers eflags. But it may happen that
+      // FlagsDefMI also *uses* eflags, in which case the transformation is
+      // invalid.
+      if (FlagsDefMI->readsRegister(X86::EFLAGS))
+        continue;
+
+      ++NumSubstZexts;
+      Changed = true;
+
+      // On 32-bit, we need to be careful to force an ABCD register.
+      const TargetRegisterClass *RC = MF.getSubtarget<X86Subtarget>().is64Bit()
+                                          ? &X86::GR32RegClass
+                                          : &X86::GR32_ABCDRegClass;
+      Register ZeroReg = MRI->createVirtualRegister(RC);
+      Register InsertReg = MRI->createVirtualRegister(RC);
+
+      // Initialize a register with 0. This must go before the eflags def
+      BuildMI(MBB, FlagsDefMI, MI.getDebugLoc(), TII->get(X86::MOV32r0),
+              ZeroReg);
+
+      // X86 setcc only takes an output GR8, so fake a GR32 input by inserting
+      // the setcc result into the low byte of the zeroed register.
+      BuildMI(*ZExt->getParent(), ZExt, ZExt->getDebugLoc(),
+              TII->get(X86::INSERT_SUBREG), InsertReg)
+          .addReg(ZeroReg)
+          .addReg(MI.getOperand(0).getReg())
+          .addImm(X86::sub_8bit);
+      MRI->replaceRegWith(ZExt->getOperand(0).getReg(), InsertReg);
+      ToErase.push_back(ZExt);
+    }
+  }
+
+  for (auto &I : ToErase)
+    I->eraseFromParent();
+
+  return Changed;
+}
diff --git a/code/train/C++/0089110_SACMethodRANSAC.cpp b/code/train/C++/0089110_SACMethodRANSAC.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d83022047e17b0646a3456cf829600cf2f1277df
--- /dev/null
+++ b/code/train/C++/0089110_SACMethodRANSAC.cpp
@@ -0,0 +1,98 @@
+/*
+ * @file: SACMethodRANSAC.cpp
+ *
+ * @date: Apr 19, 2011
+ * @author: reon
+ */
+
+#include "SACMethodRANSAC.h"
+
+namespace brics_3d {
+
+
+SACMethodRANSAC::SACMethodRANSAC(){}
+
+SACMethodRANSAC::~SACMethodRANSAC() {}
+
+bool SACMethodRANSAC::computeModel(){
+
+	 // Warn and exit if no threshold was set
+     if (this->threshold == -1)
+     {
+       cout<<"[RANSAC::computeModel] No threshold set!"<<endl;
+       return (false);
+     }
+
+
+     this->iterations = 0;
+     int noMaxInliersFound = std::numeric_limits<int>::min();
+     double k = 1.0;
+
+     std::vector<int> bestModel;
+     std::vector<int> bestModelIndices, inliers;
+     Eigen::VectorXd estimatedModelCoefficients;
+
+     int noInliersCurrentModel = 0;
+
+
+     while (this->iterations < k)
+     {
+
+       //Compute a random model from the input pointcloud
+       bool isDegenerate = false;
+       bool modelFound = false;
+       this->objectModel->computeRandomModel(this->iterations,estimatedModelCoefficients,isDegenerate,modelFound);
+
+
+
+       if (!isDegenerate) break;
+
+       if(!modelFound){
+
+    	   this->iterations++;
+    	   continue;
+       }
+
+
+
+       // The inliers within the user-defined threshold are selected
+       this->objectModel->selectWithinDistance (estimatedModelCoefficients, this->threshold, inliers);
+       noInliersCurrentModel = inliers.size ();
+
+
+       //Select the best model estimation. The number of inliers in the model
+       //will be maximized
+       if (noInliersCurrentModel > noMaxInliersFound)
+       {
+         noMaxInliersFound = noInliersCurrentModel;
+
+         // Save the current model/inlier/coefficients selection as being the best so far
+         this->inliers            = inliers;
+         this->modelCoefficients = estimatedModelCoefficients;
+
+         // Compute the k parameter (k=log(z)/log(1-w^n))
+         double w = (double)((double)noInliersCurrentModel / (double)this->objectModel->getInputCloud()->getSize());
+         double pNoOutliers = 1 - pow (w, (double)this->objectModel->getNumberOfSamplesRequired());
+         pNoOutliers = std::max (std::numeric_limits<double>::epsilon (), pNoOutliers);       // Avoid division by -Inf
+         pNoOutliers = std::min (1 - std::numeric_limits<double>::epsilon (), pNoOutliers);   // Avoid division by 0.
+         k = log (1 - this->probability) / log (pNoOutliers);
+       }
+
+
+       this->iterations++;
+
+       if (this->iterations > this->maxIterations)
+       {
+           cout<<"[RANSAC::computeModel] RANSAC reached the maximum number of trials";
+         break;
+       }
+
+     }
+
+
+     if (this->inliers.size() == 0)
+       return (false);
+     return (true);
+}
+
+}
diff --git a/code/train/C++/0091315_motion_emu.cpp b/code/train/C++/0091315_motion_emu.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..31e11875de0e5c2da22d1257253e120e76f3e70a
--- /dev/null
+++ b/code/train/C++/0091315_motion_emu.cpp
@@ -0,0 +1,173 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <chrono>
+#include <mutex>
+#include <thread>
+#include <tuple>
+#include "common/math_util.h"
+#include "common/quaternion.h"
+#include "common/thread.h"
+#include "common/vector_math.h"
+#include "input_common/motion_emu.h"
+
+namespace InputCommon {
+
+// Implementation class of the motion emulation device
+class MotionEmuDevice {
+public:
+    MotionEmuDevice(int update_millisecond, float sensitivity, float tilt_clamp)
+        : update_millisecond(update_millisecond),
+          update_duration(std::chrono::duration_cast<std::chrono::steady_clock::duration>(
+              std::chrono::milliseconds(update_millisecond))),
+          sensitivity(sensitivity), tilt_clamp(tilt_clamp),
+          motion_emu_thread(&MotionEmuDevice::MotionEmuThread, this) {}
+
+    ~MotionEmuDevice() {
+        if (motion_emu_thread.joinable()) {
+            shutdown_event.Set();
+            motion_emu_thread.join();
+        }
+    }
+
+    void BeginTilt(int x, int y) {
+        mouse_origin = Math::MakeVec(x, y);
+        is_tilting = true;
+    }
+
+    void Tilt(int x, int y) {
+        auto mouse_move = Math::MakeVec(x, y) - mouse_origin;
+        if (is_tilting) {
+            std::lock_guard<std::mutex> guard(tilt_mutex);
+            if (mouse_move.x == 0 && mouse_move.y == 0) {
+                tilt_angle = 0;
+            } else {
+                tilt_direction = mouse_move.Cast<float>();
+                tilt_angle = std::clamp(tilt_direction.Normalize() * sensitivity, 0.0f,
+                                        MathUtil::PI * this->tilt_clamp / 180.0f);
+            }
+        }
+    }
+
+    void EndTilt() {
+        std::lock_guard<std::mutex> guard(tilt_mutex);
+        tilt_angle = 0;
+        is_tilting = false;
+    }
+
+    std::tuple<Math::Vec3<float>, Math::Vec3<float>> GetStatus() {
+        std::lock_guard<std::mutex> guard(status_mutex);
+        return status;
+    }
+
+private:
+    const int update_millisecond;
+    const std::chrono::steady_clock::duration update_duration;
+    const float sensitivity;
+
+    Math::Vec2<int> mouse_origin;
+
+    std::mutex tilt_mutex;
+    Math::Vec2<float> tilt_direction;
+    float tilt_angle = 0;
+    float tilt_clamp = 90;
+
+    bool is_tilting = false;
+
+    Common::Event shutdown_event;
+
+    std::tuple<Math::Vec3<float>, Math::Vec3<float>> status;
+    std::mutex status_mutex;
+
+    // Note: always keep the thread declaration at the end so that other objects are initialized
+    // before this!
+    std::thread motion_emu_thread;
+
+    void MotionEmuThread() {
+        auto update_time = std::chrono::steady_clock::now();
+        Math::Quaternion<float> q = MakeQuaternion(Math::Vec3<float>(), 0);
+        Math::Quaternion<float> old_q;
+
+        while (!shutdown_event.WaitUntil(update_time)) {
+            update_time += update_duration;
+            old_q = q;
+
+            {
+                std::lock_guard<std::mutex> guard(tilt_mutex);
+
+                // Find the quaternion describing current 3DS tilting
+                q = MakeQuaternion(Math::MakeVec(-tilt_direction.y, 0.0f, tilt_direction.x),
+                                   tilt_angle);
+            }
+
+            auto inv_q = q.Inverse();
+
+            // Set the gravity vector in world space
+            auto gravity = Math::MakeVec(0.0f, -1.0f, 0.0f);
+
+            // Find the angular rate vector in world space
+            auto angular_rate = ((q - old_q) * inv_q).xyz * 2;
+            angular_rate *= 1000 / update_millisecond / MathUtil::PI * 180;
+
+            // Transform the two vectors from world space to 3DS space
+            gravity = QuaternionRotate(inv_q, gravity);
+            angular_rate = QuaternionRotate(inv_q, angular_rate);
+
+            // Update the sensor state
+            {
+                std::lock_guard<std::mutex> guard(status_mutex);
+                status = std::make_tuple(gravity, angular_rate);
+            }
+        }
+    }
+};
+
+// Interface wrapper held by input receiver as a unique_ptr. It holds the implementation class as
+// a shared_ptr, which is also observed by the factory class as a weak_ptr. In this way the factory
+// can forward all the inputs to the implementation only when it is valid.
+class MotionEmuDeviceWrapper : public Input::MotionDevice {
+public:
+    MotionEmuDeviceWrapper(int update_millisecond, float sensitivity, float tilt_clamp) {
+        device = std::make_shared<MotionEmuDevice>(update_millisecond, sensitivity, tilt_clamp);
+    }
+
+    std::tuple<Math::Vec3<float>, Math::Vec3<float>> GetStatus() const override {
+        return device->GetStatus();
+    }
+
+    std::shared_ptr<MotionEmuDevice> device;
+};
+
+std::unique_ptr<Input::MotionDevice> MotionEmu::Create(const Common::ParamPackage& params) {
+    int update_period = params.Get("update_period", 100);
+    float sensitivity = params.Get("sensitivity", 0.01f);
+    float tilt_clamp = params.Get("tilt_clamp", 90.0f);
+    auto device_wrapper =
+        std::make_unique<MotionEmuDeviceWrapper>(update_period, sensitivity, tilt_clamp);
+    // Previously created device is disconnected here. Having two motion devices for 3DS is not
+    // expected.
+    current_device = device_wrapper->device;
+    return std::move(device_wrapper);
+}
+
+void MotionEmu::BeginTilt(int x, int y) {
+    if (auto ptr = current_device.lock()) {
+        ptr->BeginTilt(x, y);
+    }
+}
+
+void MotionEmu::Tilt(int x, int y) {
+    if (auto ptr = current_device.lock()) {
+        ptr->Tilt(x, y);
+    }
+}
+
+void MotionEmu::EndTilt() {
+    if (auto ptr = current_device.lock()) {
+        ptr->EndTilt();
+    }
+}
+
+} // namespace InputCommon
diff --git a/code/train/C++/0091915_ppm_view.cc b/code/train/C++/0091915_ppm_view.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ace6b21050828b47fcf2700a33244098281df6c9
--- /dev/null
+++ b/code/train/C++/0091915_ppm_view.cc
@@ -0,0 +1,94 @@
+// ppm_view.cc
+// viewer and translator for ppm images
+// Copyright (c) 2014 John K. Johnstone 
+
+#include <fstream>
+using namespace std;
+
+#include "miscellany.h"                        // GetSuffix, ChangeSuffixPlusDot
+#include "ppm.h"                          // ReadPPM, WritePPM, FlipPPMforOpenGL
+#include "viewer.h"
+using namespace pierre;
+
+static void Usage() 
+{
+  cout 
+  << "view an image in ppm format" << endl << endl
+  << " -a: output original image in ascii ppm format" << endl
+  << " -r: output original image in raw ppm format" << endl 
+  << " -g: output as grayscale image, in raw ppm format" << endl
+  << " -b: output as bitmap using 3x3 dithering, in raw ppm format" << endl
+  << endl
+  << "input: foo.ppm" << endl
+  << "output (potential): foo_P3.ppm, foo_P6.ppm, foo_gray.ppm OR foo_bitmap.ppm" << endl;
+  exit(-1);
+}
+
+int main (int argc, char **argv)
+{
+  bool output_ascii = 0;
+  bool output_raw = 0;
+  bool output_gray = 0;
+  bool output_bitmap = 0;
+  if (argc == 1) Usage();
+  int args_parsed = 1;
+  while (args_parsed < argc)
+   {
+    if ('-' == argv[args_parsed][0])
+      switch (argv[args_parsed++][1])
+      {
+      case 'a': output_ascii = 1; break;
+      case 'r': output_raw = 1; break;
+      case 'g': output_gray = 1; break;
+      case 'b': output_bitmap = 1; break;
+      case 'h':
+      default:	Usage(); break;
+      }
+   else args_parsed++;
+  }
+
+  string ppmName = argv[argc-1];
+  string suffix; GetSuffix (ppmName, suffix); assert (suffix=="ppm");
+
+  Viewer viewer;
+  ifstream infile (argv[argc-1]);
+  ReadPPM (infile, viewer.img_);
+
+  // stub to be completed by 470/670 teams + 770: 
+  // create grayscale PPM image in viewer.img_gray_
+
+  // stub to be completed only by 670 teams + 770: 
+  // create bitmap PPM image in viewer.img_dither_
+
+  if (output_ascii)
+   {
+    // stub to be completed by everyone
+    ;
+   }
+  else if (output_raw)
+   {
+    suffix = "_P6.ppm";
+    ChangeSuffixPlusDot (ppmName, suffix);
+    ofstream outfile (ppmName.c_str());
+    WritePPM (viewer.img_, outfile, 0);
+   }
+  else if (output_gray)
+   {
+    // stub to be completed by all x70 students :
+    // output the grayscale image, named foo_gray.ppm
+    ;
+   }
+  else if (output_bitmap)
+   {
+    // stub to be completed by 670 and 770 students
+    // output the bitmap image, named foo_bitmap.ppm
+    ;
+   }
+  FlipPPMforOpenGL (viewer.img_);
+  /* uncomment once these images are generated
+  FlipPPMforOpenGL (viewer.img_gray_);
+  FlipPPMforOpenGL (viewer.img_dither_);
+  */
+  viewer.init (argv[argc-1]);
+  return 0;
+}
diff --git a/code/train/C++/0092730_textquickitem.cpp b/code/train/C++/0092730_textquickitem.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bed1899f28b760f33197bb67bc0f11f396799ea0
--- /dev/null
+++ b/code/train/C++/0092730_textquickitem.cpp
@@ -0,0 +1,132 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        textquickitem.cpp
+// Author:      Jonathan Schluessler
+// Created:     2017
+// Copyright (c) Authors and others. All rights reserved.
+/////////////////////////////////////////////////////////////////////////////
+
+#include "vrvqt/textquickitem.h"
+
+//----------------------------------------------------------------------------
+
+#include <QPainter>
+
+//#define DRAW_DEBUG_BOUNDING_BOXES
+
+namespace vrvQt {
+
+TextQuickItem::TextQuickItem()
+{
+    // TODO: Try following optimization hints on different platforms
+    // setRenderTarget(QQuickPaintedItem::FramebufferObject);
+    // setPerformanceHint(QQuickPaintedItem::FastFBOResizing);
+    // setAntialiasing(true);
+    // setMipmap(true);
+}
+
+void TextQuickItem::appendText(QString text, QFont font)
+{
+    m_textParts.append(TextWithFont(text, font));
+}
+
+void TextQuickItem::calcPos()
+{
+    // Note: It is not possible to re-use the existing bounding-box of the verovio-object because the stored
+    // values may be out-of-date. Thus we have to recalculate the correct position and baseline by examining the font.
+
+    int textWidth = 0;
+    int textAscent = 0;
+    int textDescent = 0;
+    int textXShift = 0;
+
+    bool hasBoldFont = false;
+    bool hasItalicFont = false;
+
+    bool firstLoop = true;
+    for (TextWithFont &textWithFont : m_textParts) {
+
+        // Note: Initial construction of QFontMetrics is expensive (This function takes ~95% of first updatePaintNode
+        // call - e.g 48,5 of 51 ms)! Subsequent calls are much faster, so Qt seems to already have a caching mechanism
+        // in place. There is no significant difference between using tightBoundingRect, boundingRect or merely
+        // height/width.
+        QFontMetrics fm(textWithFont.font);
+
+        // QFontMetrics::boundingRect(QChar) is more accurate than the QString overload, thus we prefer it if we only
+        // have 1 symbol (which is often the case, e.g. for music text). Using tightBoundingRect would result in many
+        // bounding boxes that are too narrow.
+        QRect boundingRect;
+        if (textWithFont.text.size() == 1)
+            boundingRect = fm.boundingRect(textWithFont.text.front());
+        else
+            boundingRect = fm.boundingRect(textWithFont.text);
+
+        textWithFont.offset = textWidth;
+        textWidth += boundingRect.right() - boundingRect.left();
+        textAscent = std::max(textAscent, boundingRect.top() * -1);
+        textDescent = std::max(textDescent, boundingRect.bottom());
+        if (firstLoop) {
+            // Note that the bounding rect can start at a negative x (e.g. italic font)
+            textXShift = boundingRect.left();
+            if (textXShift < 0) textWidth -= textXShift;
+            firstLoop = false;
+        }
+
+        if (textWithFont.font.bold()) hasBoldFont = true;
+        if (textWithFont.font.italic()) hasItalicFont = true;
+    }
+
+    // Security margin for bold/italic fonts because the bounding rects are sometimes too narrow
+    if (hasBoldFont || hasItalicFont) {
+        textWidth += 4;
+        textAscent += 4;
+        textDescent += 1;
+    }
+
+    qreal newX = x() + textXShift;
+    if (m_alignment == Qt::AlignRight) {
+        setX(newX - textWidth);
+    }
+    else if (m_alignment == Qt::AlignHCenter) {
+        setX(newX - textWidth / 2);
+    }
+    else {
+        setX(newX);
+    }
+    setY(y() - textAscent);
+
+    m_paintOffsetY = textAscent;
+    m_paintOffsetX = -textXShift;
+
+    int textHeight = textDescent + textAscent + 1;
+
+    setImplicitWidth(textWidth);
+    setImplicitHeight(textHeight);
+}
+
+void TextQuickItem::setColor(QColor color)
+{
+    m_color = color;
+    update();
+}
+
+bool TextQuickItem::isEmpty()
+{
+    return m_textParts.empty();
+}
+
+void TextQuickItem::paint(QPainter *painter)
+{
+    painter->setPen(m_color);
+
+    for (TextWithFont textWithFont : m_textParts) {
+        painter->setFont(textWithFont.font);
+        painter->drawText(m_paintOffsetX + textWithFont.offset, m_paintOffsetY, textWithFont.text);
+    }
+
+#ifdef DRAW_DEBUG_BOUNDING_BOXES
+    painter->setPen(QColor(Qt::red));
+    painter->setBrush(QColor(255, 0, 0, 100));
+    painter->drawRect(0, 0, implicitWidth(), implicitHeight());
+#endif
+}
+} // namespace vrvQt
diff --git a/code/train/C++/0092751_LRUPolicy.cc b/code/train/C++/0092751_LRUPolicy.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a1e3b277e1e5f7b4939caa7a08dac1e0af03ed83
--- /dev/null
+++ b/code/train/C++/0092751_LRUPolicy.cc
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2013 Advanced Micro Devices, Inc
+ * All rights reserved.
+ *
+ * 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 copyright holders 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.
+ *
+ * Author: Derek Hower
+ */
+
+#include "mem/ruby/structures/LRUPolicy.hh"
+
+
+
+LRUPolicy::LRUPolicy(const Params * p)
+    : AbstractReplacementPolicy(p)
+{
+}
+
+
+LRUPolicy::~LRUPolicy()
+{
+}
+
+LRUPolicy *
+LRUReplacementPolicyParams::create()
+{
+    return new LRUPolicy(this);
+}
+
+
+void
+LRUPolicy::touch(int64 set, int64 index, Tick time)
+{
+    assert(index >= 0 && index < m_assoc);
+    assert(set >= 0 && set < m_num_sets);
+
+    m_last_ref_ptr[set][index] = time;
+}
+
+int64
+LRUPolicy::getVictim(int64 set) const
+{
+    Tick time, smallest_time;
+    int64 smallest_index;
+
+    smallest_index = 0;
+    smallest_time = m_last_ref_ptr[set][0];
+
+    for (unsigned i = 0; i < m_assoc; i++) {
+        time = m_last_ref_ptr[set][i];
+
+        if (time < smallest_time) {
+            smallest_index = i;
+            smallest_time = time;
+        }
+    }
+
+    return smallest_index;
+}
diff --git a/code/train/C++/0092788_gmm-make-regtree.cc b/code/train/C++/0092788_gmm-make-regtree.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8c79d013e0d9a7f86cfd3877d9e4372d6717c9dd
--- /dev/null
+++ b/code/train/C++/0092788_gmm-make-regtree.cc
@@ -0,0 +1,107 @@
+// gmmbin/gmm-make-regtree.cc
+
+// Copyright 2009-2011  Saarland University;  Microsoft Corporation
+
+// 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 "base/kaldi-common.h"
+#include "util/kaldi-io.h"
+#include "util/text-utils.h"
+#include "gmm/mle-am-diag-gmm.h"
+#include "tree/context-dep.h"
+#include "hmm/transition-model.h"
+#include "transform/regression-tree.h"
+
+
+int main(int argc, char *argv[]) {
+  try {
+    typedef kaldi::int32 int32;
+    typedef kaldi::BaseFloat BaseFloat;
+
+    const char *usage =
+        "Build regression class tree.\n"
+        "Usage: gmm-make-regtree [options] <model-file> <regtree-out>\n"
+        "E.g.: gmm-make-regtree --silphones=1:2:3 --state-occs=1.occs 1.mdl 1.regtree\n"
+        " [Note: state-occs come from --write-occs option of gmm-est]\n";
+
+    std::string occs_in_filename;
+    std::string sil_phones_str;
+    bool binary_write = true;
+    int32 max_leaves = 1;
+    kaldi::ParseOptions po(usage);
+    po.Register("state-occs", &occs_in_filename, "File containing state occupancies (use --write-occs in gmm-est)");
+    po.Register("sil-phones", &sil_phones_str, "Colon-separated list of integer ids of silence phones, e.g. 1:2:3; if used, create top-level speech/sil split (only one reg-class for silence).");
+    po.Register("binary", &binary_write, "Write output in binary mode");
+    po.Register("max-leaves", &max_leaves, "Maximum number of leaves in regression tree.");
+    po.Read(argc, argv);
+
+    if (po.NumArgs() != 2) {
+      po.PrintUsage();
+      exit(1);
+    }
+
+    std::string model_in_filename = po.GetArg(1),
+        tree_out_filename = po.GetArg(2);
+
+    kaldi::AmDiagGmm am_gmm;
+    kaldi::TransitionModel trans_model;
+    {
+      bool binary_read;
+      kaldi::Input ki(model_in_filename, &binary_read);
+      trans_model.Read(ki.Stream(), binary_read);
+      am_gmm.Read(ki.Stream(), binary_read);
+    }
+
+    kaldi::Vector<BaseFloat> state_occs;
+    if (occs_in_filename != "") {
+      bool binary_read;
+      kaldi::Input ki(occs_in_filename, &binary_read);
+      state_occs.Read(ki.Stream(), binary_read);
+    } else {
+      KALDI_LOG << "--state-occs option not provided so using constant occupancies.";
+      state_occs.Resize(am_gmm.NumPdfs());
+      state_occs.Set(1.0);
+    }
+
+    std::vector<int32> sil_pdfs;
+    if (sil_phones_str != "") {
+      std::vector<int32> sil_phones;
+      if (!kaldi::SplitStringToIntegers(sil_phones_str, ":", false, &sil_phones))
+        KALDI_ERR << "invalid sil-phones option " << sil_phones_str;
+      std::sort(sil_phones.begin(), sil_phones.end());
+      bool ans = GetPdfsForPhones(trans_model, sil_phones, &sil_pdfs);
+      if (!ans)
+        KALDI_WARN << "Pdfs associated with silence phones are not only "
+            "associated with silence phones: your speech-silence split "
+            "may not be meaningful.";
+    }
+
+    kaldi::RegressionTree regtree;
+    regtree.BuildTree(state_occs, sil_pdfs, am_gmm, max_leaves);
+    // Write out the regression tree
+    {
+      kaldi::Output ko(tree_out_filename, binary_write);
+      regtree.Write(ko.Stream(), binary_write);
+    }
+
+    KALDI_LOG << "Written regression tree to " << tree_out_filename;
+  } catch(const std::exception &e) {
+    std::cerr << e.what() << '\n';
+    return -1;
+  }
+}
+
+
diff --git a/code/train/C++/0093179_main.cc b/code/train/C++/0093179_main.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e783b53bb289410c09ca13ac9a66291b6d04905a
--- /dev/null
+++ b/code/train/C++/0093179_main.cc
@@ -0,0 +1,100 @@
+// Copyright (c) 2016, reginell. All rights reserved.
+// Use of this source code is governed by a BSD license that can be
+// found in the LICENSE file.
+//
+// Subject: Algorithms and Data structures (AaDs).
+
+#include <cmath>
+#include <cstddef>
+#include <iomanip>
+#include <iostream>
+#include <vector>
+
+using usize = std::size_t;
+using i32 = int;
+using f64 = double;
+
+template <typename T, typename Y>
+constexpr inline T implicit_cast(const Y& value) noexcept {
+  return value;
+}
+
+template <class T>
+using vec = std::vector<T, std::allocator<T>>;
+
+f64 f(f64 x) noexcept { return std::pow(x, 2) + 5 * std::cos(x) - 3; }
+
+f64 MD(f64 a, f64 b, f64 e) noexcept {
+  f64 x[3], y[3]{};
+  x[0] = a;
+  x[1] = b;
+  y[0] = f(x[0]);
+
+  do {
+    x[2] = (x[0] + x[1]) / 2;
+    y[2] = f(x[2]);
+    const f64 v = y[0] * y[2];
+
+    if (v > 0) {
+      x[0] = x[2];
+      y[0] = y[2];
+    } else {
+      x[1] = x[2];
+      y[1] = y[2];
+    }
+  } while ((x[1] - x[0]) > e);
+
+  return (x[0] + x[1]) / 2;
+}
+
+int main() {
+  i32 a, b;
+  f64 m, e;
+
+  std::cout << "a = ";
+  std::cin >> a;
+  std::cout << "b = ";
+  std::cin >> b;
+  std::cout << "m = ";
+  std::cin >> m;
+  std::cout << "e = ";
+  std::cin >> e;
+
+  const f64 h{(b * 1.0 - a) / m};
+  f64 X = a;
+  f64 y{f(X)};
+
+  std::cout.flags(std::ios::right);
+  std::cout.precision(4);  //-V112
+
+  std::cout << std::setw(9) << "X"
+            << "\t" << std::setw(9) << "Y" << std::endl;
+  std::cout << std::setw(9) << X << "\t" << std::setw(9) << y << std::endl;
+
+  X += h;
+  f64 u{y};
+
+  auto z = vec<f64>(implicit_cast<usize>(m) + 1);
+  usize i{0};
+
+  while (X <= b) {
+    y = f(X);
+    std::cout << std::setw(9) << X << "\t" << std::setw(9) << y << std::endl;
+
+    if ((u > 0 && y < 0) || (u < 0 && y > 0)) {
+      z[i++] = MD(X - h, X, e);
+    }
+
+    u = y;
+    X += h;
+  }
+
+  const usize k{i};
+  std::cout << std::endl;
+
+  for (i = 0; i < k; i++)
+    std::cout << "X" << i + 1 << " = " << z[i] << ", e = " << std::fabs(f(z[i]))
+              << std::endl;
+
+  return 0;
+}
diff --git a/code/train/C++/0093521_39._Combination_Sum.cpp b/code/train/C++/0093521_39._Combination_Sum.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..998f51f42d8c0eefbb2e2f029bd296b9a43c36ce
--- /dev/null
+++ b/code/train/C++/0093521_39._Combination_Sum.cpp
@@ -0,0 +1,80 @@
+//
+//  39. Combination Sum.cpp
+//  leetcode
+//
+//  Created by Yuebin Yang on 2017/2/3.
+//  Copyright © 2017年 yuebin. All rights reserved.
+//
+//  Question:
+        //Given a set of candidate numbers (C) (without duplicates) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.
+        //
+        //The same repeated number may be chosen from C unlimited number of times.
+        //
+        //Note:
+        //All numbers (including target) will be positive integers.
+        //The solution set must not contain duplicate combinations.
+        //For example, given candidate set [2, 3, 6, 7] and target 7,
+        //A solution set is:
+                //[7],
+                //[2, 2, 3]
+
+//  idea: because every element maybe used for more than one time. I use recursion to find out all the possible solutions.
+
+#include <iostream>
+#include <stdio.h>
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+
+class Solution {
+public:
+    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
+        vector<int> path;
+        vector<vector<int>>result;
+        int len=candidates.size();
+        sort(candidates.begin(),candidates.end());
+        DFS(candidates,path,0,target,result);
+        
+        return result;
+    }// combinationSum
+    
+private:
+    void DFS(vector<int>& candidates,vector<int>& path,int start,int target,vector<vector<int>>& result)
+    {
+        if(target==0)
+        {
+            result.push_back(path);
+            return;
+        }
+        for(int i=start;i<candidates.size();i++)
+        {
+            if(candidates[i]>target)
+                return;
+            path.push_back(candidates[i]);
+            DFS(candidates, path, i, target-candidates[i], result);
+            path.pop_back();
+        }
+    }// DFS
+};
+
+
+int main(){
+    Solution solution;
+    int target = 12;
+    vector<int> vec;
+    vec.push_back(2);
+    vec.push_back(4);
+    //vec.push_back();
+    vec.push_back(8);
+    
+    vector<vector<int> > result = solution.combinationSum(vec,target);
+    // 输出
+    for(int i = 0;i < result.size();++i){
+        for(int j = 0;j < result[i].size();++j){
+            cout<<result[i][j]<<" ";
+        }
+        cout<<endl;
+    }
+    return 0;
+}
diff --git a/code/train/C++/0094022_EstimatingTheMean.cpp b/code/train/C++/0094022_EstimatingTheMean.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..848e18cb744c0220062f72b2fda66380ad6e6321
--- /dev/null
+++ b/code/train/C++/0094022_EstimatingTheMean.cpp
@@ -0,0 +1,58 @@
+#include <bits/stdc++.h>
+
+template<typename T> T gcd(T a, T b) {
+    if(!b) return a;
+    return gcd(b, a % b);
+}
+template<typename T> T lcm(T a, T b) {
+    return a * b / gcd(a, b);
+}
+
+template<typename T> void chmin(T& a, T b) { a = (a > b) ? b : a; }
+template<typename T> void chmax(T& a, T b) { a = (a < b) ? b : a; }
+int in() { int x; scanf("%d", &x); return x; }
+
+using namespace std;
+
+typedef long long Int;
+typedef unsigned uint;
+
+const int MAXN = 100005;
+
+int T, N, P[MAXN];
+
+int main(void) {
+	cin >> T;
+
+	for (int t = 1; t <= T; t++) {
+		cin >> N;
+
+		int best = -1;
+		int ans = 0;
+		
+		for (int i = 0; i < N; i++) {
+			cin >> P[i];
+
+			if (P[i] > best) {
+				best = P[i];
+			}
+		}
+
+		for (int i = 0; i < N; i++) {
+			if (P[i] == best) {
+				int len = 1;
+				int j = i + 1;
+
+				while (j < N && P[j] == best) {
+					j += 1;
+					len += 1;
+				}
+
+				ans = max(ans, len);
+				i = j;
+			}
+		}
+		cout << "Caso #" << t << ": " << ans << "\n";
+	}
+    return 0;
+}
diff --git a/code/train/C++/0094282_keyword_matcher.cpp b/code/train/C++/0094282_keyword_matcher.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..68d20980f00fd215dc1cce71713ac1a996d99b8e
--- /dev/null
+++ b/code/train/C++/0094282_keyword_matcher.cpp
@@ -0,0 +1,173 @@
+#include "search/keyword_matcher.hpp"
+
+#include "indexer/search_delimiters.hpp"
+#include "indexer/search_string_utils.hpp"
+
+#include "base/assert.hpp"
+#include "base/buffer_vector.hpp"
+#include "base/stl_add.hpp"
+
+#include <algorithm>
+#include <sstream>
+
+using namespace std;
+
+namespace search
+{
+KeywordMatcher::KeywordMatcher()
+{
+  Clear();
+}
+
+void KeywordMatcher::Clear()
+{
+  m_keywords.clear();
+  m_prefix.clear();
+}
+
+void KeywordMatcher::SetKeywords(strings::UniString const * keywords, size_t count,
+                                 strings::UniString const & prefix)
+{
+  m_keywords.assign(keywords, keywords + count);
+  m_prefix = prefix;
+}
+
+KeywordMatcher::Score KeywordMatcher::CalcScore(string const & name) const
+{
+  return CalcScore(NormalizeAndSimplifyString(name));
+}
+
+KeywordMatcher::Score KeywordMatcher::CalcScore(strings::UniString const & name) const
+{
+  buffer_vector<strings::UniString, kMaxNumTokens> tokens;
+  SplitUniString(name, MakeBackInsertFunctor(tokens), Delimiters());
+
+  return CalcScore(tokens.data(), tokens.size());
+}
+
+KeywordMatcher::Score KeywordMatcher::CalcScore(strings::UniString const * tokens,
+                                                size_t count) const
+{
+  // Some names can have too many tokens. Trim them.
+  count = min(count, kMaxNumTokens);
+
+  vector<bool> isQueryTokenMatched(m_keywords.size());
+  vector<bool> isNameTokenMatched(count);
+  uint32_t sumTokenMatchDistance = 0;
+  int8_t prevTokenMatchDistance = 0;
+  bool prefixMatched = true;
+
+  for (int i = 0; i < m_keywords.size(); ++i)
+  {
+    for (int j = 0; j < count && !isQueryTokenMatched[i]; ++j)
+    {
+      if (!isNameTokenMatched[j] && m_keywords[i] == tokens[j])
+      {
+        isQueryTokenMatched[i] = isNameTokenMatched[j] = true;
+        int8_t const tokenMatchDistance = i - j;
+        sumTokenMatchDistance += abs(tokenMatchDistance - prevTokenMatchDistance);
+        prevTokenMatchDistance = tokenMatchDistance;
+      }
+    }
+  }
+
+  if (!m_prefix.empty())
+  {
+    prefixMatched = false;
+    for (int j = 0; j < count && !prefixMatched; ++j)
+    {
+      if (!isNameTokenMatched[j] &&
+          strings::StartsWith(tokens[j].begin(), tokens[j].end(), m_prefix.begin(), m_prefix.end()))
+      {
+        isNameTokenMatched[j] = prefixMatched = true;
+        int8_t const tokenMatchDistance = int(m_keywords.size()) - j;
+        sumTokenMatchDistance += abs(tokenMatchDistance - prevTokenMatchDistance);
+      }
+    }
+  }
+
+  uint8_t numQueryTokensMatched = 0;
+  for (size_t i = 0; i < isQueryTokenMatched.size(); ++i)
+  {
+    if (isQueryTokenMatched[i])
+      ++numQueryTokensMatched;
+  }
+
+  Score score;
+  score.m_fullQueryMatched = prefixMatched && (numQueryTokensMatched == isQueryTokenMatched.size());
+  score.m_prefixMatched = prefixMatched;
+  score.m_numQueryTokensAndPrefixMatched = numQueryTokensMatched + (prefixMatched ? 1 : 0);
+
+  score.m_nameTokensMatched = 0;
+  score.m_nameTokensLength = 0;
+  for (size_t i = 0; i < count; ++i)
+  {
+    if (isNameTokenMatched[i])
+      score.m_nameTokensMatched |= (1 << (kMaxNumTokens - 1 - i));
+    score.m_nameTokensLength += tokens[i].size();
+  }
+
+  score.m_sumTokenMatchDistance = sumTokenMatchDistance;
+  return score;
+}
+
+KeywordMatcher::Score::Score()
+  : m_sumTokenMatchDistance(0)
+  , m_nameTokensMatched(0)
+  , m_nameTokensLength(0)
+  , m_numQueryTokensAndPrefixMatched(0)
+  , m_fullQueryMatched(false)
+  , m_prefixMatched(false)
+{
+}
+
+bool KeywordMatcher::Score::operator<(KeywordMatcher::Score const & s) const
+{
+  if (m_fullQueryMatched != s.m_fullQueryMatched)
+    return m_fullQueryMatched < s.m_fullQueryMatched;
+  if (m_numQueryTokensAndPrefixMatched != s.m_numQueryTokensAndPrefixMatched)
+    return m_numQueryTokensAndPrefixMatched < s.m_numQueryTokensAndPrefixMatched;
+  if (m_prefixMatched != s.m_prefixMatched)
+    return m_prefixMatched < s.m_prefixMatched;
+  if (m_nameTokensMatched != s.m_nameTokensMatched)
+    return m_nameTokensMatched < s.m_nameTokensMatched;
+  if (m_sumTokenMatchDistance != s.m_sumTokenMatchDistance)
+    return m_sumTokenMatchDistance > s.m_sumTokenMatchDistance;
+
+  return false;
+}
+
+bool KeywordMatcher::Score::operator==(KeywordMatcher::Score const & s) const
+{
+  return m_sumTokenMatchDistance == s.m_sumTokenMatchDistance
+      && m_nameTokensMatched == s.m_nameTokensMatched
+      && m_numQueryTokensAndPrefixMatched == s.m_numQueryTokensAndPrefixMatched
+      && m_fullQueryMatched == s.m_fullQueryMatched
+      && m_prefixMatched == s.m_prefixMatched;
+}
+
+bool KeywordMatcher::Score::LessInTokensLength(Score const & s) const
+{
+  if (m_fullQueryMatched)
+  {
+    ASSERT(s.m_fullQueryMatched, ());
+    return m_nameTokensLength > s.m_nameTokensLength;
+  }
+  return false;
+}
+
+string DebugPrint(KeywordMatcher::Score const & score)
+{
+  ostringstream out;
+  out << "KeywordMatcher::Score(";
+  out << "FQM=" << score.m_fullQueryMatched;
+  out << ",nQTM=" << static_cast<int>(score.m_numQueryTokensAndPrefixMatched);
+  out << ",PM=" << score.m_prefixMatched;
+  out << ",NTM=";
+  for (int i = static_cast<int>(kMaxNumTokens) - 1; i >= 0; --i)
+    out << ((score.m_nameTokensMatched >> i) & 1);
+  out << ",STMD=" << score.m_sumTokenMatchDistance;
+  out << ")";
+  return out.str();
+}
+}  // namespace search
diff --git a/code/train/C++/0095071_audiostream.cpp b/code/train/C++/0095071_audiostream.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a809420e05266cbe98d74da425a2e7c316d00ca0
--- /dev/null
+++ b/code/train/C++/0095071_audiostream.cpp
@@ -0,0 +1,203 @@
+/* xoreos - A reimplementation of BioWare's Aurora engine
+ *
+ * xoreos is the legal property of its developers, whose names
+ * can be found in the AUTHORS file distributed with this source
+ * distribution.
+ *
+ * xoreos 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.
+ *
+ * xoreos 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 xoreos. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Largely based on the AudioStream implementation found in ScummVM.
+
+/** @file
+ *  Streaming audio.
+ */
+
+#include <queue>
+
+#include "src/common/error.h"
+#include "src/common/mutex.h"
+
+#include "src/sound/audiostream.h"
+
+namespace Sound {
+
+LoopingAudioStream::LoopingAudioStream(RewindableAudioStream *stream, size_t loops, bool disposeAfterUse)
+    : _parent(stream), _disposeAfterUse(disposeAfterUse), _loops(loops), _completeIterations(0) {
+}
+
+LoopingAudioStream::~LoopingAudioStream() {
+	if (_disposeAfterUse)
+		delete _parent;
+}
+
+size_t LoopingAudioStream::readBuffer(int16 *buffer, const size_t numSamples) {
+	if ((_loops && _completeIterations == _loops) || !numSamples)
+		return 0;
+
+	const size_t samplesRead = _parent->readBuffer(buffer, numSamples);
+	if (samplesRead == kSizeInvalid)
+		return kSizeInvalid;
+
+	if (_parent->endOfStream()) {
+		++_completeIterations;
+		if (_completeIterations == _loops)
+			return samplesRead;
+
+		const size_t remainingSamples = numSamples - samplesRead;
+
+		if (!_parent->rewind()) {
+			// TODO: Properly indicate error
+			_loops = _completeIterations = 1;
+			return samplesRead;
+		}
+
+		const size_t samplesReadNext = readBuffer(buffer + samplesRead, remainingSamples);
+		if (samplesReadNext == kSizeInvalid)
+			return kSizeInvalid;
+
+		return samplesRead + samplesReadNext;
+	}
+
+	return samplesRead;
+}
+
+bool LoopingAudioStream::endOfData() const {
+	return (_loops != 0 && (_completeIterations == _loops));
+}
+
+AudioStream *makeLoopingAudioStream(RewindableAudioStream *stream, size_t loops) {
+	if (loops != 1)
+		return new LoopingAudioStream(stream, loops);
+	else
+		return stream;
+}
+
+class QueuingAudioStreamImpl : public QueuingAudioStream {
+private:
+	/**
+	 * We queue a number of (pointers to) audio stream objects.
+	 * In addition, we need to remember for each stream whether
+	 * to dispose it after all data has been read from it.
+	 * Hence, we don't store pointers to stream objects directly,
+	 * but rather StreamHolder structs.
+	 */
+	struct StreamHolder {
+		AudioStream *_stream;
+		bool _disposeAfterUse;
+		StreamHolder(AudioStream *stream, bool disposeAfterUse)
+		    : _stream(stream),
+		      _disposeAfterUse(disposeAfterUse) {}
+	};
+
+	/**
+	 * The sampling rate of this audio stream.
+	 */
+	const int _rate;
+
+	/**
+	 * The number of channels in this audio stream.
+	 */
+	const int _channels;
+
+	/**
+	 * This flag is set by the finish() method only. See there for more details.
+	 */
+	bool _finished;
+
+	/**
+	 * A mutex to avoid access problems (causing e.g. corruption of
+	 * the linked list) in thread aware environments.
+	 */
+	Common::Mutex _mutex;
+
+	/**
+	 * The queue of audio streams.
+	 */
+	std::queue<StreamHolder> _queue;
+
+public:
+	QueuingAudioStreamImpl(int rate, int channels)
+	    : _rate(rate), _channels(channels), _finished(false) {}
+	~QueuingAudioStreamImpl();
+
+	// Implement the AudioStream API
+	virtual size_t readBuffer(int16 *buffer, const size_t numSamples);
+	virtual int getChannels() const { return _channels; }
+	virtual int getRate() const { return _rate; }
+	virtual bool endOfData() const {
+		//Common::StackLock lock(_mutex);
+		return _queue.empty();
+	}
+	virtual bool endOfStream() const { return _finished && _queue.empty(); }
+
+	// Implement the QueuingAudioStream API
+	virtual void queueAudioStream(AudioStream *stream, bool disposeAfterUse);
+	virtual void finish() { _finished = true; }
+
+	size_t numQueuedStreams() const {
+		//Common::StackLock lock(_mutex);
+		return _queue.size();
+	}
+};
+
+QueuingAudioStreamImpl::~QueuingAudioStreamImpl() {
+	while (!_queue.empty()) {
+		StreamHolder tmp = _queue.front();
+		_queue.pop();
+		if (tmp._disposeAfterUse)
+			delete tmp._stream;
+	}
+}
+
+void QueuingAudioStreamImpl::queueAudioStream(AudioStream *stream, bool disposeAfterUse) {
+	if (_finished)
+		throw Common::Exception("QueuingAudioStreamImpl::queueAudioStream(): Trying to queue another audio stream, but the QueuingAudioStream is finished.");
+
+	if ((stream->getRate() != getRate()) || (stream->getChannels() != getChannels()))
+		throw Common::Exception("QueuingAudioStreamImpl::queueAudioStream(): stream has mismatched parameters");
+
+	Common::StackLock lock(_mutex);
+	_queue.push(StreamHolder(stream, disposeAfterUse));
+}
+
+size_t QueuingAudioStreamImpl::readBuffer(int16 *buffer, const size_t numSamples) {
+	Common::StackLock lock(_mutex);
+	size_t samplesDecoded = 0;
+
+	while (samplesDecoded < numSamples && !_queue.empty()) {
+		AudioStream *stream = _queue.front()._stream;
+
+		const size_t n = stream->readBuffer(buffer + samplesDecoded, numSamples - samplesDecoded);
+		if (n == kSizeInvalid)
+			return kSizeInvalid;
+
+		samplesDecoded += n;
+
+		if (stream->endOfData()) {
+			StreamHolder tmp = _queue.front();
+			_queue.pop();
+			if (tmp._disposeAfterUse)
+				delete stream;
+		}
+	}
+
+	return samplesDecoded;
+}
+
+QueuingAudioStream *makeQueuingAudioStream(int rate, int channels) {
+	return new QueuingAudioStreamImpl(rate, channels);
+}
+
+} // End of namespace Sound
diff --git a/code/train/C++/0095854_3974.cc b/code/train/C++/0095854_3974.cc
new file mode 100644
index 0000000000000000000000000000000000000000..73f284e1a634fd34308414144ab743ba3bf73923
--- /dev/null
+++ b/code/train/C++/0095854_3974.cc
@@ -0,0 +1,53 @@
+#include <iostream>
+#include <cstring>
+
+using namespace std;
+
+int len;
+char in[1000010], s[2000010];
+int nRad[2000010];
+
+int manacher() {
+    memset(nRad, 0, sizeof(nRad));
+    int maxRad, j, maxx;
+    maxRad = j = maxx = 0;
+
+    for (int i = 1; i != len; ++i) {
+        if (i < maxx)
+            nRad[i] = min(nRad[2*j-i], maxx-i);
+        else
+            nRad[i] = 1;
+
+        while (s[i - nRad[i]] == s[i + nRad[i]])
+            ++nRad[i];
+
+        if (maxRad < nRad[i])
+            maxRad = nRad[i];
+
+        if (i + nRad[i] > maxx) {
+            j = i;
+            maxx = i + nRad[i];
+        }
+    }
+
+    return maxRad - 1;
+}
+
+int main() {
+    int cases = 1;
+    while (cin >> in) {
+        if (strncmp(in, "END", 3) == 0)
+            break;
+        len = strlen(in);
+        memset(s, '#', sizeof(s));
+        s[0] = '$';
+        for (int i = 0; i != len; ++i)
+            s[(i+1)*2] = in[i];
+        len = (len + 1) * 2;
+
+        int ans = manacher();
+        cout << "Case " << cases++ << ": " << ans << endl;
+    }
+    return 0;
+}
+
diff --git a/code/train/C++/0095993_LuckyTicketSubstring.cpp b/code/train/C++/0095993_LuckyTicketSubstring.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1dda60b4e851d9024cc063a9e06d2b4355ccdda8
--- /dev/null
+++ b/code/train/C++/0095993_LuckyTicketSubstring.cpp
@@ -0,0 +1,169 @@
+#include <string>
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <iterator>
+#include <tuple>
+#include <regex>
+#include <array>
+#include <valarray>
+#define all(v)begin(v),end(v)
+#define dump(v)copy(all(v),ostream_iterator<decltype(*v.begin())>(cout,"\n"))
+#define rg(i,a,b)for(int i=a,i##e=b;i<i##e;++i)
+#define fr(i,n)for(int i=0,i##e=n;i<i##e;++i)
+#define rf(i,n)for(int i=n-1;i>=0;--i)
+#define ei(a,m)for(auto&a:m)if(int a##i=&a-&*begin(m)+1)if(--a##i,1)
+#define sz(v)int(v.size())
+#define sr(v)sort(all(v))
+#define rs(v)sort(all(v),greater<int>())
+#define rev(v)reverse(all(v))
+#define eb emplace_back
+#define stst stringstream
+#define big numeric_limits<int>::max()
+#define g(t,i)get<i>(t)
+#define cb(v,w)copy(all(v),back_inserter(w))
+#define uni(v)sort(all(v));v.erase(unique(all(v)),end(v))
+#define vt(...)vector<tuple<__VA_ARGS__>>
+#define smx(a,b)a=max(a,b)
+#define smn(a,b)a=min(a,b)
+#define words(w,q)vector<string>w;[&w](string&&s){stringstream u(s);string r;while(u>>r)w.eb(r);}(q);
+#define digits(d,n,s)vector<int>d;[&d](int m){while(m)d.eb(m%s),m/=s;}(n);
+typedef long long ll;
+using namespace std;
+
+struct LuckyTicketSubstring {
+	int maxLength(string s) {
+		const int q = sz(s);
+		int mx = 0;
+		for (int i = 0; i < q; ++i) for (int j = i + 2; j <= q; ++j) if ((j - i) % 2 == 0) {
+			int m = (j + i) / 2;
+			int t = 0;
+			for (int k = i; k < m; ++k) t += s[k] - '0';
+			for (int k = m; k < j; ++k) t -= s[k] - '0';
+			cout << s.substr(i, j - i) << ' ' << t << endl;
+			if (t == 0) mx = max(mx, j - i);
+		}
+		return mx;
+	}
+};
+
+// BEGIN KAWIGIEDIT TESTING
+// Generated by KawigiEdit-pf 2.3.0
+#include <iostream>
+#include <string>
+#include <vector>
+#include <ctime>
+#include <cmath>
+using namespace std;
+bool KawigiEdit_RunTest(int testNum, string p0, bool hasAnswer, int p1) {
+	cout << "Test " << testNum << ": [" << "\"" << p0 << "\"";
+	cout << "]" << endl;
+	LuckyTicketSubstring *obj;
+	int answer;
+	obj = new LuckyTicketSubstring();
+	clock_t startTime = clock();
+	answer = obj->maxLength(p0);
+	clock_t endTime = clock();
+	delete obj;
+	bool res;
+	res = true;
+	cout << "Time: " << double(endTime - startTime) / CLOCKS_PER_SEC << " seconds" << endl;
+	if (hasAnswer) {
+		cout << "Desired answer:" << endl;
+		cout << "\t" << p1 << endl;
+	}
+	cout << "Your answer:" << endl;
+	cout << "\t" << answer << endl;
+	if (hasAnswer) {
+		res = answer == p1;
+	}
+	if (!res) {
+		cout << "DOESN'T MATCH!!!!" << endl;
+	} else if (double(endTime - startTime) / CLOCKS_PER_SEC >= 2) {
+		cout << "FAIL the timeout" << endl;
+		res = false;
+	} else if (hasAnswer) {
+		cout << "Match :-)" << endl;
+	} else {
+		cout << "OK, but is it right?" << endl;
+	}
+	cout << "" << endl;
+	return res;
+}
+int main() {
+	bool all_right;
+	bool disabled;
+	bool tests_disabled;
+	all_right = true;
+	tests_disabled = false;
+	
+	string p0;
+	int p1;
+	
+	// ----- test 0 -----
+	disabled = false;
+	p0 = "123231";
+	p1 = 6;
+	all_right = (disabled || KawigiEdit_RunTest(0, p0, true, p1) ) && all_right;
+	tests_disabled = tests_disabled || disabled;
+	// ------------------
+	
+	// ----- test 1 -----
+	disabled = false;
+	p0 = "74233285";
+	p1 = 4;
+	all_right = (disabled || KawigiEdit_RunTest(1, p0, true, p1) ) && all_right;
+	tests_disabled = tests_disabled || disabled;
+	// ------------------
+	
+	// ----- test 2 -----
+	disabled = false;
+	p0 = "986561517416921217551395112859219257312";
+	p1 = 36;
+	all_right = (disabled || KawigiEdit_RunTest(2, p0, true, p1) ) && all_right;
+	tests_disabled = tests_disabled || disabled;
+	// ------------------
+	
+	// ----- test 3 -----
+	disabled = false;
+	p0 = "1";
+	p1 = 0;
+	all_right = (disabled || KawigiEdit_RunTest(3, p0, true, p1) ) && all_right;
+	tests_disabled = tests_disabled || disabled;
+	// ------------------
+	
+	// ----- test 4 -----
+	disabled = false;
+	p0 = "112";
+	p1 = 2;
+	all_right = (disabled || KawigiEdit_RunTest(4, p0, true, p1) ) && all_right;
+	tests_disabled = tests_disabled || disabled;
+	// ------------------
+	
+	if (all_right) {
+		if (tests_disabled) {
+			cout << "You're a stud (but some test cases were disabled)!" << endl;
+		} else {
+			cout << "You're a stud (at least on given cases)!" << endl;
+		}
+	} else {
+		cout << "Some of the test cases had errors." << endl;
+	}
+	return 0;
+}
+// END KAWIGIEDIT TESTING
diff --git a/code/train/C++/0096007_MCSchedule.cpp b/code/train/C++/0096007_MCSchedule.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..929bd7f6046cc3e19dc45a8df25c08281f9c5e8e
--- /dev/null
+++ b/code/train/C++/0096007_MCSchedule.cpp
@@ -0,0 +1,152 @@
+//===- MCSchedule.cpp - Scheduling ------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the default scheduling model.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/MC/MCSchedule.h"
+#include "llvm/MC/MCInst.h"
+#include "llvm/MC/MCInstrDesc.h"
+#include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include <type_traits>
+
+using namespace llvm;
+
+static_assert(std::is_pod<MCSchedModel>::value,
+              "We shouldn't have a static constructor here");
+const MCSchedModel MCSchedModel::Default = {DefaultIssueWidth,
+                                            DefaultMicroOpBufferSize,
+                                            DefaultLoopMicroOpBufferSize,
+                                            DefaultLoadLatency,
+                                            DefaultHighLatency,
+                                            DefaultMispredictPenalty,
+                                            false,
+                                            true,
+                                            0,
+                                            nullptr,
+                                            nullptr,
+                                            0,
+                                            0,
+                                            nullptr,
+                                            nullptr};
+
+int MCSchedModel::computeInstrLatency(const MCSubtargetInfo &STI,
+                                      const MCSchedClassDesc &SCDesc) {
+  int Latency = 0;
+  for (unsigned DefIdx = 0, DefEnd = SCDesc.NumWriteLatencyEntries;
+       DefIdx != DefEnd; ++DefIdx) {
+    // Lookup the definition's write latency in SubtargetInfo.
+    const MCWriteLatencyEntry *WLEntry =
+        STI.getWriteLatencyEntry(&SCDesc, DefIdx);
+    // Early exit if we found an invalid latency.
+    if (WLEntry->Cycles < 0)
+      return WLEntry->Cycles;
+    Latency = std::max(Latency, static_cast<int>(WLEntry->Cycles));
+  }
+  return Latency;
+}
+
+int MCSchedModel::computeInstrLatency(const MCSubtargetInfo &STI,
+                                      unsigned SchedClass) const {
+  const MCSchedClassDesc &SCDesc = *getSchedClassDesc(SchedClass);
+  if (!SCDesc.isValid())
+    return 0;
+  if (!SCDesc.isVariant())
+    return MCSchedModel::computeInstrLatency(STI, SCDesc);
+
+  llvm_unreachable("unsupported variant scheduling class");
+}
+
+int MCSchedModel::computeInstrLatency(const MCSubtargetInfo &STI,
+                                      const MCInstrInfo &MCII,
+                                      const MCInst &Inst) const {
+  unsigned SchedClass = MCII.get(Inst.getOpcode()).getSchedClass();
+  const MCSchedClassDesc *SCDesc = getSchedClassDesc(SchedClass);
+  if (!SCDesc->isValid())
+    return 0;
+
+  unsigned CPUID = getProcessorID();
+  while (SCDesc->isVariant()) {
+    SchedClass = STI.resolveVariantSchedClass(SchedClass, &Inst, CPUID);
+    SCDesc = getSchedClassDesc(SchedClass);
+  }
+
+  if (SchedClass)
+    return MCSchedModel::computeInstrLatency(STI, *SCDesc);
+
+  llvm_unreachable("unsupported variant scheduling class");
+}
+
+double
+MCSchedModel::getReciprocalThroughput(const MCSubtargetInfo &STI,
+                                      const MCSchedClassDesc &SCDesc) {
+  Optional<double> Throughput;
+  const MCSchedModel &SM = STI.getSchedModel();
+  const MCWriteProcResEntry *I = STI.getWriteProcResBegin(&SCDesc);
+  const MCWriteProcResEntry *E = STI.getWriteProcResEnd(&SCDesc);
+  for (; I != E; ++I) {
+    if (!I->Cycles)
+      continue;
+    unsigned NumUnits = SM.getProcResource(I->ProcResourceIdx)->NumUnits;
+    double Temp = NumUnits * 1.0 / I->Cycles;
+    Throughput = Throughput ? std::min(Throughput.getValue(), Temp) : Temp;
+  }
+  if (Throughput.hasValue())
+    return 1.0 / Throughput.getValue();
+
+  // If no throughput value was calculated, assume that we can execute at the
+  // maximum issue width scaled by number of micro-ops for the schedule class.
+  return ((double)SCDesc.NumMicroOps) / SM.IssueWidth;
+}
+
+double
+MCSchedModel::getReciprocalThroughput(const MCSubtargetInfo &STI,
+                                      const MCInstrInfo &MCII,
+                                      const MCInst &Inst) const {
+  unsigned SchedClass = MCII.get(Inst.getOpcode()).getSchedClass();
+  const MCSchedClassDesc *SCDesc = getSchedClassDesc(SchedClass);
+
+  // If there's no valid class, assume that the instruction executes/completes
+  // at the maximum issue width.
+  if (!SCDesc->isValid())
+    return 1.0 / IssueWidth;
+
+  unsigned CPUID = getProcessorID();
+  while (SCDesc->isVariant()) {
+    SchedClass = STI.resolveVariantSchedClass(SchedClass, &Inst, CPUID);
+    SCDesc = getSchedClassDesc(SchedClass);
+  }
+
+  if (SchedClass)
+    return MCSchedModel::getReciprocalThroughput(STI, *SCDesc);
+
+  llvm_unreachable("unsupported variant scheduling class");
+}
+
+double
+MCSchedModel::getReciprocalThroughput(unsigned SchedClass,
+                                      const InstrItineraryData &IID) {
+  Optional<double> Throughput;
+  const InstrStage *I = IID.beginStage(SchedClass);
+  const InstrStage *E = IID.endStage(SchedClass);
+  for (; I != E; ++I) {
+    if (!I->getCycles())
+      continue;
+    double Temp = countPopulation(I->getUnits()) * 1.0 / I->getCycles();
+    Throughput = Throughput ? std::min(Throughput.getValue(), Temp) : Temp;
+  }
+  if (Throughput.hasValue())
+    return 1.0 / Throughput.getValue();
+
+  // If there are no execution resources specified for this class, then assume
+  // that it can execute at the maximum default issue width.
+  return 1.0 / DefaultIssueWidth;
+}
diff --git a/code/train/C++/0096334_MXADataRecord.cpp b/code/train/C++/0096334_MXADataRecord.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3479491d73385212b7bc3d2d9802904cb187fb49
--- /dev/null
+++ b/code/train/C++/0096334_MXADataRecord.cpp
@@ -0,0 +1,319 @@
+#include <MXA/Core/MXADataRecord.h>
+#include <MXA/Common/LogTime.h>
+
+// Set the initial value of the _uniqueGUIDValue
+int32_t MXADataRecord::_uniqueGUIDValue(0);
+
+// -----------------------------------------------------------------------------
+//  Constructor
+// -----------------------------------------------------------------------------
+MXADataRecord::MXADataRecord() :
+_luid(0),
+_recordName(""),
+_altName("")
+{
+  
+}
+
+// -----------------------------------------------------------------------------
+//  Static New Method that is used to construct a new DataRecord Node
+// -----------------------------------------------------------------------------
+MXADataRecord::Pointer MXADataRecord::New(int luid, std::string name, std::string altName)
+{
+  MXADataRecord* rec = new MXADataRecord();
+  MXADataRecord::Pointer record(rec);
+  record->_setWeakPtr(boost::weak_ptr<IDataRecord>(record)); // Set the Weak Pointer
+  rec->setLuid(luid);
+  rec->setGuid( MXADataRecord::nextGUIDValue() );
+  rec->setRecordName(name);
+  rec->setAltName(altName);
+  return record;
+}
+
+// -----------------------------------------------------------------------------
+//  Destructor
+// -----------------------------------------------------------------------------
+MXADataRecord::~MXADataRecord()
+{
+  //std::cout << logTime() << "~MXADataRecord {" << this->_uniqueId << "}" << std::endl;
+}
+
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+void MXADataRecord::generateLUT(IDataRecord::LookupTable &lut, IDataRecord::Container &nodes)
+{
+  for ( IDataRecord::Container::iterator iter = nodes.begin(); iter < nodes.end(); ++iter )
+  {
+    //  rec = dynamic_cast<MXADataRecord*> ( (*(iter)).get() ); //get the Raw pointer to the object
+    IDataRecord::Pointer node =  ( *(iter) );
+    lut[node->getUniqueId()] = node;
+    if (node->hasChildren() ) {
+      // std::cout << "Creating Group for " << rec->getRecordName() << std::endl;
+      IDataRecord::Container children = node->getChildren();
+      MXADataRecord::generateLUT( lut, children );
+    } 
+  }
+}
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+
+void MXADataRecord::printDataRecord(std::ostream& os, int32_t indent)
+{
+  os << StringUtils::indent(indent) << "*-Record Name: " << this->_recordName << std::endl;
+  os << StringUtils::indent(indent) << " |-Alternate Name: " << this->_altName << std::endl;
+  os << StringUtils::indent(indent) << " |-Display Name: " << this->_nodeName << std::endl;
+  os << StringUtils::indent(indent) << " |-LUID: " << this->_luid << std::endl;
+  os << StringUtils::indent(indent) << " |-GUID: " << this->getGuid() << std::endl;
+#if 0
+  for (MXAAttributes::iterator iter = _attributes.begin(); iter != _attributes.end(); ++iter )
+  {
+    os << StringUtils::indent(indent) << " |- Attribute: " << std::endl;
+  }
+#endif
+  if (this->hasChildren() ) { indent++;}
+  for (IDataRecord::Container::iterator iter = _children.begin(); iter != _children.end(); ++iter)
+  {
+    (*(iter))->printDataRecord(os, indent);
+  }
+}
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+void MXADataRecord::printDataRecordTree(int32_t depth)
+{
+  if ( this->hasChildren() ) {
+    IDataRecord::Container::const_iterator iter;
+    for (iter=this->_children.begin(); iter!=this->_children.end(); iter++) {
+      (*iter)->printDataRecordTree(depth+1);
+    }
+  }
+}
+
+
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+std::string MXADataRecord::generatePath()
+{
+  std::string path;
+  path =  StringUtils::numToString(this->_luid);
+  MXADataRecord* parent = dynamic_cast<MXADataRecord*>( this->_parent.lock().get() );
+  while( NULL != parent )
+  {
+    path =  StringUtils::numToString(parent->getLuid() ) + "/" + path;
+    parent = dynamic_cast<MXADataRecord*>(parent->getParent().lock().get() );
+  }
+  return path;
+}
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+std::string MXADataRecord::generateParentPath()
+{
+  std::string path;
+
+  MXADataRecord* parent = dynamic_cast<MXADataRecord*>( this->_parent.lock().get() );
+  while( NULL != parent )
+  {
+    path =  StringUtils::numToString(parent->getLuid() ) + "/" + path;
+    parent = dynamic_cast<MXADataRecord*>(parent->getParent().lock().get() );
+  }
+  return path;
+}
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+int32_t MXADataRecord::writeRecord(IDataRecordWriter* writer)
+{
+  return writer->writeDataRecord(this);
+}
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+bool MXADataRecord::isValid(std::string &message)
+{
+  bool valid = true;
+  if (this->_recordName.empty() || this->_altName.empty())
+  {
+    valid = false;
+    message.append("Either the Data Record Name or the Alt Name is empty. Both are required to have a value.\n");
+  }
+  return valid;
+}
+
+
+// -----------------------------------------------------------------------------
+//  This is used to set a weak ptr to itself. The weak ptr is then used when 
+//  another node needs to set this object as its parent. If we did NOT use a weak
+//  ptr and used a shared ptr then we would end up with a cyclic reference and the
+//  object would never get deleted because the ref count would never hit zero
+// -----------------------------------------------------------------------------
+void MXADataRecord::_setWeakPtr(IDataRecord::WeakPointer weakPtr)
+{
+  this->_selfPtr = weakPtr; 
+}
+
+// -----------------------------------------------------------------------------
+//  Used for Unique Ids
+// -----------------------------------------------------------------------------
+void MXADataRecord::resetGUIDValue()
+{
+  _uniqueGUIDValue = 0;
+}
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+int32_t MXADataRecord::nextGUIDValue()
+{
+  return MXADataRecord::_uniqueGUIDValue++;
+}
+
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+void MXADataRecord::setParent(IDataRecord::WeakPointer parent)
+{
+  this->_parent = parent;
+}
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+IDataRecord::WeakPointer MXADataRecord::getParent()
+{
+  return this->_parent;
+}
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+int32_t MXADataRecord::getNumChildren() const
+{
+  return static_cast<int32_t>(this->_children.size());
+}
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+bool MXADataRecord::hasChildren() const
+{
+  return (this->_children.size() != 0);
+}
+
+// -----------------------------------------------------------------------------
+//  Adds a child ONLY if it is NOT already inserted into the children vector
+// -----------------------------------------------------------------------------
+void MXADataRecord::addChild(IDataRecord::Pointer child)
+{
+  child->setParent(this->_selfPtr);
+  bool alreadyInserted = false;
+  for (IDataRecord::Container::iterator iter = this->_children.begin(); iter != this->_children.end(); ++iter)
+  {
+    if ( (*(iter)).get() == child.get() ) //Compare the raw pointers
+    {
+      alreadyInserted = true;
+      break;
+    }
+  }
+  if (alreadyInserted == false) {
+    this->_children.push_back(child);
+  }
+}
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+void MXADataRecord::removeChild(int index)
+{
+  IDataRecord::Container::iterator iter = this->_children.begin() + index;
+  this->_children.erase(iter);
+}
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+void MXADataRecord::removeChild(IDataRecord* child)
+{
+  for (IDataRecord::Container::iterator iter = this->_children.begin(); iter != this->_children.end(); ++iter)
+  {
+    if ( (*(iter)).get() == child )
+    {
+      this->_children.erase(iter);
+      break;
+    }
+  }
+}
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+void MXADataRecord::removeAllChildren()
+{
+  this->_children.clear();
+}
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+int32_t MXADataRecord::indexOfChild(IDataRecord* child)
+{
+  int32_t retVal = -1;
+  int32_t index = 0;
+  for (IDataRecord::Container::iterator iter = this->_children.begin(); iter != this->_children.end(); ++iter)
+  {
+    if ( (*(iter)).get() == child )
+    {
+      return index;
+    }
+    index++;
+  }
+  return retVal;
+}
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+IDataRecord::Pointer MXADataRecord::getChildAt(int32_t index)
+{
+  if (static_cast<uint32_t>(index) < this->_children.size())
+    return this->_children[index];
+    else {
+      //std::cout << "MXADataRecord(GUID): " << this->getUniqueId() << " Num Children: " << this->_children.size() << "  Index:" << index << std::endl;
+    }
+   MXADataRecord::Pointer ptr;
+   return ptr;
+}
+
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+IDataRecord::Container& MXADataRecord::getChildren()
+{
+  return this->_children;
+}
+
+#if 0
+// -----------------------------------------------------------------------------
+//  
+// -----------------------------------------------------------------------------
+void MXADataRecord::removeAttribute(std::string label)
+{
+  _nodeAttributes.erase(label);
+}
+
+#endif
+
+
+
+
diff --git a/code/train/C++/0096471_arrays-maxsum.cpp b/code/train/C++/0096471_arrays-maxsum.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6940380e4777ff4bd9d11fcc3b19dbde097d5807
--- /dev/null
+++ b/code/train/C++/0096471_arrays-maxsum.cpp
@@ -0,0 +1,58 @@
+// http://www.interviewbit.com/courses/programming/topics/arrays/problems/maxsum/
+
+// Kadane's Algorithm: https://en.wikipedia.org/wiki/Maximum_subarray_problem
+
+// Q: how big are expected values? Ok to use int?
+
+#include <iostream>
+#include <limits>
+#include <vector>
+
+using std::cin;
+using std::cout;
+
+int maxSubArray(const std::vector<int> &A) {
+
+  if (A.size() <= 0) {
+    return 0;
+  }
+  int max_ending_here = 0;
+  int max_so_far = 0;
+  int max_value = std::numeric_limits<int>::min();  //store max value in case all elements in array are negative
+  
+  for (int i = 0; i < A.size(); ++i) {
+    max_ending_here = max_ending_here + A[i];
+
+    if (max_ending_here < 0) {
+      max_ending_here = 0;
+    } else if (max_so_far < max_ending_here) {
+      max_so_far = max_ending_here;
+    }
+    
+    if (A[i] > max_value) {
+      max_value = A[i];
+    }
+  }
+  if (max_value < 0) {  //all values in array were negative - return the least negative value  
+    return max_value;  
+  } else {
+    return max_so_far;
+  }
+}
+
+
+int main() {
+  std::vector<int> a;
+  int input;
+
+  while (1) {
+    cout << "Enter values 1 at a time into vector. Enter 0 when you are finished.\n";
+    cin >> input;
+
+    while (input != 0) {
+      a.push_back(input);
+      cin >> input;
+    }
+    cout << "\nMax subarray sum: " << maxSubArray(a) << "\n";
+  }
+}
\ No newline at end of file
diff --git a/code/train/C++/0096693_search-a-range-sorted-array.cc b/code/train/C++/0096693_search-a-range-sorted-array.cc
new file mode 100644
index 0000000000000000000000000000000000000000..63b9a276c6c468284bf142dd09ed582bdc761608
--- /dev/null
+++ b/code/train/C++/0096693_search-a-range-sorted-array.cc
@@ -0,0 +1,76 @@
+// Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
+
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+#include <random>
+#include <string>
+#include <utility>
+#include <vector>
+
+using std::cout;
+using std::default_random_engine;
+using std::endl;
+using std::pair;
+using std::random_device;
+using std::stoul;
+using std::uniform_int_distribution;
+using std::vector;
+
+// @include
+pair<int, int> search_range(const vector<int>& A, int target) {
+  auto result = equal_range(A.cbegin(), A.cend(), target);
+  if (*result.first != target) {
+    return {-1, -1};
+  }
+  return {distance(A.begin(), result.first),
+          distance(A.begin(), result.second - 1)};
+}
+// @exclude
+
+pair<int, int> check_ans(const vector<int>& A, int target) {
+  size_t a = 0;
+  while (a < A.size() && A[a] < target) {
+    ++a;
+  }
+  if (A[a] != target) {
+    return {-1, -1};
+  }
+  int b = A.size() - 1;
+  while (b >= 0 && A[b] > target) {
+    --b;
+  }
+  return {a, b};
+}
+
+int main(int argc, char** argv) {
+  default_random_engine gen((random_device())());
+  for (int times = 0; times < 1000; ++times) {
+    size_t n;
+    if (argc == 2) {
+      n = stoul(argv[1]);
+    } else {
+      uniform_int_distribution<size_t> n_dis(0, 100000);
+      n = n_dis(gen);
+    }
+    uniform_int_distribution<int> A_dis(0, static_cast<int>(n));
+    vector<int> A;
+    generate_n(back_inserter(A), n, [&] { return A_dis(gen); });
+    sort(A.begin(), A.end());
+    /*
+    for (int a : A) {
+      cout << a << " ";
+    }
+    cout << endl;
+    */
+    int target = A_dis(gen);
+    // cout << "target = " << target << endl;
+    auto result = search_range(A, target), ans = check_ans(A, target);
+    /*
+    cout << result.first << ", " << result.second << endl;
+    cout << ans.first << ", " << ans.second << endl;
+    */
+    assert(result == ans);
+  }
+  return 0;
+}
diff --git a/code/train/C++/0096748_chordsdescriptors.cpp b/code/train/C++/0096748_chordsdescriptors.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..69bd5b2fdcec4c69ea543b446c9b1d2c4374458d
--- /dev/null
+++ b/code/train/C++/0096748_chordsdescriptors.cpp
@@ -0,0 +1,244 @@
+/*
+ * Copyright (C) 2006-2021  Music Technology Group - Universitat Pompeu Fabra
+ *
+ * This file is part of Essentia
+ *
+ * Essentia 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 (FSF), 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 Affero GNU General Public License
+ * version 3 along with this program.  If not, see http://www.gnu.org/licenses/
+ */
+
+#include "chordsdescriptors.h"
+#include "stringutil.h"
+
+using namespace std;
+
+namespace essentia {
+namespace standard {
+
+const char* ChordsDescriptors::name = "ChordsDescriptors";
+const char* ChordsDescriptors::category = "Tonal";
+const char* ChordsDescriptors::description = DOC("Given a chord progression this algorithm describes it by means of key, scale, histogram, and rate of change.\n"
+"Note:\n"
+"  - chordsHistogram indexes follow the circle of fifths order, while being shifted to the input key and scale\n"
+"  - key and scale are taken from the most frequent chord. In the case where multiple chords are equally frequent, the chord is hierarchically chosen from the circle of fifths.\n"
+"  - chords should follow this name convention `<A-G>[<#/b><m>]` (i.e. C, C# or C#m are valid chords). Chord names not fitting this convention will throw an exception.\n"
+"\n"
+"Input chords vector may not be empty, otherwise an exception is thrown.\n"
+"\n"
+"References:\n"
+"  [1] Chord progression - Wikipedia, the free encyclopedia,\n"
+"  http://en.wikipedia.org/wiki/Chord_progression\n\n"
+"  [2] Circle of fifths - Wikipedia, the free encyclopedia,\n"
+"  http://en.wikipedia.org/wiki/Circle_of_fifths");
+
+const char* ChordsDescriptors::circleOfFifth[] = { "C", "Em", "G", "Bm", "D", "F#m", "A", "C#m", "E", "Abm", "B", "Ebm", "F#", "Bbm", "C#", "Fm", "Ab", "Cm", "Eb", "Gm", "Bb", "Dm", "F", "Am"};
+const char* ChordsDescriptors::circleOfFifthAlternativeNames[] = { "C", "Em", "G", "Bm", "D", "Gbm", "A", "Dbm", "E", "G#m", "B", "D#m", "Gb", "A#m", "Db", "Fm", "G#", "Cm", "D#", "Gm", "A#", "Dm", "F", "Am"};
+
+
+
+int ChordsDescriptors::chordIndex(const string& chord) {
+  for (int i=0; i<int(ARRAY_SIZE(circleOfFifth)); ++i) {
+    if (chord == circleOfFifth[i] || chord ==  circleOfFifthAlternativeNames[i]) {
+      return i;
+    }
+  }
+  throw EssentiaException("ChordsDescriptors: Invalid chord: ", chord);
+}
+
+
+map<int, Real> ChordsDescriptors::chordsHistogram(const vector<string>& chords) {
+  map<int, Real> histogram;
+
+  // Initialize
+  for (int i=0; i<int(ARRAY_SIZE(circleOfFifth)); ++i) {
+    histogram[i] = 0.0;
+  }
+
+  // Increment
+  for (int i=0; i<int(chords.size()); ++i) {
+    histogram[chordIndex(chords[i])] += 1.0;
+  }
+
+  // Normalize
+  for (int i=0; i<int(histogram.size()); ++i) {
+    histogram[i] *= 100.0 / (Real)chords.size();
+  }
+
+  return histogram;
+}
+
+
+// offset the list of indices making key as the root index (or 0-index)
+map<int, Real> ChordsDescriptors::chordsHistogramNorm(map<int, Real>& histogram, const string& key) {
+  int keyIndex = chordIndex(key);
+  map<int, Real> histogramNorm = histogram;
+
+  for (int i=0; i<int(histogramNorm.size()); ++i) {
+    int chordIndex = i - keyIndex;
+    if (chordIndex < 0) {
+      chordIndex += ARRAY_SIZE(circleOfFifth);
+    }
+    histogramNorm[chordIndex] = histogram[i];
+  }
+
+  return histogramNorm;
+}
+
+
+void ChordsDescriptors::compute() {
+  const vector<string>& chords = _chords.get();
+
+  if (chords.empty()) {
+    throw EssentiaException("ChordsDescriptors: Chords input empty");
+  }
+
+  string key = _key.get();
+  
+  if (key.empty()) {
+    throw EssentiaException("ChordsDescriptors: Key input empty");
+  }
+
+  key[0] = toUpper(string(1, key[0]))[0];
+  
+  string scale = toLower(_scale.get());
+
+  if (scale.empty()) {
+    throw EssentiaException("ChordsDescriptors: Scale input empty");
+  }
+
+  if (_scale.get() == "minor") {
+    key += "m";
+  }
+
+    // Chords Histogram
+  map<int, Real> chordsHist = chordsHistogram(chords);
+  map<int, Real> chordsHistNorm = chordsHistogramNorm(chordsHist, key);
+
+  vector<Real>& chordsHistNormVect = _chordsHistogram.get();
+  chordsHistNormVect.resize(0); // erase anything that was in there
+  for (int i=0; i<int(ARRAY_SIZE(circleOfFifth)); ++i) {
+    chordsHistNormVect.push_back(chordsHistNorm[i]);
+  }
+
+  // Chords Number Rate
+  Real& chordNumberRate = _chordsNumberRate.get();
+  chordNumberRate = 0.0;
+  for (int i=0; i<int(chordsHistNormVect.size()); ++i) {
+    if (chordsHistNormVect[i] > 1.0) {
+      chordNumberRate += 1.0;
+    }
+  }
+  chordNumberRate /= (Real)chords.size();
+
+  // Chords Changes Rate
+  Real& chordChangesRate = _chordsChangesRate.get();
+  chordChangesRate = 0.0;
+  for (int i=1; i<int(chords.size()); ++i) {
+    if (chords[i] != chords[i-1]) {
+      chordChangesRate += 1.0;
+    }
+  }
+  chordChangesRate /= (Real)chords.size();
+
+  // Chords Key and Scale = most frequent chord
+  string& chordsKey = _chordsKey.get();
+  string& chordsScale = _chordsScale.get();
+  chordsKey = "A";
+  Real maxValue = 0.0;
+
+  for (int i=0; i<int(ARRAY_SIZE(circleOfFifth)); ++i) {
+    if (chordsHist[i] > maxValue) {
+      maxValue = chordsHist[i];
+      chordsKey = circleOfFifth[i];
+    }
+  }
+
+  bool major = true;
+  string::size_type position = chordsKey.find("m");
+
+  if ((position == 1) || (position == 2)) {
+    major = false;
+  }
+
+  if (major) {
+    chordsKey = chordsKey;
+    chordsScale = "major";
+  }
+  else {
+    chordsKey = chordsKey.substr(0, position);
+    chordsScale = "minor";
+  }
+}
+
+} // namespace standard
+} // namespace essentia
+
+
+
+namespace essentia {
+namespace streaming {
+
+const char* ChordsDescriptors::name = standard::ChordsDescriptors::name;
+const char* ChordsDescriptors::description = standard::ChordsDescriptors::description;
+
+
+AlgorithmStatus ChordsDescriptors::process() {
+  // this could be implemented as a composite, but it is kept like this for
+  // historical and demonstrations reasons
+  while (_chords.acquire(1)) {
+    _accu.push_back(*(std::string*)_chords.getFirstToken());
+    _chords.release(1);
+  }
+
+  if (!shouldStop()) return PASS;
+
+  // make sure we have one value for key and scale
+  if (!_key.acquire(1) || !_scale.acquire(1)) {
+    return NO_INPUT;
+  }
+
+  standard::Algorithm* algo = _chordsAlgo;
+  string key = *(string*)_key.getFirstToken();
+  string scale = *(string*)_scale.getFirstToken();
+  vector<Real> chordsHist;
+  Real cnr, ccr;
+  string ckey, cscale;
+
+  algo->input("chords").set(_accu);
+  algo->input("key").set(key);
+  algo->input("scale").set(scale);
+  algo->output("chordsHistogram").set(chordsHist);
+  algo->output("chordsNumberRate").set(cnr);
+  algo->output("chordsChangesRate").set(ccr);
+  algo->output("chordsKey").set(ckey);
+  algo->output("chordsScale").set(cscale);
+  algo->compute();
+
+  _chordsHistogram.push(chordsHist);
+  _chordsNumberRate.push(cnr);
+  _chordsChangesRate.push(ccr);
+  _chordsKey.push(ckey);
+  _chordsScale.push(cscale);
+
+  return FINISHED;
+}
+
+void ChordsDescriptors::reset() {
+  Algorithm::reset();
+  _accu.clear();
+  if (_chordsAlgo) _chordsAlgo->reset();
+}
+
+
+} // namespace streaming
+} // namespace essentia
diff --git a/code/train/C++/0096974_reverseWordsInAString.II.cpp b/code/train/C++/0096974_reverseWordsInAString.II.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bee4156a17f8576d0bb8a573ab6098d82f410c2c
--- /dev/null
+++ b/code/train/C++/0096974_reverseWordsInAString.II.cpp
@@ -0,0 +1,64 @@
+// Source : https://oj.leetcode.com/problems/reverse-words-in-a-string-ii/
+// Author : Hao Chen
+// Date   : 2015-02-09
+
+/********************************************************************************** 
+ * 
+ * Given an input string, reverse the string word by word. A word is defined as a sequence of non-space characters. 
+ * 
+ * The input string does not contain leading or trailing spaces and the words are always separated by a single space. 
+ * 
+ * For example,
+ *  Given s = "the sky is blue",
+ *  return "blue is sky the". 
+ * 
+ * Could you do it in-place without allocating extra space? 
+ * 
+ * 
+ **********************************************************************************/
+
+#include <ctype.h>
+#include <iostream>
+#include <string>
+using namespace std;
+
+
+void swap(char &a, char &b) {
+    char temp = a;
+    a = b;
+    b = temp;
+}
+void reverse(string &s, int begin, int end) {
+    while(begin < end) {
+        swap(s[begin++], s[end--]);
+    }
+}
+void reverseWords(string &s) {
+
+    if (s.size()<=1) return;
+
+    // reverse the whole string
+    reverse(s, 0, s.size()-1);
+
+    // reverse the each word
+    for ( int begin=0, i=0; i<=s.size(); i++ ) {
+        if ( isblank(s[i]) || s[i] == '\0') {
+            reverse(s, begin, i-1);
+            begin = i+1;
+        }
+    }
+}
+
+
+int main(int argc, char** argv)
+{
+    string s = "the sky is blue";
+    if ( argc > 1 ) {
+        s = argv[1];
+    }
+    
+    cout << s << endl;
+    reverseWords(s);
+    cout << s << endl;
+    
+}
diff --git a/code/train/C++/0097179_TgtCppsshConnection.cpp b/code/train/C++/0097179_TgtCppsshConnection.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7ea501388cd241ee025d5628d39f00ec3db18b02
--- /dev/null
+++ b/code/train/C++/0097179_TgtCppsshConnection.cpp
@@ -0,0 +1,230 @@
+/*
+    ComBomb - Terminal emulator
+    Copyright (C) 2014  Chris Desjardins
+    http://blog.chrisd.info cjd@chrisd.info
+
+    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 "cppssh/cppssh.h"
+#include "TgtCppsshConnection.h"
+#include "TgtThread.h"
+#include "CBException.h"
+#include "CDLogger/Logger.h"
+#include <boost/bind.hpp>
+#include <sstream>
+
+#ifdef WIN32
+#define CPPSSH_TIMEOUT 10000
+#else
+#define CPPSSH_TIMEOUT 1000
+#endif
+
+struct TgtCppsshImpl
+{
+    TgtCppsshImpl()
+        : _connectionId(-1),
+        _columns(0),
+        _rows(0),
+        _windowResize(false),
+        _connected(false)
+    {
+    }
+
+    std::shared_ptr<TgtThread> _sshThread;
+    int  _connectionId;
+    int  _columns;
+    int  _rows;
+    bool _windowResize;
+    std::mutex _windowResizeMutex;
+    bool _connected;
+};
+
+std::shared_ptr<TgtCppsshIntf> TgtCppsshIntf::createCppsshConnection(
+    const std::shared_ptr<const TgtConnectionConfig>& config)
+{
+    std::shared_ptr<TgtCppsshIntf> ret(new TgtCppsshIntf(config));
+    ret->tgtAttemptReconnect();
+    return ret;
+}
+
+TgtCppsshIntf::TgtCppsshIntf(const std::shared_ptr<const TgtConnectionConfig>& config)
+    : TgtIntf(config),
+    _sshData(new TgtCppsshImpl())
+{
+}
+
+TgtCppsshIntf::~TgtCppsshIntf()
+{
+    tgtDisconnect();
+    _sshData.reset();
+}
+
+void TgtCppsshIntf::tgtMakeConnection()
+{
+    std::shared_ptr<const TgtConnectionConfig> connectionConfig = std::dynamic_pointer_cast<const TgtConnectionConfig>(
+        _connectionConfig);
+
+    CppsshConnectStatus_t ret = Cppssh::connect(&_sshData->_connectionId, connectionConfig->_hostName.c_str(),
+                                                connectionConfig->_portNum, connectionConfig->_userName.c_str(),
+                                                connectionConfig->_privKeyFile.c_str(),
+                                                connectionConfig->_password.c_str(), CPPSSH_TIMEOUT,
+                                                connectionConfig->_x11Forwarded, connectionConfig->_keepAlives);
+    if (ret == CPPSSH_CONNECT_OK)
+    {
+        _sshData->_connected = true;
+        _sshData->_sshThread = TgtThread::create(boost::bind(std::bind(&TgtCppsshIntf::sshThread, this)));
+    }
+    else
+    {
+        std::stringstream s;
+        std::string reason;
+        switch (ret)
+        {
+            case CPPSSH_CONNECT_UNKNOWN_HOST:
+                reason = "Unknown host";
+                break;
+
+            case CPPSSH_CONNECT_AUTH_FAIL:
+                reason = "Authentication failure";
+                break;
+
+            case CPPSSH_CONNECT_INCOMPATIBLE_SERVER:
+                reason = "Incompatible server";
+                break;
+
+            case CPPSSH_CONNECT_KEX_FAIL:
+                reason = "Kex failure";
+                break;
+
+            default:
+            case CPPSSH_CONNECT_ERROR:
+                reason = "SSH Error";
+                break;
+        }
+
+        s << "Unable to connect to: " << connectionConfig->_hostName.c_str() << " " << reason;
+        throw CB_EXCEPTION_STR(CBException::CbExcp, s.str().c_str());
+    }
+}
+
+void TgtCppsshIntf::tgtBreakConnection()
+{
+    _sshData->_sshThread.reset();
+    Cppssh::close(_sshData->_connectionId);
+}
+
+void TgtCppsshIntf::tgtGetTitle(std::string* szTitle)
+{
+    std::shared_ptr<const TgtConnectionConfig> connectionConfig = std::dynamic_pointer_cast<const TgtConnectionConfig>(
+        _connectionConfig);
+    std::stringstream t;
+    t << connectionConfig->_hostName << ":" << connectionConfig->_portNum;
+    *szTitle = t.str();
+}
+
+bool TgtCppsshIntf::isConnected()
+{
+    return Cppssh::isConnected(_sshData->_connectionId) && _sshData->_connected;
+}
+
+bool TgtCppsshIntf::sshThread()
+{
+    bool attemptReconnect = false;
+    if ((isConnected() == false) || (sshSend() == false) || (sshRecv() == false))
+    {
+        attemptReconnect = true;
+        _sshData->_connected = false;
+    }
+    else if (_sshData->_windowResize == true)
+    {
+        tgtWindowResize(_sshData->_columns, _sshData->_rows);
+    }
+
+    if (attemptReconnect == true)
+    {
+        tgtAttemptReconnect();
+        _sshData->_windowResize = true;
+    }
+    return !attemptReconnect;
+}
+
+bool TgtCppsshIntf::sshSend()
+{
+    int ret = true;
+    boost::intrusive_ptr<RefCntBuffer> b;
+
+    while ((isConnected() == true) && (_outgoingData.dequeue(b, 1) == true))
+    {
+        uint8_t* data = boost::asio::buffer_cast<uint8_t*>(b->_buffer);
+
+        if (Cppssh::write(_sshData->_connectionId, data, boost::asio::buffer_size(b->_buffer)) == false)
+        {
+            cdLog(LogLevel::Error) << "Unable to write to host";
+        }
+    }
+    return ret;
+}
+
+bool TgtCppsshIntf::sshRecv()
+{
+    bool ret = true;
+
+    size_t sentBytes;
+    do
+    {
+        CppsshMessage msg;
+
+        sentBytes = 0;
+        if ((Cppssh::read(_sshData->_connectionId, &msg) == true) && (msg.length() > 0))
+        {
+            size_t length = msg.length();
+            while ((isConnected() == true) && (sentBytes < length) && (ret == true))
+            {
+                boost::intrusive_ptr<RefCntBuffer> currentIncomingBuffer;
+                if (_bufferPool->dequeue(currentIncomingBuffer, 100) == true)
+                {
+                    qint64 len = msg.length() - sentBytes;
+                    size_t copyLen =
+                        std::min((size_t)len, boost::asio::buffer_size(currentIncomingBuffer->_buffer) - 1);
+                    boost::asio::const_buffer b = boost::asio::const_buffer(msg.message() + sentBytes, len);
+                    sentBytes += boost::asio::buffer_copy(currentIncomingBuffer->_buffer, b, copyLen);
+                    currentIncomingBuffer->_buffer = boost::asio::buffer(currentIncomingBuffer->_buffer, copyLen);
+                    _incomingData.enqueue(currentIncomingBuffer);
+                }
+                else
+                {
+                    ret = false;
+                    break;
+                }
+            }
+        }
+    } while ((isConnected() == true) && (sentBytes > 0) && (ret == true));
+    return ret;
+}
+
+void TgtCppsshIntf::tgtWindowResize(int cols, int rows)
+{
+    std::unique_lock<std::mutex> guard(_sshData->_windowResizeMutex);
+    if ((_sshData->_columns != cols) || (_sshData->_rows != rows))
+    {
+        _sshData->_columns = cols;
+        _sshData->_rows = rows;
+        _sshData->_windowResize = true;
+    }
+    if ((_sshData->_windowResize == true) && (Cppssh::isConnected(_sshData->_connectionId) == true))
+    {
+        Cppssh::windowChange(_sshData->_connectionId, cols, rows);
+        _sshData->_windowResize = false;
+    }
+}
diff --git a/code/train/C++/0097249_qgsscalecombobox.cpp b/code/train/C++/0097249_qgsscalecombobox.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..379dc7026208c6af01799e17482cbb64316b7ca1
--- /dev/null
+++ b/code/train/C++/0097249_qgsscalecombobox.cpp
@@ -0,0 +1,244 @@
+/***************************************************************************
+         qgsscalecombobox.h
+         ------------------------
+  begin                : January 7, 2012
+  copyright            : (C) 2012 by Alexander Bruy
+  email                : alexander dot bruy at gmail dot 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 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#include "qgis.h"
+#include "qgslogger.h"
+#include "qgsscalecombobox.h"
+
+#include <QAbstractItemView>
+#include <QLocale>
+#include <QSettings>
+#include <QLineEdit>
+
+QgsScaleComboBox::QgsScaleComboBox( QWidget* parent ) : QComboBox( parent ), mScale( 1.0 )
+{
+  updateScales();
+
+  setEditable( true );
+  setInsertPolicy( QComboBox::NoInsert );
+  setCompleter( 0 );
+  connect( this, SIGNAL( activated( const QString & ) ), this, SLOT( fixupScale() ) );
+  connect( lineEdit(), SIGNAL( editingFinished() ), this, SLOT( fixupScale() ) );
+  fixupScale();
+}
+
+QgsScaleComboBox::~QgsScaleComboBox()
+{
+}
+
+void QgsScaleComboBox::updateScales( const QStringList &scales )
+{
+  QStringList myScalesList;
+  QString oldScale = currentText();
+
+  if ( scales.isEmpty() )
+  {
+    QSettings settings;
+    QString myScales = settings.value( "Map/scales", PROJECT_SCALES ).toString();
+    if ( !myScales.isEmpty() )
+    {
+      myScalesList = myScales.split( ',' );
+    }
+  }
+  else
+  {
+    QStringList::const_iterator scaleIt = scales.constBegin();
+    for ( ; scaleIt != scales.constEnd(); ++scaleIt )
+    {
+      myScalesList.append( *scaleIt );
+    }
+  }
+
+  QStringList parts;
+  double denominator;
+  bool ok;
+  for ( int i = 0; i < myScalesList.size(); ++i )
+  {
+    parts = myScalesList[ i ] .split( ':' );
+    denominator = QLocale::system().toDouble( parts[1], &ok );
+    if ( ok )
+    {
+      myScalesList[ i ] = toString( 1.0 / denominator );
+    }
+  }
+
+  blockSignals( true );
+  clear();
+  addItems( myScalesList );
+  setScaleString( oldScale );
+  blockSignals( false );
+}
+
+void QgsScaleComboBox::showPopup()
+{
+  QComboBox::showPopup();
+
+  if ( !currentText().contains( ':' ) )
+  {
+    return;
+  }
+  QStringList parts = currentText().split( ':' );
+  bool ok;
+  int idx = 0;
+  int min = 999999;
+  long currScale = parts.at( 1 ).toLong( &ok );
+  long nextScale, delta;
+  for ( int i = 0; i < count(); i++ )
+  {
+    parts = itemText( i ).split( ':' );
+    nextScale = parts.at( 1 ).toLong( &ok );
+    delta = qAbs( currScale - nextScale );
+    if ( delta < min )
+    {
+      min = delta;
+      idx = i;
+    }
+  }
+
+  blockSignals( true );
+  view()->setCurrentIndex( model()->index( idx, 0 ) );
+  blockSignals( false );
+  view()->setMinimumWidth( view()->sizeHintForColumn( 0 ) );
+}
+
+//! Function to read the selected scale as text
+QString QgsScaleComboBox::scaleString()
+{
+  return toString( mScale );
+}
+
+//! Function to set the selected scale from text
+bool QgsScaleComboBox::setScaleString( const QString& scaleTxt )
+{
+  bool ok;
+  double newScale = toDouble( scaleTxt, &ok );
+  if ( ! ok )
+  {
+    return false;
+  }
+  else
+  {
+    mScale = newScale;
+    setEditText( toString( mScale ) );
+    clearFocus();
+    return true;
+  }
+}
+
+//! Function to read the selected scale as double
+double QgsScaleComboBox::scale()
+{
+  return mScale;
+}
+
+//! Function to set the selected scale from double
+void QgsScaleComboBox::setScale( double scale )
+{
+  setScaleString( toString( scale ) );
+}
+
+//! Slot called when QComboBox has changed
+void QgsScaleComboBox::fixupScale()
+{
+  double newScale;
+  double oldScale = mScale;
+  bool ok, userSetScale;
+  QStringList txtList = currentText().split( ':' );
+  userSetScale = txtList.size() != 2;
+
+  // QgsDebugMsg( QString( "entered with oldScale: %1" ).arg( oldScale ) );
+  newScale = toDouble( currentText(), &ok );
+
+  // Valid string representation
+  if ( ok && ( newScale != oldScale ) )
+  {
+    // if a user types scale = 2345, we transform to 1:2345
+    if ( userSetScale && newScale >= 1.0 )
+    {
+      mScale = 1 / newScale;
+    }
+    else
+    {
+      mScale = newScale;
+    }
+    setScale( mScale );
+    emit scaleChanged();
+  }
+  else
+  {
+    // Invalid string representation or same scale
+    // Reset to the old
+    setScale( mScale );
+  }
+}
+
+QString QgsScaleComboBox::toString( double scale )
+{
+  if ( scale == 0 )
+  {
+    return "0";
+  }
+  else if ( scale > 1 )
+  {
+    return QString( "%1:1" ).arg( QLocale::system().toString( qRound( scale ) ) );
+  }
+  else
+  {
+    return QString( "1:%1" ).arg( QLocale::system().toString( qRound( 1.0 / scale ) ) );
+  }
+}
+
+double QgsScaleComboBox::toDouble( const QString& scaleString, bool * returnOk )
+{
+  bool ok = false;
+  QString scaleTxt( scaleString );
+
+  double scale = QGis::permissiveToDouble( scaleTxt, ok );
+  if ( ok )
+  {
+    // Create a text version and set that text and rescan
+    // Idea is to get the same rounding.
+    scaleTxt = toString( scale );
+  }
+  else
+  {
+    // It is now either X:Y or not valid
+    QStringList txtList = scaleTxt.split( ':' );
+    if ( 2 == txtList.size() )
+    {
+      bool okX = false;
+      bool okY = false;
+      int x = QGis::permissiveToInt( txtList[ 0 ], okX );
+      int y = QGis::permissiveToInt( txtList[ 1 ], okY );
+      if ( okX && okY )
+      {
+        // Scale is fraction of x and y
+        scale = ( double )x / ( double )y;
+        ok = true;
+      }
+    }
+  }
+
+  // Set up optional return flag
+  if ( returnOk )
+  {
+    *returnOk = ok;
+  }
+  return scale;
+}
+
+
diff --git a/code/train/C++/0097253_afinterleave.cpp b/code/train/C++/0097253_afinterleave.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..121b735c5ca0ba94d5d79395b6b670ad94121f84
--- /dev/null
+++ b/code/train/C++/0097253_afinterleave.cpp
@@ -0,0 +1,252 @@
+/*	Copyright: 	© Copyright 2005 Apple Computer, Inc. All rights reserved.
+
+	Disclaimer:	IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc.
+			("Apple") in consideration of your agreement to the following terms, and your
+			use, installation, modification or redistribution of this Apple software
+			constitutes acceptance of these terms.  If you do not agree with these terms,
+			please do not use, install, modify or redistribute this Apple software.
+
+			In consideration of your agreement to abide by the following terms, and subject
+			to these terms, Apple grants you a personal, non-exclusive license, under AppleÕs
+			copyrights in this original Apple software (the "Apple Software"), to use,
+			reproduce, modify and redistribute the Apple Software, with or without
+			modifications, in source and/or binary forms; provided that if you redistribute
+			the Apple Software in its entirety and without modifications, you must retain
+			this notice and the following text and disclaimers in all such redistributions of
+			the Apple Software.  Neither the name, trademarks, service marks or logos of
+			Apple Computer, Inc. may be used to endorse or promote products derived from the
+			Apple Software without specific prior written permission from Apple.  Except as
+			expressly stated in this notice, no other rights or licenses, express or implied,
+			are granted by Apple herein, including but not limited to any patent rights that
+			may be infringed by your derivative works or by other works in which the Apple
+			Software may be incorporated.
+
+			The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO
+			WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
+			WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+			PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
+			COMBINATION WITH YOUR PRODUCTS.
+
+			IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
+			CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+			GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+			ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION
+			OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT
+			(INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN
+			ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*=============================================================================
+	Interleaver.cpp
+	
+=============================================================================*/
+
+#include "CAAudioFile.h"
+#include "CAXException.h"
+#include <unistd.h>
+#include "CAChannelLayouts.h"
+#include "CAFilePathUtils.h"
+
+static void usage()
+{
+	fprintf(stderr,
+			"Usage:\n"
+			"%s [option...] input_file... -o output_file\n\n"
+			"Options: (may appear before or after arguments)\n"
+			"    { -l | --channellayout } layout_tag\n"
+			"        layout_tag: name of a constant from CoreAudioTypes.h\n"
+			"          (prefix \"kAudioChannelLayoutTag_\" may be omitted)\n",
+			getprogname()
+			);
+	exit(1);
+}
+
+
+void	Interleave(int nInputs, const char *infilenames[], const char *outfilename, const CAAudioChannelLayout *layout)
+{
+	const UInt32 kBufferSizeFrames = 0x8000;
+	const UInt32 kBufferSizeBytes = kBufferSizeFrames * sizeof(Float32);
+	class FileAndBuffer : public CAAudioFile {
+	public:
+		FileAndBuffer() : mBuf(NULL), mPtrs(NULL) { }
+		~FileAndBuffer() { delete mBuf; delete mPtrs; }
+		
+		CABufferList *	mBuf;
+		CABufferList *	mPtrs;
+	};
+	FileAndBuffer *infiles = new FileAndBuffer[nInputs], *file;
+	FileAndBuffer outfile;
+	int i;
+	UInt32 outputChannels = 0;
+	double sampleRate = 0.;
+	UInt32 maxBitDepth = 0;
+	CAStreamBasicDescription clientFormat;
+	bool outFileCreated = false;
+	
+	try {
+		// set up input files
+		for (i = 0; i < nInputs; ++i) {
+			file = &infiles[i];
+			file->Open(infilenames[i]);
+			const CAStreamBasicDescription &fmt = file->GetFileDataFormat();
+			//fmt.PrintFormat(stdout, "", "input file");
+			XThrowIf(fmt.mFormatID != kAudioFormatLinearPCM, -1, "input files must be PCM");
+			outputChannels += fmt.mChannelsPerFrame;
+			if (sampleRate == 0.)
+				sampleRate = fmt.mSampleRate;
+			else
+				XThrowIf(fmt.mSampleRate != sampleRate, -1, "input files must have the same sample rate");
+			if (fmt.mBitsPerChannel > maxBitDepth)
+				maxBitDepth = fmt.mBitsPerChannel;
+			clientFormat.mSampleRate = sampleRate;
+			clientFormat.SetCanonical(fmt.mChannelsPerFrame, false);	// deinterleaved
+			file->SetClientFormat(clientFormat, NULL);
+			file->mBuf = CABufferList::New("readbuf", clientFormat);
+			file->mBuf->AllocateBuffers(kBufferSizeBytes);
+			file->mPtrs = CABufferList::New("readptrs", clientFormat);
+			//clientFormat.PrintFormat(stdout, "", "input client");
+		}
+		
+		if (layout != NULL) {
+			if (AudioChannelLayoutTag_GetNumberOfChannels(layout->Tag()) != outputChannels) {
+				fprintf(stderr, "Channel layout tag '%s' is inappropriate for %lu channels of audio -- aborting\n", 
+					CAChannelLayouts::ConstantToString(layout->Tag()), outputChannels);
+				exit(2);
+			}
+		}
+
+		// prepare output file format
+		CAStreamBasicDescription outfmt;
+		outfmt.mSampleRate = sampleRate;
+		outfmt.mFormatID = kAudioFormatLinearPCM;
+		outfmt.mFormatFlags = kLinearPCMFormatFlagIsBigEndian | kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsPacked;
+		outfmt.mBitsPerChannel = maxBitDepth;
+		outfmt.mChannelsPerFrame = outputChannels;
+		outfmt.mBytesPerPacket = outfmt.mBytesPerFrame = outputChannels * (maxBitDepth >> 3);
+		outfmt.mFramesPerPacket = 1;
+		//outfmt.PrintFormat(stdout, "", "output file");
+		
+		unlink(outfilename);
+		FSRef parentDir;
+		CFStringRef outName;
+		XThrowIfError(PosixPathToParentFSRefAndName(outfilename, parentDir, outName), "Couldn't locate output directory");
+		outfile.CreateNew(parentDir, outName, kAudioFileAIFFType, outfmt, layout ? &layout->Layout() : NULL);
+		outFileCreated = true;
+		
+		// create the output file and buffers
+		clientFormat.mSampleRate = sampleRate;
+		clientFormat.SetCanonical(outputChannels, false);
+		outfile.SetClientFormat(clientFormat, NULL);
+		//clientFormat.PrintFormat(stdout, "", "output client");
+
+		outfile.mPtrs = CABufferList::New("writeptrs", clientFormat);
+
+		AudioBufferList &writebufs = outfile.mPtrs->GetModifiableBufferList();
+		int outbuf = 0;
+		for (i = 0; i < nInputs; ++i) {
+			file = &infiles[i];
+			const CABufferList *bl = file->mBuf;
+			const AudioBufferList &readbufs = bl->GetBufferList();
+			memcpy(&writebufs.mBuffers[outbuf], &readbufs.mBuffers[0], 
+				readbufs.mNumberBuffers * sizeof(AudioBuffer));
+			outbuf += readbufs.mNumberBuffers;
+		}
+		
+		while (true) {
+			UInt32 maxFramesRead = 0;
+			UInt32 nframes;
+			for (i = 0; i < nInputs; ++i) {
+				file = &infiles[i];
+				file->mPtrs->SetFrom(file->mBuf);
+				nframes = kBufferSizeFrames;
+				AudioBufferList &readbufs = file->mPtrs->GetModifiableBufferList();
+				file->Read(nframes, &readbufs);
+				//CAShowAudioBufferList(&readbufs, 8, 0);
+				if (nframes > maxFramesRead)
+					maxFramesRead = nframes;
+				if (nframes < kBufferSizeFrames)
+					file->mPtrs->PadWithZeroes(kBufferSizeBytes);
+			}
+			if (maxFramesRead == 0)
+				break;
+
+			if (maxFramesRead < kBufferSizeFrames)
+				outfile.mPtrs->SetNumBytes(maxFramesRead * sizeof(Float32));
+			//CAShowAudioBufferList(&writebufs, 8, 0);
+			outfile.Write(maxFramesRead, &writebufs);
+			if (maxFramesRead < kBufferSizeFrames)
+				break;
+		}
+	}
+	catch (...) {
+		if (outFileCreated)
+			unlink(outfilename);
+		delete[] infiles;
+		throw;
+	}
+	outfile.Close();
+	// input files are closed from destructors
+	delete[] infiles;
+}
+
+static void	MissingArgument()
+{
+	fprintf(stderr, "missing argument\n\n");
+	usage();
+}
+
+int	main(int argc, const char *argv[])
+{
+	int nins = 0;
+	static const int MAX_INPUT_FILES = 32;
+	const char *infiles[MAX_INPUT_FILES];
+	const char *outfile = NULL;
+	UInt32 layoutTag = 0;
+
+	for (int i = 1; i < argc; ++i) {
+		const char *arg = argv[i];
+		if (arg[0] != '-') {
+			if (nins >= MAX_INPUT_FILES) {
+				fprintf(stderr, "too many input files\n\n");
+				usage();
+			}
+			infiles[nins++] = arg;
+		} else {
+			arg += 1;
+			if (arg[0] == 'o') {
+				if (++i == argc) MissingArgument();
+				outfile = argv[i];
+			} else if (arg[0] == 'l' || !strcmp(arg, "-channellayout")) {
+				if (++i == argc) MissingArgument();
+				layoutTag = CAChannelLayouts::StringToConstant(argv[i]);
+				if (layoutTag == CAChannelLayouts::kInvalidTag) {
+					fprintf(stderr, "unknown channel layout tag: %s\n\n", argv[i]);
+					usage();
+				}
+			} else {
+				fprintf(stderr, "unknown argument: %s\n\n", arg - 1);
+				usage();
+			}
+		}
+	}
+	
+	if (nins < 2 || outfile == NULL)
+		usage();
+	
+	try {
+		if (layoutTag != 0) {
+			CAAudioChannelLayout layout = CAAudioChannelLayout(layoutTag);
+			Interleave(nins, infiles, outfile, &layout);
+		} else
+			Interleave(nins, infiles, outfile, NULL);
+	}
+	catch (CAXException &e) {
+		char buf[256];
+		fprintf(stderr, "Error: %s (%s)\n", e.mOperation, CAXException::FormatError(buf, e.mError));
+		return 1;
+	}
+	catch (...) {
+		fprintf(stderr, "An unknown error occurred\n");
+		return 1;
+	}
+	return 0;
+}
diff --git a/code/train/C++/0097282_GraphicEQFilterGUIView.cpp b/code/train/C++/0097282_GraphicEQFilterGUIView.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d9483125752aefb4000c9153e4507a1089224bfa
--- /dev/null
+++ b/code/train/C++/0097282_GraphicEQFilterGUIView.cpp
@@ -0,0 +1,59 @@
+/*
+    This file is part of EqualizerAPO, a system-wide equalizer.
+    Copyright (C) 2015  Jonas Thedering
+
+    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.
+*/
+
+#include "GraphicEQFilterGUIScene.h"
+#include "GraphicEQFilterGUIView.h"
+
+GraphicEQFilterGUIView::GraphicEQFilterGUIView(QWidget* parent)
+	: FrequencyPlotView(parent)
+{
+}
+
+void GraphicEQFilterGUIView::drawBackground(QPainter* painter, const QRectF& rect)
+{
+	FrequencyPlotView::drawBackground(painter, rect);
+
+	painter->setRenderHint(QPainter::Antialiasing, true);
+	GraphicEQFilterGUIScene* s = qobject_cast<GraphicEQFilterGUIScene*>(scene());
+	std::vector<FilterNode>& nodes = s->getNodes();
+	GainIterator gainIterator(nodes);
+	QPainterPath path;
+	bool first = true;
+	double lastDb = -1000;
+	for (int x = rect.left() - 1; x <= rect.right() + 1; x++)
+	{
+		double hz = s->xToHz(x);
+		double db = gainIterator.gainAt(hz);
+		double y = s->dbToY(db);
+		if (db == lastDb)
+			y = floor(y) + 0.5;
+		lastDb = db;
+		if (first)
+		{
+			path.moveTo(x, y);
+			first = false;
+		}
+		else
+		{
+			path.lineTo(x, y);
+		}
+	}
+	painter->setPen(Qt::black);
+	painter->drawPath(path);
+}
diff --git a/code/train/C++/0097468_umbmark.cpp b/code/train/C++/0097468_umbmark.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7ec8c597b5f084fe8b709b5f3b9c23e98d21d7a4
--- /dev/null
+++ b/code/train/C++/0097468_umbmark.cpp
@@ -0,0 +1,167 @@
+#include <iostream>
+
+#include <ros/ros.h>
+#include <geometry_msgs/Twist.h>
+#include <tf/transform_listener.h>
+
+class RobotDriver
+{
+private:
+  //! The node handle we'll be using
+  ros::NodeHandle nh_;
+  //! We will be publishing to the "cmd_vel" topic to issue commands
+  ros::Publisher cmd_vel_pub_;
+  //! We will be listening to TF transforms as well
+  tf::TransformListener listener_;
+
+public:
+  //! ROS node initialization
+  RobotDriver(ros::NodeHandle &nh)
+  {
+    nh_ = nh;
+    //set up the publisher for the cmd_vel topic
+    cmd_vel_pub_ = nh_.advertise<geometry_msgs::Twist>("cmd_vel", 1);
+  }
+
+  //! Drive forward a specified distance based on odometry information
+  bool driveForwardOdom(double distance)
+  {
+    //wait for the listener to get the first message
+    listener_.waitForTransform("base_link", "odom",
+                               ros::Time(0), ros::Duration(1.0));
+    
+    //we will record transforms here
+    tf::StampedTransform start_transform;
+    tf::StampedTransform current_transform;
+
+    //record the starting transform from the odometry to the base frame
+    listener_.lookupTransform("base_link", "odom",
+                              ros::Time(0), start_transform);
+    
+    //we will be sending commands of type "twist"
+    geometry_msgs::Twist base_cmd;
+    //the command will be to go forward at 0.25 m/s
+    base_cmd.linear.y = base_cmd.angular.z = 0;
+    base_cmd.linear.x = 0.25;
+    
+    ros::Rate rate(10.0);
+    bool done = false;
+    while (!done && nh_.ok())
+    {
+      //send the drive command
+      cmd_vel_pub_.publish(base_cmd);
+      rate.sleep();
+      //get the current transform
+      try
+      {
+        listener_.lookupTransform("base_link", "odom",
+                                  ros::Time(0), current_transform);
+      }
+      catch (tf::TransformException ex)
+      {
+        ROS_ERROR("%s",ex.what());
+        break;
+      }
+      //see how far we've traveled
+      tf::Transform relative_transform = 
+        start_transform.inverse() * current_transform;
+      double dist_moved = relative_transform.getOrigin().length();
+
+      if(dist_moved > distance)
+	 done = true;
+    }
+    if (done)
+	 return true;
+    return false;
+  }
+
+  bool turnOdom(bool clockwise, double radians)
+  {
+    while(radians < 0) radians += 2*M_PI;
+    while(radians > 2*M_PI) radians -= 2*M_PI;
+
+    //wait for the listener to get the first message
+    listener_.waitForTransform("base_link", "odom",
+                               ros::Time(0), ros::Duration(1.0));
+    
+    //we will record transforms here
+    tf::StampedTransform start_transform;
+    tf::StampedTransform current_transform;
+
+    //record the starting transform from the odometry to the base frame
+    listener_.lookupTransform("base_link", "odom",
+                              ros::Time(0), start_transform);
+    
+    //we will be sending commands of type "twist"
+    geometry_msgs::Twist base_cmd;
+    //the command will be to turn at 0.1 rad/s
+    base_cmd.linear.x = base_cmd.linear.y = 0.0;
+    base_cmd.angular.z = 0.1;
+    if (clockwise) base_cmd.angular.z = -base_cmd.angular.z;
+    
+    //the axis we want to be rotating by
+    tf::Vector3 desired_turn_axis(0,0,1);
+    if (!clockwise) desired_turn_axis = -desired_turn_axis;
+    
+    ros::Rate rate(10.0);
+    bool done = false;
+    while (!done && nh_.ok())
+    {
+      //send the drive command
+      cmd_vel_pub_.publish(base_cmd);
+      rate.sleep();
+      //get the current transform
+      try
+      {
+        listener_.lookupTransform("base_link", "odom",
+                                  ros::Time(0), current_transform);
+      }
+      catch (tf::TransformException ex)
+      {
+        ROS_ERROR("%s",ex.what());
+        break;
+      }
+      tf::Transform relative_transform = 
+        start_transform.inverse() * current_transform;
+      tf::Vector3 actual_turn_axis = 
+        relative_transform.getRotation().getAxis();
+      double angle_turned = relative_transform.getRotation().getAngle();
+      if ( fabs(angle_turned) < 1.0e-2) continue;
+
+      if ( actual_turn_axis.dot( desired_turn_axis ) < 0 ) 
+        angle_turned = 2 * M_PI - angle_turned;
+
+      if (angle_turned > radians)
+        done = true;
+    }
+    if (done)
+      return true;
+    return false;
+  }
+};
+
+int main(int argc, char** argv)
+{
+  //init the ROS node
+  ros::init(argc, argv, "robot_driver");
+  ros::NodeHandle nh;
+
+  RobotDriver driver(nh);
+  std::cout << "Press any key to start" << std::endl;
+  std::cin.get();
+
+//  for (uint8_t i = 0; i < 4; i++) {
+//    std::cout << "Driving forward 0.5m" << std::endl;
+//    driver.driveForwardOdom(0.5);
+//    std::cout << "Drove 0.5m forward, press any key to continue" << std::endl;
+//    std::cin.get();
+
+    std::cout << "Turning Right pi/2 radians" << std::endl;
+    driver.turnOdom(true, 1.57079633);
+//    std::cout << "Turned pi/2 radians right, press any key to continue" << std::endl;
+//    std::cin.get();
+//  }
+  std::cout << "Done, press any key to exit" << std::endl;
+  std::cin.get();
+}
+
diff --git a/code/train/C++/0097754_SegmentNodeList.cpp b/code/train/C++/0097754_SegmentNodeList.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..045d46b073b54fda58693cfbde7003100ef9dd03
--- /dev/null
+++ b/code/train/C++/0097754_SegmentNodeList.cpp
@@ -0,0 +1,229 @@
+/**********************************************************************
+ * $Id$
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.refractions.net
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Licence as published
+ * by the Free Software Foundation. 
+ * See the COPYING file for more information.
+ *
+ **********************************************************************/
+
+#include <geos/noding.h>
+#include <geos/profiler.h>
+
+namespace geos {
+
+#if PROFILE
+static Profiler *profiler = Profiler::instance();
+#endif
+
+SegmentNodeList::SegmentNodeList(const SegmentString *newEdge)
+{
+	nodes=new set<SegmentNode*,SegmentNodeLT>();
+	edge=newEdge;
+}
+
+SegmentNodeList::~SegmentNodeList()
+{
+	set<SegmentNode *, SegmentNodeLT>::iterator it;
+	for(it=nodes->begin(); it != nodes->end(); it++) delete *it;
+	delete nodes;
+
+	unsigned int i;
+	for(i=0; i<splitEdges.size(); i++)
+	{
+		delete splitEdges[i];
+	}
+	for(i=0; i<splitCoordLists.size(); i++)
+	{
+		delete splitCoordLists[i];
+	}
+}
+
+/**
+ * Adds an intersection into the list, if it isn't already there.
+ * The input segmentIndex and dist are expected to be normalized.
+ * @return the SegmentIntersection found or added
+ */
+SegmentNode*
+SegmentNodeList::add(Coordinate *intPt, int segmentIndex, double dist)
+{
+#if PROFILE
+	profiler->start("SegmentNodeList::add");
+#endif
+	SegmentNode *eiNew=new SegmentNode(intPt, segmentIndex, dist);
+
+	set<SegmentNode*,SegmentNodeLT>::iterator it  = nodes->find(eiNew);
+	if ( it != nodes->end() )
+	{
+		delete eiNew;
+#if PROFILE
+	profiler->stop("SegmentNodeList::add");
+#endif
+		return *it;
+	}
+
+	nodes->insert(eiNew);
+#if PROFILE
+	profiler->stop("SegmentNodeList::add");
+#endif
+	return eiNew;
+}
+
+/**
+ * Adds entries for the first and last points of the edge to the list
+ */
+void SegmentNodeList::addEndpoints()
+{
+	int maxSegIndex = edge->size() - 1;
+	add((Coordinate*)&(edge->getCoordinate(0)), 0, 0.0);
+	add((Coordinate*)&(edge->getCoordinate(maxSegIndex)), maxSegIndex, 0.0);
+}
+
+/**
+ * Creates new edges for all the edges that the intersections in this
+ * list split the parent edge into.
+ * Adds the edges to the input list (this is so a single list
+ * can be used to accumulate all split edges for a Geometry).
+ */
+void
+SegmentNodeList::addSplitEdges(vector<SegmentString*> *edgeList)
+{
+	// testingOnly
+	//vector<SegmentString*> *testingSplitEdges=new vector<SegmentString*>();
+	// ensure that the list has entries for the first and last point of the edge
+	addEndpoints();
+
+	set<SegmentNode*,SegmentNodeLT>::iterator it=nodes->begin();
+	// there should always be at least two entries in the list
+	SegmentNode *eiPrev=*it;
+	it++;
+	for(;it!=nodes->end();it++) {
+		SegmentNode *ei=*it;
+		SegmentString *newEdge=createSplitEdge(eiPrev, ei);
+		edgeList->push_back(newEdge);
+		//testingSplitEdges->push_back(newEdge);
+		eiPrev = ei;
+	}
+	//checkSplitEdgesCorrectness(testingSplitEdges);
+}
+
+void
+SegmentNodeList::checkSplitEdgesCorrectness(vector<SegmentString*> *splitEdges)
+{
+	const CoordinateSequence *edgePts=edge->getCoordinates();
+	// check that first and last points of split edges are same as endpoints of edge
+	SegmentString *split0=(*splitEdges)[0];
+	Coordinate pt0=split0->getCoordinate(0);
+	if (!(pt0==edgePts->getAt(0)))
+		throw new GEOSException("bad split edge start point at " + pt0.toString());
+	SegmentString *splitn=(*splitEdges)[splitEdges->size()-1];
+	const CoordinateSequence *splitnPts=splitn->getCoordinatesRO();
+	const Coordinate &ptn=splitnPts->getAt(splitnPts->getSize()-1);
+	if (!(ptn==edgePts->getAt(edgePts->getSize()-1)))
+		throw new GEOSException("bad split edge end point at " + ptn.toString());
+}
+
+/**
+ * Create a new "split edge" with the section of points between
+ * (and including) the two intersections.
+ * The label for the new edge is the same as the label for the parent edge.
+ */
+SegmentString*
+SegmentNodeList::createSplitEdge(SegmentNode *ei0, SegmentNode *ei1)
+{
+	//Debug.print("\ncreateSplitEdge"); Debug.print(ei0); Debug.print(ei1);
+	int npts = ei1->segmentIndex - ei0->segmentIndex + 2;
+	Coordinate lastSegStartPt=edge->getCoordinate(ei1->segmentIndex);
+	// if the last intersection point is not equal to the its segment start pt,
+	// add it to the points list as well.
+	// (This check is needed because the distance metric is not totally reliable!)
+	// The check for point equality is 2D only - Z values are ignored
+	bool useIntPt1=ei1->dist > 0.0 || ! ei1->coord->equals2D(lastSegStartPt);
+	if (! useIntPt1) {
+		npts--;
+	}
+	CoordinateSequence *pts = new DefaultCoordinateSequence(npts); 
+	int ipt = 0;
+	//pts->setAt(Coordinate(*(ei0->coord)),ipt++);
+	pts->setAt(*(ei0->coord), ipt++);
+	for (int i = ei0->segmentIndex + 1; i <= ei1->segmentIndex; i++) {
+		pts->setAt(edge->getCoordinate(i),ipt++);
+	}
+	if (useIntPt1) 	pts->setAt(*(ei1->coord),ipt++);
+	SegmentString *ret = new SegmentString(pts,edge->getContext());
+	splitEdges.push_back(ret);
+	splitCoordLists.push_back(pts);
+	return ret;
+}
+
+string SegmentNodeList::print(){
+	string out="Intersections:";
+	set<SegmentNode*,SegmentNodeLT>::iterator it=nodes->begin();
+	for(;it!=nodes->end();it++) {
+		SegmentNode *ei=*it;
+		out.append(ei->print());
+	}
+	return out;
+}
+
+} // namespace geos
+
+/**********************************************************************
+ * $Log$
+ * Revision 1.11  2004/11/01 16:43:04  strk
+ * Added Profiler code.
+ * Temporarly patched a bug in DoubleBits (must check drawbacks).
+ * Various cleanups and speedups.
+ *
+ * Revision 1.10  2004/07/13 08:33:53  strk
+ * Added missing virtual destructor to virtual classes.
+ * Fixed implicit unsigned int -> int casts
+ *
+ * Revision 1.9  2004/07/08 19:34:49  strk
+ * Mirrored JTS interface of CoordinateSequence, factory and
+ * default implementations.
+ * Added DefaultCoordinateSequenceFactory::instance() function.
+ *
+ * Revision 1.8  2004/07/02 13:28:27  strk
+ * Fixed all #include lines to reflect headers layout change.
+ * Added client application build tips in README.
+ *
+ * Revision 1.7  2004/07/01 14:12:44  strk
+ *
+ * Geometry constructors come now in two flavors:
+ * 	- deep-copy args (pass-by-reference)
+ * 	- take-ownership of args (pass-by-pointer)
+ * Same functionality is available through GeometryFactory,
+ * including buildGeometry().
+ *
+ * Revision 1.6  2004/06/16 13:13:25  strk
+ * Changed interface of SegmentString, now copying CoordinateSequence argument.
+ * Fixed memory leaks associated with this and MultiGeometry constructors.
+ * Other associated fixes.
+ *
+ * Revision 1.5  2004/05/27 10:27:03  strk
+ * Memory leaks fixed.
+ *
+ * Revision 1.4  2004/05/06 15:54:15  strk
+ * SegmentNodeList keeps track of created splitEdges for later destruction.
+ * SegmentString constructor copies given Label.
+ * Buffer operation does no more leaks for doc/example.cpp
+ *
+ * Revision 1.3  2004/05/03 22:56:44  strk
+ * leaks fixed, exception specification omitted.
+ *
+ * Revision 1.2  2004/05/03 20:49:20  strk
+ * Some more leaks fixed
+ *
+ * Revision 1.1  2004/03/26 07:48:30  ybychkov
+ * "noding" package ported (JTS 1.4)
+ *
+ *
+ **********************************************************************/
+
diff --git a/code/train/C++/0097898_Wrappertopness.cc b/code/train/C++/0097898_Wrappertopness.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a94801e0ee0d1f9a2fc0943c0fbb8840116baee6
--- /dev/null
+++ b/code/train/C++/0097898_Wrappertopness.cc
@@ -0,0 +1,136 @@
+#include<iostream>
+#include<string>
+#include<stdlib.h> 
+
+#include "topness/simplex.h"
+
+/* Wrapper for topness minimization using the Nelder-Mead algorithm 
+
+   Parameters for the Nelder-Mead algorithm set here 
+
+   DMAX set to 4 in simplex.h 
+
+   top and W masses used in the topness algorithm set in topness_struc.h 
+
+   Written by Michael L. Graesser, 06/2015    
+
+*/
+
+using namespace std; 
+
+double topnesscompute(double pb1[4], double pb2[4], double pl[4], double MET[4], double sigmat, double sigmaW, double sigmas, double xbest[4]) 
+{
+
+  double alpha=1.0; // parameter for reflection 
+  double beta=0.5;  // parameter for contraction 
+  double gamma=2.0;  // parameter for expansion 
+
+  const int d=4;    // number of parameters to scan over, not the space-time dimension! 
+  const int DIMMAX=d*(d+1);  // dimension of simplex 
+  double xin[d+1][d];    // starting point 
+  double xstart[DIMMAX]; // algorithm stores d+1 points of simplex in a single array
+
+
+  double eps=0.000002;   // tolerance
+  double Deltastep=20.;  // initial spacing of points, in GeV
+  int Ntry=100000;    // maximum number of Nelder-Mead cycles to perform for a given initial seed   
+  int Nattempts=15; //   number of initial starts 
+
+  // get random seed (once) 
+  // default c++ "random number" generator good enough here      
+  srand((unsigned)time(0));
+  double rndm, start ;
+  int n=3000;
+  // get going                                                                     
+  for (int i=0; i<100; i++)
+    {
+      rndm=(rand()%n)+1;
+    }
+  double edir[]={1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1};
+  double ybest=1000000000.; // a big number 
+  double ybest1=100000000.;                                           
+  double xbest1[]={1000.,1000.,1000.,1000.};
+  double ybest2=100000000.;  // a big number                                          
+  double xbest2[]={1000.,1000.,1000.,1000.};
+  int i,j,k;
+  // int tid;                                                                                       
+  bool converge1, converge2;         
+  
+  // initialize topness function  
+  my_func topstat1(pb1,pb2,pl,MET,sigmat,sigmaW,sigmas,1.0);
+  my_func topstat2(pb2,pb1,pl,MET,sigmat,sigmaW,sigmas,1.0); // other combination  
+
+  // initialize topness computation 
+  my_Nelder_Mead my_check1(d,alpha,beta,gamma, Ntry, eps, Deltastep, n, &topstat1);
+  my_Nelder_Mead my_check2(d,alpha,beta,gamma, Ntry, eps, Deltastep, n, &topstat2);
+  double yl;
+  // begin loop over Nattempts
+  for (k=0; k<Nattempts; k++)
+    {
+      // initialize starting point 
+      for (i=0;i<d+1; i++)
+        {
+          for (j=0; j<d; j++)
+            {
+              if (i==0)
+                {
+                  rndm=(rand()%n)+1;
+                  start= (rndm/n-0.5);
+                  xin[0][j]=8000.0*start;
+                }
+              else
+                {
+                  xin[i][j]=xin[0][j]+Deltastep*edir[d*(i-1)+j];
+                }
+            }
+          copy(xin[i],xin[i]+d, xstart+d*i);  // copy initial data into xstart          
+        }
+      // now first combination 
+      converge1=my_check1.find_global_min(xstart);
+      if (converge1==true)
+        {
+
+          yl=my_check1.yfinal;
+          if (yl < ybest1)
+            {
+              ybest1=yl;
+              copy(my_check1.xfinal,my_check1.xfinal+d,xbest1);
+            }
+        }
+      else
+        {
+          cout << " Minimum not found...exiting " << endl;
+        }
+      // now do second combination                                                      
+      converge2=my_check2.find_global_min(xstart);
+      if (converge2==true)
+        {
+          yl=my_check2.yfinal;
+          if (yl < ybest2)
+            {
+              ybest2=yl;
+              copy(my_check2.xfinal,my_check2.xfinal+d,xbest2);
+            }
+        }
+      else
+	{
+          cout << " Minimum not found...exiting " << endl;
+        }
+
+    }
+
+  if (ybest1 < ybest2)
+    {
+    ybest=ybest1;
+    copy(xbest1,xbest1+d,xbest);
+    }
+   else
+   {
+     ybest=ybest2;
+     copy(xbest2,xbest2+d,xbest);
+   }
+
+  return ybest; 
+
+}
+
diff --git a/code/train/C++/0098061_font_list_impl.cc b/code/train/C++/0098061_font_list_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3eb55be5933a9e26abef16505a130d8be9e5639b
--- /dev/null
+++ b/code/train/C++/0098061_font_list_impl.cc
@@ -0,0 +1,199 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/font_list_impl.h"
+
+#include <algorithm>
+
+#include "base/logging.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/font_list.h"
+
+namespace {
+
+// Returns a font description from |families|, |style|, and |size_pixels|.
+std::string BuildDescription(const std::vector<std::string>& families,
+                             int style,
+                             int size_pixels) {
+  std::string description = base::JoinString(families, ",");
+  description += ",";
+
+  if (style & gfx::Font::BOLD)
+    description += "Bold ";
+  if (style & gfx::Font::ITALIC)
+    description += "Italic ";
+
+  description += base::IntToString(size_pixels);
+  description += "px";
+
+  return description;
+}
+
+}  // namespace
+
+namespace gfx {
+
+FontListImpl::FontListImpl(const std::string& font_description_string)
+    : font_description_string_(font_description_string),
+      common_height_(-1),
+      common_baseline_(-1),
+      font_style_(-1),
+      font_size_(-1) {
+  DCHECK(!font_description_string.empty());
+  // DCHECK description string ends with "px" for size in pixel.
+  DCHECK(base::EndsWith(font_description_string, "px",
+                        base::CompareCase::SENSITIVE));
+}
+
+FontListImpl::FontListImpl(const std::vector<std::string>& font_names,
+                           int font_style,
+                           int font_size)
+    : font_description_string_(BuildDescription(font_names, font_style,
+                                                font_size)),
+      common_height_(-1),
+      common_baseline_(-1),
+      font_style_(font_style),
+      font_size_(font_size) {
+  DCHECK(!font_names.empty());
+  DCHECK(!font_names[0].empty());
+}
+
+FontListImpl::FontListImpl(const std::vector<Font>& fonts)
+    : fonts_(fonts),
+      common_height_(-1),
+      common_baseline_(-1),
+      font_style_(-1),
+      font_size_(-1) {
+  DCHECK(!fonts.empty());
+  font_style_ = fonts[0].GetStyle();
+  font_size_ = fonts[0].GetFontSize();
+#if DCHECK_IS_ON()
+  for (size_t i = 1; i < fonts.size(); ++i) {
+    DCHECK_EQ(fonts[i].GetStyle(), font_style_);
+    DCHECK_EQ(fonts[i].GetFontSize(), font_size_);
+  }
+#endif
+}
+
+FontListImpl::FontListImpl(const Font& font)
+    : common_height_(-1),
+      common_baseline_(-1),
+      font_style_(-1),
+      font_size_(-1) {
+  fonts_.push_back(font);
+}
+
+FontListImpl* FontListImpl::Derive(int size_delta, int font_style) const {
+  // If there is a font vector, derive from that.
+  if (!fonts_.empty()) {
+    std::vector<Font> fonts = fonts_;
+    for (size_t i = 0; i < fonts.size(); ++i)
+      fonts[i] = fonts[i].Derive(size_delta, font_style);
+    return new FontListImpl(fonts);
+  }
+
+  // Otherwise, parse the font description string to derive from it.
+  std::vector<std::string> font_names;
+  int old_size;
+  int old_style;
+  CHECK(FontList::ParseDescription(font_description_string_, &font_names,
+                                   &old_style, &old_size));
+  const int size = std::max(1, old_size + size_delta);
+  return new FontListImpl(font_names, font_style, size);
+}
+
+int FontListImpl::GetHeight() const {
+  if (common_height_ == -1)
+    CacheCommonFontHeightAndBaseline();
+  return common_height_;
+}
+
+int FontListImpl::GetBaseline() const {
+  if (common_baseline_ == -1)
+    CacheCommonFontHeightAndBaseline();
+  return common_baseline_;
+}
+
+int FontListImpl::GetCapHeight() const {
+  // Assume the primary font is used to render Latin characters.
+  return GetPrimaryFont().GetCapHeight();
+}
+
+int FontListImpl::GetExpectedTextWidth(int length) const {
+  // Rely on the primary font metrics for the time being.
+  return GetPrimaryFont().GetExpectedTextWidth(length);
+}
+
+int FontListImpl::GetFontStyle() const {
+  if (font_style_ == -1)
+    CacheFontStyleAndSize();
+  return font_style_;
+}
+
+int FontListImpl::GetFontSize() const {
+  if (font_size_ == -1)
+    CacheFontStyleAndSize();
+  return font_size_;
+}
+
+const std::vector<Font>& FontListImpl::GetFonts() const {
+  if (fonts_.empty()) {
+    DCHECK(!font_description_string_.empty());
+
+    std::vector<std::string> font_names;
+    // It's possible that gfx::Font::UNDERLINE is specified and it's already
+    // stored in |font_style_| but |font_description_string_| doesn't have the
+    // underline info.  So we should respect |font_style_| as long as it's
+    // valid.
+    int style = 0;
+    CHECK(FontList::ParseDescription(font_description_string_, &font_names,
+                                     &style, &font_size_));
+    if (font_style_ == -1)
+      font_style_ = style;
+    for (size_t i = 0; i < font_names.size(); ++i) {
+      DCHECK(!font_names[i].empty());
+
+      Font font(font_names[i], font_size_);
+      if (font_style_ == Font::NORMAL)
+        fonts_.push_back(font);
+      else
+        fonts_.push_back(font.Derive(0, font_style_));
+    }
+  }
+  return fonts_;
+}
+
+const Font& FontListImpl::GetPrimaryFont() const {
+  return GetFonts()[0];
+}
+
+FontListImpl::~FontListImpl() {}
+
+void FontListImpl::CacheCommonFontHeightAndBaseline() const {
+  int ascent = 0;
+  int descent = 0;
+  const std::vector<Font>& fonts = GetFonts();
+  for (std::vector<Font>::const_iterator i = fonts.begin();
+       i != fonts.end(); ++i) {
+    ascent = std::max(ascent, i->GetBaseline());
+    descent = std::max(descent, i->GetHeight() - i->GetBaseline());
+  }
+  common_height_ = ascent + descent;
+  common_baseline_ = ascent;
+}
+
+void FontListImpl::CacheFontStyleAndSize() const {
+  if (!fonts_.empty()) {
+    font_style_ = fonts_[0].GetStyle();
+    font_size_ = fonts_[0].GetFontSize();
+  } else {
+    std::vector<std::string> font_names;
+    CHECK(FontList::ParseDescription(font_description_string_, &font_names,
+                                     &font_style_, &font_size_));
+  }
+}
+
+}  // namespace gfx
diff --git a/code/train/C/0099378_cli.c b/code/train/C/0099378_cli.c
new file mode 100644
index 0000000000000000000000000000000000000000..488d641cfcfef49751dd94c2481d3617d5eb6cfb
--- /dev/null
+++ b/code/train/C/0099378_cli.c
@@ -0,0 +1,246 @@
+/*
+ * Command line interface for libnvram
+ *
+ * Copyright 2009, Jo-Philipp Wich <xm@subsignal.org>
+ *
+ * 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.
+ *
+ *
+ * The libnvram code is based on Broadcom code for Linux 2.4.x .
+ *
+ */
+
+#include "nvram.h"
+
+
+static nvram_handle_t * nvram_open_rdonly(void)
+{
+	const char *file = nvram_find_staging();
+
+	if( file == NULL )
+		file = nvram_find_mtd();
+
+	if( file != NULL )
+		return nvram_open(file, NVRAM_RO);
+
+	return NULL;
+}
+
+static nvram_handle_t * nvram_open_staging(void)
+{
+	if( nvram_find_staging() != NULL || nvram_to_staging() == 0 )
+		return nvram_open(NVRAM_STAGING, NVRAM_RW);
+
+	return NULL;
+}
+
+static int do_show(nvram_handle_t *nvram)
+{
+	nvram_tuple_t *t;
+	int stat = 1;
+
+	if( (t = nvram_getall(nvram)) != NULL )
+	{
+		while( t )
+		{
+			printf("%s=%s\n", t->name, t->value);
+			t = t->next;
+		}
+
+		stat = 0;
+	}
+
+	return stat;
+}
+
+static int do_get(nvram_handle_t *nvram, const char *var)
+{
+	const char *val;
+	int stat = 1;
+
+	if( (val = nvram_get(nvram, var)) != NULL )
+	{
+		printf("%s\n", val);
+		stat = 0;
+	}
+
+	return stat;
+}
+
+static int do_unset(nvram_handle_t *nvram, const char *var)
+{
+	return nvram_unset(nvram, var);
+}
+
+static int do_set(nvram_handle_t *nvram, const char *pair)
+{
+	char *val = strstr(pair, "=");
+	char var[strlen(pair)];
+	int stat = 1;
+
+	if( val != NULL )
+	{
+		memset(var, 0, sizeof(var));
+		strncpy(var, pair, (int)(val-pair));
+		stat = nvram_set(nvram, var, (char *)(val + 1));
+	}
+
+	return stat;
+}
+
+static int do_info(nvram_handle_t *nvram)
+{
+	nvram_header_t *hdr = nvram_header(nvram);
+
+	/* CRC8 over the last 11 bytes of the header and data bytes */
+	uint8_t crc = hndcrc8((unsigned char *) &hdr[0] + NVRAM_CRC_START_POSITION,
+		hdr->len - NVRAM_CRC_START_POSITION, 0xff);
+
+	/* Show info */
+	printf("Magic:         0x%08X\n",   hdr->magic);
+	printf("Length:        0x%08X\n",   hdr->len);
+	printf("Offset:        0x%08X\n",   nvram->offset);
+
+	printf("CRC8:          0x%02X (calculated: 0x%02X)\n",
+		hdr->crc_ver_init & 0xFF, crc);
+
+	printf("Version:       0x%02X\n",   (hdr->crc_ver_init >> 8) & 0xFF);
+	printf("SDRAM init:    0x%04X\n",   (hdr->crc_ver_init >> 16) & 0xFFFF);
+	printf("SDRAM config:  0x%04X\n",   hdr->config_refresh & 0xFFFF);
+	printf("SDRAM refresh: 0x%04X\n",   (hdr->config_refresh >> 16) & 0xFFFF);
+	printf("NCDL values:   0x%08X\n\n", hdr->config_ncdl);
+
+	printf("%i bytes used / %i bytes available (%.2f%%)\n",
+		hdr->len, nvram->length - nvram->offset - hdr->len,
+		(100.00 / (double)(nvram->length - nvram->offset)) * (double)hdr->len);
+
+	return 0;
+}
+
+
+int main( int argc, const char *argv[] )
+{
+	nvram_handle_t *nvram;
+	int commit = 0;
+	int write = 0;
+	int stat = 1;
+	int done = 0;
+	int i;
+
+	/* Ugly... iterate over arguments to see whether we can expect a write */
+	for( i = 1; i < argc; i++ )
+		if( ( !strcmp(argv[i], "set")   && ++i < argc ) ||
+			( !strcmp(argv[i], "unset") && ++i < argc ) ||
+			!strcmp(argv[i], "commit") )
+		{
+			write = 1;
+			break;
+		}
+
+
+	nvram = write ? nvram_open_staging() : nvram_open_rdonly();
+
+	if( nvram != NULL && argc > 1 )
+	{
+		for( i = 1; i < argc; i++ )
+		{
+			if( !strcmp(argv[i], "show") )
+			{
+				stat = do_show(nvram);
+				done++;
+			}
+			else if( !strcmp(argv[i], "info") )
+			{
+				stat = do_info(nvram);
+				done++;
+			}
+			else if( !strcmp(argv[i], "get") || !strcmp(argv[i], "unset") || !strcmp(argv[i], "set") )
+			{
+				if( (i+1) < argc )
+				{
+					switch(argv[i++][0])
+					{
+						case 'g':
+							stat = do_get(nvram, argv[i]);
+							break;
+
+						case 'u':
+							stat = do_unset(nvram, argv[i]);
+							break;
+
+						case 's':
+							stat = do_set(nvram, argv[i]);
+							break;
+					}
+					done++;
+				}
+				else
+				{
+					fprintf(stderr, "Command '%s' requires an argument!\n", argv[i]);
+					done = 0;
+					break;
+				}
+			}
+			else if( !strcmp(argv[i], "commit") )
+			{
+				commit = 1;
+				done++;
+			}
+			else
+			{
+				fprintf(stderr, "Unknown option '%s' !\n", argv[i]);
+				done = 0;
+				break;
+			}
+		}
+
+		if( write )
+			stat = nvram_commit(nvram);
+
+		nvram_close(nvram);
+
+		if( commit )
+			stat = staging_to_nvram();
+	}
+
+	if( !nvram )
+	{
+		fprintf(stderr,
+			"Could not open nvram! Possible reasons are:\n"
+			"	- No device found (/proc not mounted or no nvram present)\n"
+			"	- Insufficient permissions to open mtd device\n"
+			"	- Insufficient memory to complete operation\n"
+			"	- Memory mapping failed or not supported\n"
+		);
+
+		stat = 1;
+	}
+	else if( !done )
+	{
+		fprintf(stderr,
+			"Usage:\n"
+			"	nvram show\n"
+			"	nvram info\n"
+			"	nvram get variable\n"
+			"	nvram set variable=value [set ...]\n"
+			"	nvram unset variable [unset ...]\n"
+			"	nvram commit\n"
+		);
+
+		stat = 1;
+	}
+
+	return stat;
+}
diff --git a/code/train/C/0100581_cmd_line_opts.c b/code/train/C/0100581_cmd_line_opts.c
new file mode 100644
index 0000000000000000000000000000000000000000..4d1ba4c1705df5bb7570cff278338475cdb4360c
--- /dev/null
+++ b/code/train/C/0100581_cmd_line_opts.c
@@ -0,0 +1,92 @@
+#include "cmd_line_opts.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+int co_get_int(int argc, char** argv, const char* text, int* res) {
+	int opt_len = strlen(text);
+	int found = 0;
+
+	int ii;
+	for(ii = 0; ii < argc; ++ii) {
+		if( argv[ii][0] == '-' ) {
+			if(!strncmp(text, argv[ii], opt_len)) {
+				*res = atoi(argv[ii+1]);
+				found = 1;
+				break;
+			}
+
+			else {
+				++ii;
+			}
+		}
+	}
+
+	return found;
+}
+
+int co_get_bool(int argc, char** argv, const char* text, int* res) {
+	int opt_len = strlen(text);
+	int found = 0;
+
+	int ii;
+	for(ii = 0; ii < argc; ++ii) {
+		if( argv[ii][0] == '-' ) {
+			if(!strncmp(text, argv[ii], opt_len)) {
+				*res = 1;
+				found = 1;
+				break;
+			}
+
+			else {
+				++ii;
+			}
+		}
+	}
+
+	return found;
+}
+
+int co_get_float(int argc, char** argv, const char* text, float* res) {
+	int opt_len = strlen(text);
+	int found = 0;
+
+	int ii;
+	for(ii = 0; ii < argc; ++ii) {
+		if( argv[ii][0] == '-' ) {
+			if(!strncmp(text, argv[ii], opt_len)) {
+				*res = atof(argv[ii+1]);
+				found = 1;
+				break;
+			}
+
+			else {
+				++ii;
+			}
+		}
+	}
+
+	return found;
+}
+
+int co_get_string(int argc, char** argv, const char* text, char* * res) {
+	int opt_len = strlen(text);
+	int found = 0;
+
+	int ii;
+	for(ii = 0; ii < argc; ++ii) {
+		if( argv[ii][0] == '-' ) {
+			if(!strncmp(text, argv[ii], opt_len)) {
+				*res = argv[ii+1];
+				found = 1;
+				break;
+			}
+
+			else {
+				++ii;
+			}
+		}
+	}
+
+	return found;
+}
diff --git a/code/train/C/0101271_speakup_decext.c b/code/train/C/0101271_speakup_decext.c
new file mode 100644
index 0000000000000000000000000000000000000000..fa2b4e11a798355e06f4fa626d09998cadcacf83
--- /dev/null
+++ b/code/train/C/0101271_speakup_decext.c
@@ -0,0 +1,242 @@
+/*
+ * originally written by: Kirk Reiser <kirk@braille.uwo.ca>
+* this version considerably modified by David Borowski, david575@rogers.com
+ *
+ * Copyright (C) 1998-99  Kirk Reiser.
+ * Copyright (C) 2003 David Borowski.
+ *
+ * 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.
+ *
+ * specificly written as a driver for the speakup screenreview
+ * s not a general device driver.
+ */
+#include <linux/jiffies.h>
+#include <linux/sched.h>
+#include <linux/timer.h>
+#include <linux/kthread.h>
+
+#include "spk_priv.h"
+#include "serialio.h"
+#include "speakup.h"
+
+#define DRV_VERSION "2.14"
+#define SYNTH_CLEAR 0x03
+#define PROCSPEECH 0x0b
+static unsigned char last_char;
+
+static inline u_char get_last_char(void)
+{
+	u_char avail = inb_p(speakup_info.port_tts + UART_LSR) & UART_LSR_DR;
+
+	if (avail)
+		last_char = inb_p(speakup_info.port_tts + UART_RX);
+	return last_char;
+}
+
+static inline bool synth_full(void)
+{
+	return get_last_char() == 0x13;
+}
+
+static void do_catch_up(struct spk_synth *synth);
+static void synth_flush(struct spk_synth *synth);
+
+static int in_escape;
+
+static struct var_t vars[] = {
+	{ CAPS_START, .u.s = {"[:dv ap 222]" } },
+	{ CAPS_STOP, .u.s = {"[:dv ap 100]" } },
+	{ RATE, .u.n = {"[:ra %d]", 7, 0, 9, 150, 25, NULL } },
+	{ PITCH, .u.n = {"[:dv ap %d]", 100, 0, 100, 0, 0, NULL } },
+	{ VOL, .u.n = {"[:dv gv %d]", 13, 0, 16, 0, 5, NULL } },
+	{ PUNCT, .u.n = {"[:pu %c]", 0, 0, 2, 0, 0, "nsa" } },
+	{ VOICE, .u.n = {"[:n%c]", 0, 0, 9, 0, 0, "phfdburwkv" } },
+	{ DIRECT, .u.n = {NULL, 0, 0, 1, 0, 0, NULL } },
+	V_LAST_VAR
+};
+
+/*
+ * These attributes will appear in /sys/accessibility/speakup/decext.
+ */
+static struct kobj_attribute caps_start_attribute =
+	__ATTR(caps_start, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
+static struct kobj_attribute caps_stop_attribute =
+	__ATTR(caps_stop, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
+static struct kobj_attribute pitch_attribute =
+	__ATTR(pitch, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
+static struct kobj_attribute punct_attribute =
+	__ATTR(punct, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
+static struct kobj_attribute rate_attribute =
+	__ATTR(rate, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
+static struct kobj_attribute voice_attribute =
+	__ATTR(voice, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
+static struct kobj_attribute vol_attribute =
+	__ATTR(vol, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
+
+static struct kobj_attribute delay_time_attribute =
+	__ATTR(delay_time, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
+static struct kobj_attribute direct_attribute =
+	__ATTR(direct, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
+static struct kobj_attribute full_time_attribute =
+	__ATTR(full_time, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
+static struct kobj_attribute jiffy_delta_attribute =
+	__ATTR(jiffy_delta, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
+static struct kobj_attribute trigger_time_attribute =
+	__ATTR(trigger_time, S_IWUSR | S_IRUGO, spk_var_show, spk_var_store);
+
+/*
+ * Create a group of attributes so that we can create and destroy them all
+ * at once.
+ */
+static struct attribute *synth_attrs[] = {
+	&caps_start_attribute.attr,
+	&caps_stop_attribute.attr,
+	&pitch_attribute.attr,
+	&punct_attribute.attr,
+	&rate_attribute.attr,
+	&voice_attribute.attr,
+	&vol_attribute.attr,
+	&delay_time_attribute.attr,
+	&direct_attribute.attr,
+	&full_time_attribute.attr,
+	&jiffy_delta_attribute.attr,
+	&trigger_time_attribute.attr,
+	NULL,	/* need to NULL terminate the list of attributes */
+};
+
+static struct spk_synth synth_decext = {
+	.name = "decext",
+	.version = DRV_VERSION,
+	.long_name = "Dectalk External",
+	.init = "[:pe -380]",
+	.procspeech = PROCSPEECH,
+	.clear = SYNTH_CLEAR,
+	.delay = 500,
+	.trigger = 50,
+	.jiffies = 50,
+	.full = 40000,
+	.flags = SF_DEC,
+	.startup = SYNTH_START,
+	.checkval = SYNTH_CHECK,
+	.vars = vars,
+	.probe = spk_serial_synth_probe,
+	.release = spk_serial_release,
+	.synth_immediate = spk_synth_immediate,
+	.catch_up = do_catch_up,
+	.flush = synth_flush,
+	.is_alive = spk_synth_is_alive_restart,
+	.synth_adjust = NULL,
+	.read_buff_add = NULL,
+	.get_index = NULL,
+	.indexing = {
+		.command = NULL,
+		.lowindex = 0,
+		.highindex = 0,
+		.currindex = 0,
+	},
+	.attributes = {
+		.attrs = synth_attrs,
+		.name = "decext",
+	},
+};
+
+static void do_catch_up(struct spk_synth *synth)
+{
+	u_char ch;
+	static u_char last = '\0';
+	unsigned long flags;
+	unsigned long jiff_max;
+	struct var_t *jiffy_delta;
+	struct var_t *delay_time;
+	int jiffy_delta_val = 0;
+	int delay_time_val = 0;
+
+	jiffy_delta = spk_get_var(JIFFY);
+	delay_time = spk_get_var(DELAY);
+
+	spin_lock_irqsave(&speakup_info.spinlock, flags);
+	jiffy_delta_val = jiffy_delta->u.n.value;
+	spin_unlock_irqrestore(&speakup_info.spinlock, flags);
+	jiff_max = jiffies + jiffy_delta_val;
+
+	while (!kthread_should_stop()) {
+		spin_lock_irqsave(&speakup_info.spinlock, flags);
+		if (speakup_info.flushing) {
+			speakup_info.flushing = 0;
+			spin_unlock_irqrestore(&speakup_info.spinlock, flags);
+			synth->flush(synth);
+			continue;
+		}
+		if (synth_buffer_empty()) {
+			spin_unlock_irqrestore(&speakup_info.spinlock, flags);
+			break;
+		}
+		ch = synth_buffer_peek();
+		set_current_state(TASK_INTERRUPTIBLE);
+		delay_time_val = delay_time->u.n.value;
+		spin_unlock_irqrestore(&speakup_info.spinlock, flags);
+		if (ch == '\n')
+			ch = 0x0D;
+		if (synth_full() || !spk_serial_out(ch)) {
+			schedule_msec_hrtimeout((delay_time_val));
+			continue;
+		}
+		set_current_state(TASK_RUNNING);
+		spin_lock_irqsave(&speakup_info.spinlock, flags);
+		synth_buffer_getc();
+		spin_unlock_irqrestore(&speakup_info.spinlock, flags);
+		if (ch == '[')
+			in_escape = 1;
+		else if (ch == ']')
+			in_escape = 0;
+		else if (ch <= SPACE) {
+			if (!in_escape && strchr(",.!?;:", last))
+				spk_serial_out(PROCSPEECH);
+			if (time_after_eq(jiffies, jiff_max)) {
+				if (!in_escape)
+					spk_serial_out(PROCSPEECH);
+				spin_lock_irqsave(&speakup_info.spinlock,
+							flags);
+				jiffy_delta_val = jiffy_delta->u.n.value;
+				delay_time_val = delay_time->u.n.value;
+				spin_unlock_irqrestore(&speakup_info.spinlock,
+							flags);
+				schedule_timeout(msecs_to_jiffies
+						 (delay_time_val));
+				jiff_max = jiffies + jiffy_delta_val;
+			}
+		}
+		last = ch;
+	}
+	if (!in_escape)
+		spk_serial_out(PROCSPEECH);
+}
+
+static void synth_flush(struct spk_synth *synth)
+{
+	in_escape = 0;
+	spk_synth_immediate(synth, "\033P;10z\033\\");
+}
+
+module_param_named(ser, synth_decext.ser, int, S_IRUGO);
+module_param_named(start, synth_decext.startup, short, S_IRUGO);
+
+MODULE_PARM_DESC(ser, "Set the serial port for the synthesizer (0-based).");
+MODULE_PARM_DESC(start, "Start the synthesizer once it is loaded.");
+
+module_spk_synth(synth_decext);
+
+MODULE_AUTHOR("Kirk Reiser <kirk@braille.uwo.ca>");
+MODULE_AUTHOR("David Borowski");
+MODULE_DESCRIPTION("Speakup support for DECtalk External synthesizers");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
+
diff --git a/code/train/C/0101564_rand.c b/code/train/C/0101564_rand.c
new file mode 100644
index 0000000000000000000000000000000000000000..b02f938c5457a6d3e1a1455494b3303d506329b2
--- /dev/null
+++ b/code/train/C/0101564_rand.c
@@ -0,0 +1,383 @@
+/*
+ * Copyright (c) 2006 - 2007 Kungliga Tekniska Högskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ *
+ * Portions Copyright (c) 2009 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. Neither the name of the Institute 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 INSTITUTE 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 INSTITUTE 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.
+ */
+
+#include <config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <rand.h>
+#include <randi.h>
+
+#include <roken.h>
+
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+
+/**
+ * @page page_rand RAND - random number
+ *
+ * See the library functions here: @ref hcrypto_rand
+ */
+
+const static RAND_METHOD *selected_meth = NULL;
+static ENGINE *selected_engine = NULL;
+
+static void
+init_method(void)
+{
+    if (selected_meth != NULL)
+	return;
+#if defined(_WIN32)
+    selected_meth = &hc_rand_w32crypto_method;
+#elif defined(__APPLE__)
+    selected_meth = &hc_rand_unix_method;
+#else
+    selected_meth = &hc_rand_fortuna_method;
+#endif
+}
+
+/**
+ * Seed that random number generator. Secret material can securely be
+ * feed into the function, they will never be returned.
+ *
+ * @param indata seed data
+ * @param size length seed data
+ *
+ * @ingroup hcrypto_rand
+ */
+
+void
+RAND_seed(const void *indata, size_t size)
+{
+    init_method();
+    (*selected_meth->seed)(indata, size);
+}
+
+/**
+ * Get a random block from the random generator, can be used for key material.
+ *
+ * @param outdata random data
+ * @param size length random data
+ *
+ * @return 1 on success, 0 on failure.
+ *
+ * @ingroup hcrypto_rand
+ */
+int
+RAND_bytes(void *outdata, size_t size)
+{
+    if (size == 0)
+	return 1;
+    init_method();
+    return (*selected_meth->bytes)(outdata, size);
+}
+
+/**
+ * Reset and free memory used by the random generator.
+ *
+ * @ingroup hcrypto_rand
+ */
+
+void
+RAND_cleanup(void)
+{
+    const RAND_METHOD *meth = selected_meth;
+    ENGINE *engine = selected_engine;
+
+    selected_meth = NULL;
+    selected_engine = NULL;
+
+    if (meth)
+	(*meth->cleanup)();
+    if (engine)
+	ENGINE_finish(engine);
+}
+
+/**
+ * Seed that random number generator. Secret material can securely be
+ * feed into the function, they will never be returned.
+ *
+ * @param indata the input data.
+ * @param size size of in data.
+ * @param entropi entropi in data.
+ *
+ *
+ * @ingroup hcrypto_rand
+ */
+
+void
+RAND_add(const void *indata, size_t size, double entropi)
+{
+    init_method();
+    (*selected_meth->add)(indata, size, entropi);
+}
+
+/**
+ * Get a random block from the random generator, should NOT be used for key material.
+ *
+ * @param outdata random data
+ * @param size length random data
+ *
+ * @return 1 on success, 0 on failure.
+ *
+ * @ingroup hcrypto_rand
+ */
+
+int
+RAND_pseudo_bytes(void *outdata, size_t size)
+{
+    init_method();
+    return (*selected_meth->pseudorand)(outdata, size);
+}
+
+/**
+ * Return status of the random generator
+ *
+ * @return 1 if the random generator can deliver random data.
+ *
+ * @ingroup hcrypto_rand
+ */
+
+int
+RAND_status(void)
+{
+    init_method();
+    return (*selected_meth->status)();
+}
+
+/**
+ * Set the default random method.
+ *
+ * @param meth set the new default method.
+ *
+ * @return 1 on success.
+ *
+ * @ingroup hcrypto_rand
+ */
+
+int
+RAND_set_rand_method(const RAND_METHOD *meth)
+{
+    const RAND_METHOD *old = selected_meth;
+    selected_meth = meth;
+    if (old)
+	(*old->cleanup)();
+    if (selected_engine) {
+	ENGINE_finish(selected_engine);
+	selected_engine = NULL;
+    }
+    return 1;
+}
+
+/**
+ * Get the default random method.
+ *
+ * @ingroup hcrypto_rand
+ */
+
+const RAND_METHOD *
+RAND_get_rand_method(void)
+{
+    init_method();
+    return selected_meth;
+}
+
+/**
+ * Set the default random method from engine.
+ *
+ * @param engine use engine, if NULL is passed it, old method and engine is cleared.
+ *
+ * @return 1 on success, 0 on failure.
+ *
+ * @ingroup hcrypto_rand
+ */
+
+int
+RAND_set_rand_engine(ENGINE *engine)
+{
+    const RAND_METHOD *meth, *old = selected_meth;
+
+    if (engine) {
+	ENGINE_up_ref(engine);
+	meth = ENGINE_get_RAND(engine);
+	if (meth == NULL) {
+	    ENGINE_finish(engine);
+	    return 0;
+	}
+    } else {
+	meth = NULL;
+    }
+
+    if (old)
+	(*old->cleanup)();
+
+    if (selected_engine)
+	ENGINE_finish(selected_engine);
+
+    selected_engine = engine;
+    selected_meth = meth;
+
+    return 1;
+}
+
+#define RAND_FILE_SIZE 1024
+
+/**
+ * Load a a file and feed it into RAND_seed().
+ *
+ * @param filename name of file to read.
+ * @param size minimum size to read.
+ *
+ * @ingroup hcrypto_rand
+ */
+
+int
+RAND_load_file(const char *filename, size_t size)
+{
+    unsigned char buf[128];
+    size_t len;
+    ssize_t slen;
+    int fd;
+
+    fd = open(filename, O_RDONLY | O_BINARY, 0600);
+    if (fd < 0)
+	return 0;
+    rk_cloexec(fd);
+    len = 0;
+    while(len < size) {
+	slen = read(fd, buf, sizeof(buf));
+	if (slen <= 0)
+	    break;
+	RAND_seed(buf, slen);
+	len += slen;
+    }
+    close(fd);
+
+    return len ? 1 : 0;
+}
+
+/**
+ * Write of random numbers to a file to store for later initiation with RAND_load_file().
+ *
+ * @param filename name of file to write.
+ *
+ * @return 1 on success and non-one on failure.
+ * @ingroup hcrypto_rand
+ */
+
+int
+RAND_write_file(const char *filename)
+{
+    unsigned char buf[128];
+    size_t len;
+    int res = 0, fd;
+
+    fd = open(filename, O_WRONLY | O_CREAT | O_BINARY, 0600);
+    if (fd < 0)
+	return 0;
+    rk_cloexec(fd);
+
+    len = 0;
+    while(len < RAND_FILE_SIZE) {
+	res = RAND_bytes(buf, sizeof(buf));
+	if (res != 1)
+	    break;
+	if (write(fd, buf, sizeof(buf)) != sizeof(buf)) {
+	    res = 0;
+	    break;
+	}
+	len += sizeof(buf);
+    }
+
+    close(fd);
+
+    return res;
+}
+
+/**
+ * Return the default random state filename for a user to use for
+ * RAND_load_file(), and RAND_write_file().
+ *
+ * @param filename buffer to hold file name.
+ * @param size size of buffer filename.
+ *
+ * @return the buffer filename or NULL on failure.
+ *
+ * @ingroup hcrypto_rand
+ */
+
+const char *
+RAND_file_name(char *filename, size_t size)
+{
+    const char *e = NULL;
+    int pathp = 0, ret;
+
+    if (!issuid()) {
+	e = getenv("RANDFILE");
+	if (e == NULL)
+	    e = getenv("HOME");
+	if (e)
+	    pathp = 1;
+    }
+    /*
+     * Here we really want to call getpwuid(getuid()) but this will
+     * cause recursive lookups if the nss library uses
+     * gssapi/krb5/hcrypto to authenticate to the ldap servers.
+     *
+     * So at least return the unix /dev/random if we have one
+     */
+#ifndef _WIN32
+    if (e == NULL) {
+	int fd;
+
+	fd = _hc_unix_device_fd(O_RDONLY, &e);
+	if (fd >= 0)
+	    close(fd);
+    }
+#endif
+    if (e == NULL)
+	return NULL;
+
+    if (pathp)
+	ret = snprintf(filename, size, "%s/.rnd", e);
+    else
+	ret = snprintf(filename, size, "%s", e);
+
+    if (ret <= 0 || ret >= size)
+	return NULL;
+
+    return filename;
+}
diff --git a/code/train/C/0102632_parse.c b/code/train/C/0102632_parse.c
new file mode 100644
index 0000000000000000000000000000000000000000..e335a7c545c5042b1bd0de01b93349c949ede6b1
--- /dev/null
+++ b/code/train/C/0102632_parse.c
@@ -0,0 +1,281 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <string.h>
+#include <float.h> 
+#include <stdarg.h>
+#include "rnaseq.h"
+
+extern OrigRNASeq * origRNASequences[10];
+extern int parallel;
+
+int myTokenize(char *line, char **strArray1);
+
+int readAndTokenizeRNAs(char **strArray1)
+{
+	int i;
+	printf("Enter sequences: ");
+	
+	/// Use this to input ///
+	char *line___ = NULL;
+	size_t size;
+	int lres = getline(&line___, &size, stdin);
+	char line[500];
+	strcpy(line, line___);
+	line[strlen(line___)-1] = '\0';
+	//////////////////////////
+	
+	strArray1 = (char **) malloc(sizeof(char *) * 10);
+	int numOfRNA = myTokenize(line, strArray1);
+	// printf("num = %d\n", numOfRNA);
+	for(i=0;i<numOfRNA;i++)
+	{
+		origRNASequences[i]->originalLength = strlen(origRNASequences[i]->string);
+		// printf("orig len = %d \n", origRNASequences[i]->originalLength);
+	}	
+	/*
+	for(i=0;i<numOfRNA;i++)
+		printf("seq %d: %s\n", i, origRNASequences[i]->string);
+	*/
+	// printf("Number of RNAs = %d \n", numOfRNA);
+	return numOfRNA;
+}
+
+
+int myTokenize(char *line, char **strArray1)
+{
+	//assume atleast 1 & exists
+	int numOfRNA;
+	char * str = line;
+	char * pch;
+	
+	pch = strtok (str,"&");
+	int i = 0;
+	
+	for (; pch != NULL; i++, pch = strtok (NULL, "&"))
+	{
+		origRNASequences[i]->string = (char*) malloc(sizeof(char) *
+											(strlen(pch)+1));
+		strcpy(origRNASequences[i]->string, pch);
+		origRNASequences[i]->origId = i;
+	}
+	
+	return i;
+}
+
+
+
+void readEvenOdd()
+{
+	printf("Enter even|odd:");
+	//char * line = get_line(stdin);
+	
+	/// Use this to input ///
+	char *line___ = NULL;
+	size_t size;
+	int lres = getline(&line___, &size, stdin);
+	char line[200];
+	strcpy(line, line___);
+	line[strlen(line___)-1] = '\0';
+	//////////////////////////
+
+	
+	int len = strlen(line);
+	
+	int i;
+	int readingType = 0;
+	
+	for(i=0;i<len;i++)
+	{
+		// printf("chr: %c\n", line[i]);
+		switch(line[i])
+		{
+			case '|':
+			{
+				readingType = 1;
+				break;
+			}
+			case ',':
+			{
+				break;
+			}
+			default:
+			{
+				origRNASequences[line[i]-48]->type = readingType;
+				// printf("Read %d, gave type %d \n", line[i]-48, readingType);
+				// printf("Id was %d \n", origRNASequences[line[i]-48]->origId);
+				break;
+			}
+		}
+		
+	}
+	// printf("done\n");
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+void tokenizeNames(int num)
+{
+	printf("Enter names seperated by \'&\' \n" );
+	//char * line = get_line(stdin);
+	
+	/// Use this to input ///
+	char *line___ = NULL;
+	size_t size;
+	int lres = getline(&line___, &size, stdin);
+	char line[200];
+	strcpy(line, line___);
+	line[strlen(line___)-1] = '\0';
+	//////////////////////////
+	
+
+	// assume atleast 1 & exists
+	char * str = line;
+	char * pch = strtok (str,"&");
+	int i = 0;
+	strcpy(origRNASequences[i]->name, pch);
+	i++;
+	
+	while (i < num)
+	{
+		//printf ("%s\n",pch);
+		pch = strtok (NULL, "&");
+		strcpy(origRNASequences[i]->name, pch);
+		i++;
+	}
+}
+
+
+
+
+
+
+int blahblah()
+{
+	int x = 53;
+	return x;
+}
+
+int * blahblahptr()
+{
+	int * p = (int*)malloc(sizeof(int));
+	printf("p ptr = %p\n", p);
+	*p = 65;
+	return p;
+}
+
+
+CmdLineArgs * parseArgs(int argc, char ** argv)
+{
+	CmdLineArgs * args = (CmdLineArgs *)malloc(sizeof(CmdLineArgs));
+	// printf("args ptr = %p\n", args);
+	//default args values:
+	args->parallel = 0;
+	args->k = 2;
+	args->trials = 1;
+	args->fillGaps = 1;
+	args->gapSize = 4;
+	args->winSize = 1;
+	args->GU = 1;
+	strcpy(args->fileName, "default");
+	strcpy(args->rnaupOut, "default");
+
+	int i;
+	int k, t, gbool, gsize, w, gu;
+	for (i=1; i<argc; i++) 
+	{
+		if (argv[i][0]=='-') 
+  			switch ( argv[i][1] )
+			{
+				//parallel
+				case 'p':  
+					args->parallel = 1;
+					break;
+
+				//k
+				case 'k':  
+					k = atoi(argv[i+1]);
+					if(k == 0) {printf("k has to be non zero \n"); exit(-1); }
+					args->k = k ;
+					break;
+	
+				//number of trials
+				case 't':  
+					t = atoi(argv[i+1]);
+					if(t == 0) {printf("t has to be non zero \n"); exit(-1); }
+					args->trials = t ;
+					break;
+				
+				case 'w':  
+					w = atoi(argv[i+1]);
+					if(w < 1 || w > 2) {printf("w has to be 1 or 2 \n"); exit(-1); }
+					args->winSize = w ;
+					break;
+				
+				case 'g':  
+					
+					if(argv[i][2] == 'b')
+					{
+						gbool = atoi(argv[i+1]);
+						args->fillGaps = gbool;
+					}
+					else if(argv[i][2] == 's')
+					{
+						gsize = atoi(argv[i+1]);
+						args->gapSize = gsize;
+					}
+					else if(argv[i][2] == 'u')
+					{
+						gu = atoi(argv[i+1]);
+						args->GU = gu;
+					}
+					break;
+
+				case 'f':
+					printf("here: %s \n", argv[i+1]);
+					strcpy(args->fileName, argv[i+1]);
+				
+				case 'r':
+					printf("rnaup out: %s \n", argv[i+1]);
+					strcpy(args->rnaupOut, argv[i+1]);
+				
+				default: 
+					;
+			} 
+	}
+
+	printf("Using k = %d \n", args->k);
+	printf("Using parallel = %d \n", args->parallel);
+	printf("using trials  = %d \n", args->trials);
+	printf("using gaps  = %d \n", args->fillGaps);
+
+	return args;
+}
+
+
+int getInput(char ** strArray1)
+{
+	int numOfRNA = readAndTokenizeRNAs(strArray1);
+	
+	/** 2. Get the (even|odd) type of each RNA **/
+	tokenizeNames(numOfRNA);
+	
+	
+	readEvenOdd();
+
+	return numOfRNA;
+}
\ No newline at end of file
diff --git a/code/train/C/0102691_process.c b/code/train/C/0102691_process.c
new file mode 100644
index 0000000000000000000000000000000000000000..47b00233fb64cbac90bbb28c3353eac36c6f1f0c
--- /dev/null
+++ b/code/train/C/0102691_process.c
@@ -0,0 +1,263 @@
+/*
+ * drivers/power/process.c - Functions for starting/stopping processes on 
+ *                           suspend transitions.
+ *
+ * Originally from swsusp.
+ */
+
+
+#undef DEBUG
+
+#include <linux/interrupt.h>
+#include <linux/oom.h>
+#include <linux/suspend.h>
+#include <linux/module.h>
+#include <linux/syscalls.h>
+#include <linux/freezer.h>
+#include <linux/delay.h>
+#include <linux/workqueue.h>
+#include <linux/kmod.h>
+#include <linux/wakeup_reason.h>
+/* 
+ * Timeout for stopping processes
+ */
+unsigned int __read_mostly freeze_timeout_msecs = 5 * MSEC_PER_SEC;
+
+static int try_to_freeze_tasks(bool user_only)
+{
+	struct task_struct *g, *p;
+	unsigned long end_time;
+	unsigned int todo;
+	bool wq_busy = false;
+	struct timeval start, end;
+	u64 elapsed_msecs64;
+	unsigned int elapsed_msecs;
+	bool wakeup = false;
+	int sleep_usecs = USEC_PER_MSEC;
+#ifdef CONFIG_PM_SLEEP
+	char suspend_abort[MAX_SUSPEND_ABORT_LEN];
+#endif
+
+	do_gettimeofday(&start);
+
+	end_time = jiffies + msecs_to_jiffies(freeze_timeout_msecs);
+
+	if (!user_only)
+		freeze_workqueues_begin();
+
+	while (true) {
+		todo = 0;
+		read_lock(&tasklist_lock);
+		do_each_thread(g, p) {
+			if (p == current || !freeze_task(p))
+				continue;
+
+			if (!freezer_should_skip(p))
+				todo++;
+		} while_each_thread(g, p);
+		read_unlock(&tasklist_lock);
+
+		if (!user_only) {
+			wq_busy = freeze_workqueues_busy();
+			todo += wq_busy;
+		}
+
+		if (!todo || time_after(jiffies, end_time))
+			break;
+
+		if (pm_wakeup_pending()) {
+#ifdef CONFIG_PM_SLEEP
+			pm_get_active_wakeup_sources(suspend_abort,
+				MAX_SUSPEND_ABORT_LEN);
+			log_suspend_abort_reason(suspend_abort);
+#endif
+			wakeup = true;
+			break;
+		}
+
+		/*
+		 * We need to retry, but first give the freezing tasks some
+		 * time to enter the refrigerator.  Start with an initial
+		 * 1 ms sleep followed by exponential backoff until 8 ms.
+		 */
+		usleep_range(sleep_usecs / 2, sleep_usecs);
+		if (sleep_usecs < 8 * USEC_PER_MSEC)
+			sleep_usecs *= 2;
+	}
+
+	do_gettimeofday(&end);
+	elapsed_msecs64 = timeval_to_ns(&end) - timeval_to_ns(&start);
+	do_div(elapsed_msecs64, NSEC_PER_MSEC);
+	elapsed_msecs = elapsed_msecs64;
+
+	if (wakeup) {
+		printk("\n");
+		printk(KERN_ERR "Freezing of tasks aborted after %d.%03d seconds",
+		       elapsed_msecs / 1000, elapsed_msecs % 1000);
+	} else if (todo) {
+		printk("\n");
+		printk(KERN_ERR "Freezing of tasks failed after %d.%03d seconds"
+		       " (%d tasks refusing to freeze, wq_busy=%d):\n",
+		       elapsed_msecs / 1000, elapsed_msecs % 1000,
+		       todo - wq_busy, wq_busy);
+
+		read_lock(&tasklist_lock);
+		do_each_thread(g, p) {
+			if (p != current && !freezer_should_skip(p)
+			    && freezing(p) && !frozen(p))
+				sched_show_task(p);
+		} while_each_thread(g, p);
+		read_unlock(&tasklist_lock);
+	} else {
+		printk("(elapsed %d.%03d seconds) ", elapsed_msecs / 1000,
+			elapsed_msecs % 1000);
+	}
+
+	return todo ? -EBUSY : 0;
+}
+
+static bool __check_frozen_processes(void)
+{
+	struct task_struct *g, *p;
+
+	for_each_process_thread(g, p)
+		if (p != current && !freezer_should_skip(p) && !frozen(p))
+			return false;
+
+	return true;
+}
+
+/*
+ * Returns true if all freezable tasks (except for current) are frozen already
+ */
+static bool check_frozen_processes(void)
+{
+	bool ret;
+
+	read_lock(&tasklist_lock);
+	ret = __check_frozen_processes();
+	read_unlock(&tasklist_lock);
+	return ret;
+}
+
+/**
+ * freeze_processes - Signal user space processes to enter the refrigerator.
+ *
+ * On success, returns 0.  On failure, -errno and system is fully thawed.
+ */
+int freeze_processes(void)
+{
+	int error;
+	int oom_kills_saved;
+
+	error = __usermodehelper_disable(UMH_FREEZING);
+	if (error)
+		return error;
+
+	if (!pm_freezing)
+		atomic_inc(&system_freezing_cnt);
+
+	pm_wakeup_clear();
+	printk("Freezing user space processes ... ");
+	pm_freezing = true;
+	oom_kills_saved = oom_kills_count();
+	error = try_to_freeze_tasks(true);
+	if (!error) {
+		__usermodehelper_set_disable_depth(UMH_DISABLED);
+		oom_killer_disable();
+
+		/*
+		 * There might have been an OOM kill while we were
+		 * freezing tasks and the killed task might be still
+		 * on the way out so we have to double check for race.
+		 */
+		if (oom_kills_count() != oom_kills_saved &&
+		    !check_frozen_processes()) {
+			__usermodehelper_set_disable_depth(UMH_ENABLED);
+			printk("OOM in progress.");
+			error = -EBUSY;
+		} else {
+			printk("done.");
+		}
+	}
+	printk("\n");
+	BUG_ON(in_atomic());
+
+	if (error)
+		thaw_processes();
+	return error;
+}
+
+/**
+ * freeze_kernel_threads - Make freezable kernel threads go to the refrigerator.
+ *
+ * On success, returns 0.  On failure, -errno and only the kernel threads are
+ * thawed, so as to give a chance to the caller to do additional cleanups
+ * (if any) before thawing the userspace tasks. So, it is the responsibility
+ * of the caller to thaw the userspace tasks, when the time is right.
+ */
+int freeze_kernel_threads(void)
+{
+	int error;
+
+	printk("Freezing remaining freezable tasks ... ");
+	pm_nosig_freezing = true;
+	error = try_to_freeze_tasks(false);
+	if (!error)
+		printk("done.");
+
+	printk("\n");
+	BUG_ON(in_atomic());
+
+	if (error)
+		thaw_kernel_threads();
+	return error;
+}
+
+void thaw_processes(void)
+{
+	struct task_struct *g, *p;
+
+	if (pm_freezing)
+		atomic_dec(&system_freezing_cnt);
+	pm_freezing = false;
+	pm_nosig_freezing = false;
+
+	oom_killer_enable();
+
+	printk("Restarting tasks ... ");
+
+	__usermodehelper_set_disable_depth(UMH_FREEZING);
+	thaw_workqueues();
+
+	read_lock(&tasklist_lock);
+	do_each_thread(g, p) {
+		__thaw_task(p);
+	} while_each_thread(g, p);
+	read_unlock(&tasklist_lock);
+
+	usermodehelper_enable();
+
+	schedule();
+	printk("done.\n");
+}
+
+void thaw_kernel_threads(void)
+{
+	struct task_struct *g, *p;
+
+	pm_nosig_freezing = false;
+	printk("Restarting kernel threads ... ");
+
+	thaw_workqueues();
+
+	read_lock(&tasklist_lock);
+	do_each_thread(g, p) {
+		if (p->flags & (PF_KTHREAD | PF_WQ_WORKER))
+			__thaw_task(p);
+	} while_each_thread(g, p);
+	read_unlock(&tasklist_lock);
+
+	schedule();
+	printk("done.\n");
+}
diff --git a/code/train/C/0103430_test.c b/code/train/C/0103430_test.c
new file mode 100644
index 0000000000000000000000000000000000000000..f687cb2f1df5943c173650efeba359b5dca014f4
--- /dev/null
+++ b/code/train/C/0103430_test.c
@@ -0,0 +1,251 @@
+/*
+ * 3pi-linefollower-pid - demo code for the Pololu 3pi Robot
+ * 
+ * This code will follow a black line on a white background, using a
+ * PID-based algorithm.
+ *
+ * http://www.pololu.com/docs/0J21
+ * http://www.pololu.com
+ * http://forum.pololu.com
+ *
+ */
+
+// The 3pi include file must be at the beginning of any program that
+// uses the Pololu AVR library and 3pi.
+#include <pololu/3pi.h>
+
+// This include file allows data to be stored in program space.  The
+// ATmega168 has 16k of program space compared to 1k of RAM, so large
+// pieces of static data should be stored in program space.
+#include <avr/pgmspace.h>
+
+// Introductory messages.  The "PROGMEM" identifier causes the data to
+// go into program space.
+const char welcome_line1[] PROGMEM = " Pololu";
+const char welcome_line2[] PROGMEM = "3\xf7 Robot";
+const char demo_name_line1[] PROGMEM = "PID Line";
+const char demo_name_line2[] PROGMEM = "follower";
+
+// A couple of simple tunes, stored in program space.
+const char welcome[] PROGMEM = ">g32>>c32";
+const char go[] PROGMEM = "L16 cdegreg4";
+
+// Data for generating the characters used in load_custom_characters
+// and display_readings.  By reading levels[] starting at various
+// offsets, we can generate all of the 7 extra characters needed for a
+// bargraph.  This is also stored in program space.
+const char levels[] PROGMEM = {
+	0b00000,
+	0b00000,
+	0b00000,
+	0b00000,
+	0b00000,
+	0b00000,
+	0b00000,
+	0b11111,
+	0b11111,
+	0b11111,
+	0b11111,
+	0b11111,
+	0b11111,
+	0b11111
+};
+
+// This function loads custom characters into the LCD.  Up to 8
+// characters can be loaded; we use them for 7 levels of a bar graph.
+void load_custom_characters()
+{
+	lcd_load_custom_character(levels+0,0); // no offset, e.g. one bar
+	lcd_load_custom_character(levels+1,1); // two bars
+	lcd_load_custom_character(levels+2,2); // etc...
+	lcd_load_custom_character(levels+3,3);
+	lcd_load_custom_character(levels+4,4);
+	lcd_load_custom_character(levels+5,5);
+	lcd_load_custom_character(levels+6,6);
+	clear(); // the LCD must be cleared for the characters to take effect
+}
+
+// This function displays the sensor readings using a bar graph.
+void display_readings(const unsigned int *calibrated_values)
+{
+	unsigned char i;
+
+	for(i=0;i<5;i++) {
+		// Initialize the array of characters that we will use for the
+		// graph.  Using the space, an extra copy of the one-bar
+		// character, and character 255 (a full black box), we get 10
+		// characters in the array.
+		const char display_characters[10] = {' ',0,0,1,2,3,4,5,6,255};
+
+		// The variable c will have values from 0 to 9, since
+		// calibrated values are in the range of 0 to 1000, and
+		// 1000/101 is 9 with integer math.
+		char c = display_characters[calibrated_values[i]/101];
+
+		// Display the bar graph character.
+		print_character(c);
+	}
+}
+
+// Initializes the 3pi, displays a welcome message, calibrates, and
+// plays the initial music.
+void initialize()
+{
+	unsigned int counter; // used as a simple timer
+	unsigned int sensors[5]; // an array to hold sensor values
+
+	// This must be called at the beginning of 3pi code, to set up the
+	// sensors.  We use a value of 2000 for the timeout, which
+	// corresponds to 2000*0.4 us = 0.8 ms on our 20 MHz processor.
+	pololu_3pi_init(2000);
+	load_custom_characters(); // load the custom characters
+	
+	// Play welcome music and display a message
+	print_from_program_space(welcome_line1);
+	lcd_goto_xy(0,1);
+	print_from_program_space(welcome_line2);
+	play_from_program_space(welcome);
+	delay_ms(1000);
+
+	clear();
+	print_from_program_space(demo_name_line1);
+	lcd_goto_xy(0,1);
+	print_from_program_space(demo_name_line2);
+	delay_ms(1000);
+
+	// Display battery voltage and wait for button press
+	while(!button_is_pressed(BUTTON_B))
+	{
+		int bat = read_battery_millivolts();
+
+		clear();
+		print_long(bat);
+		print("mV");
+		lcd_goto_xy(0,1);
+		print("Press B");
+
+		delay_ms(100);
+	}
+
+	// Always wait for the button to be released so that 3pi doesn't
+	// start moving until your hand is away from it.
+	wait_for_button_release(BUTTON_B);
+	delay_ms(1000);
+
+	// Auto-calibration: turn right and left while calibrating the
+	// sensors.
+	for(counter=0;counter<80;counter++)
+	{
+		if(counter < 20 || counter >= 60)
+			set_motors(40,-40);
+		else
+			set_motors(-40,40);
+
+		// This function records a set of sensor readings and keeps
+		// track of the minimum and maximum values encountered.  The
+		// IR_EMITTERS_ON argument means that the IR LEDs will be
+		// turned on during the reading, which is usually what you
+		// want.
+		calibrate_line_sensors(IR_EMITTERS_ON);
+
+		// Since our counter runs to 80, the total delay will be
+		// 80*20 = 1600 ms.
+		delay_ms(20);
+	}
+	set_motors(0,0);
+
+	// Display calibrated values as a bar graph.
+	while(!button_is_pressed(BUTTON_B))
+	{
+		// Read the sensor values and get the position measurement.
+		unsigned int position = read_line(sensors,IR_EMITTERS_ON);
+
+		// Display the position measurement, which will go from 0
+		// (when the leftmost sensor is over the line) to 4000 (when
+		// the rightmost sensor is over the line) on the 3pi, along
+		// with a bar graph of the sensor readings.  This allows you
+		// to make sure the robot is ready to go.
+		clear();
+		print_long(position);
+		lcd_goto_xy(0,1);
+		display_readings(sensors);
+
+		delay_ms(100);
+	}
+	wait_for_button_release(BUTTON_B);
+
+	clear();
+
+	print("Go!");		
+
+	// Play music and wait for it to finish before we start driving.
+	play_from_program_space(go);
+	while(is_playing());
+}
+
+// This is the main function, where the code starts.  All C programs
+// must have a main() function defined somewhere.
+int main()
+{
+	unsigned int sensors[5]; // an array to hold sensor values
+	unsigned int last_proportional=0;
+	long integral=0;
+
+	// set up the 3pi
+	initialize();
+
+	// This is the "main loop" - it will run forever.
+	while(1)
+	{
+		// Get the position of the line.  Note that we *must* provide
+		// the "sensors" argument to read_line() here, even though we
+		// are not interested in the individual sensor readings.
+		unsigned int position = read_line(sensors,IR_EMITTERS_ON);
+
+		// The "proportional" term should be 0 when we are on the line.
+		int proportional = ((int)position) - 2000;
+
+		// Compute the derivative (change) and integral (sum) of the
+		// position.
+		int derivative = proportional - last_proportional;
+		integral += proportional;
+
+		// Remember the last position.
+		last_proportional = proportional;
+
+		// Compute the difference between the two motor power settings,
+		// m1 - m2.  If this is a positive number the robot will turn
+		// to the right.  If it is a negative number, the robot will
+		// turn to the left, and the magnitude of the number determines
+		// the sharpness of the turn.
+		int power_difference = proportional/20 + integral/10000 + derivative*3/2;
+
+		// Compute the actual motor settings.  We never set either motor
+		// to a negative value.
+		const int max = 60;
+		if(power_difference > max)
+			power_difference = max;
+		if(power_difference < -max)
+			power_difference = -max;
+
+		if(power_difference < 0)
+			set_motors(max+power_difference, max);
+		else
+			set_motors(max, max-power_difference);
+	}
+
+	// This part of the code is never reached.  A robot should
+	// never reach the end of its program, or unpredictable behavior
+	// will result as random code starts getting executed.  If you
+	// really want to stop all actions at some point, set your motors
+	// to 0,0 and run the following command to loop forever:
+	//
+	// while(1);
+}
+
+// Local Variables: **
+// mode: C **
+// c-basic-offset: 4 **
+// tab-width: 4 **
+// indent-tabs-mode: t **
+// end: **
diff --git a/code/train/C/0103692_qsort.c b/code/train/C/0103692_qsort.c
new file mode 100644
index 0000000000000000000000000000000000000000..91d77bcbe95d9d4e481c20d132682d8b7db6b8af
--- /dev/null
+++ b/code/train/C/0103692_qsort.c
@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef VECTOR_SIZE
+#define VECTOR_SIZE 100
+#endif
+
+
+int cmpfunc (const void * a, const void * b)
+{
+   return ( *(int*)a - *(int*)b );
+}
+
+
+void qsort_lib(int a[], int n) {
+
+  qsort(a, n, sizeof(int), cmpfunc);
+
+} /* stdlib qsort */
+
+
+int init_vector(int vect[]) {
+    for (int i = 0; i < VECTOR_SIZE; ++i ) {
+      vect[i] = rand() % 100;
+    }
+    return 0;
+}
+
+
+int main(int argc, char** argv) {
+  int vector[VECTOR_SIZE];
+
+  init_vector(vector);
+
+  qsort_lib(vector, VECTOR_SIZE);
+
+  for(int i = 1; i < VECTOR_SIZE; i++) {
+    if (vector[i] < vector[i - 1]) {
+      return 1;
+    }
+  }
+
+  return 0;
+}
diff --git a/code/train/C/0104583_mtest01.c b/code/train/C/0104583_mtest01.c
new file mode 100644
index 0000000000000000000000000000000000000000..dc960a83aba423e09d87215ad066576f9ed42aad
--- /dev/null
+++ b/code/train/C/0104583_mtest01.c
@@ -0,0 +1,280 @@
+/*
+ *
+ *   Copyright (c) International Business Machines  Corp., 2001
+ *
+ *   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		: mtest01.c
+ *  DESCRIPTION : mallocs memory <chunksize> at a time until malloc fails.
+ *  HISTORY:
+ *	04/10/2001 Paul Larson (plars@us.ibm.com)
+ *	  written
+ *	11/09/2001 Manoj Iyer (manjo@austin.ibm.com)
+ *	  Modified.
+ *	  - Removed compile warnings.
+ *	  - Added header file #include <unistd.h> definition for getopt()
+ *	05/13/2003 Robbie Williamson (robbiew@us.ibm.com)
+ *	  Modified.
+ *	  - Rewrote the test to be able to execute on large memory machines.
+ *
+ */
+
+#include <sys/types.h>
+#include <sys/sysinfo.h>
+#include <sys/wait.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "test.h"
+
+#define FIVE_HUNDRED_MB (unsigned long long)(500*1024*1024)
+#define ONE_GB	(unsigned long long)(1024*1024*1024)
+#define THREE_GB (unsigned long long)(3*ONE_GB)
+
+char *TCID = "mtest01";
+int TST_TOTAL = 1;
+int pid_count = 0;
+
+void handler(int signo)
+{
+	pid_count++;
+}
+
+int main(int argc, char* argv[])
+{
+	int c;
+	char *mem;
+	float percent;
+	unsigned int maxpercent = 0, dowrite = 0, verbose=0, j;
+	unsigned long bytecount, alloc_bytes, max_pids;
+	unsigned long long original_maxbytes, maxbytes = 0;
+	unsigned long long pre_mem = 0, post_mem = 0;
+	unsigned long long total_ram, total_free, D, C;
+	int chunksize = 1024*1024; /* one meg at a time by default */
+	struct sysinfo sstats;
+	int i, pid_cntr;
+	pid_t pid, *pid_list;
+	struct sigaction act;
+
+	act.sa_handler = handler;
+	act.sa_flags = 0;
+	sigemptyset(&act.sa_mask);
+	sigaction(SIGRTMIN,  &act, 0);
+	
+	while ((c = getopt(argc, argv, "c:b:p:wvh")) != -1) {
+		switch(c) {
+		case 'c':
+			chunksize = atoi(optarg);
+			break;
+		case 'b':
+			if (maxpercent != 0)
+				tst_brkm(TBROK, NULL,
+				    "ERROR: -b option cannot be used with -p "
+				    "option at the same time");
+			maxbytes = atoll(optarg);
+			break;
+		case 'p':
+			if (maxbytes != 0)
+				tst_brkm(TBROK, NULL,
+				    "ERROR: -p option cannot be used with -b "
+				    "option at the same time");
+			maxpercent = atoi(optarg);
+			if (maxpercent <= 0)
+				tst_brkm(TBROK, NULL,
+				    "ERROR: -p option requires number greater "
+				    "than 0");
+			if (maxpercent > 99)
+				tst_brkm(TBROK, NULL,
+				    "ERROR: -p option cannot be greater than "
+				    "99");
+			break;
+		case 'w':
+			dowrite = 1;
+			break;
+		case 'v':
+			verbose = 1;
+			break;
+		case 'h':
+		default:
+			printf("usage: %s [-c <bytes>] [-b <bytes>|-p <percent>] [-v]\n", argv[0]);
+			printf("\t-c <num>\tsize of chunk in bytes to malloc on each pass\n");
+			printf("\t-b <bytes>\tmaximum number of bytes to allocate before stopping\n");
+			printf("\t-p <bytes>\tpercent of total memory used at which the program stops\n");
+			printf("\t-w\t\twrite to the memory after allocating\n");
+			printf("\t-v\t\tverbose\n");
+			printf("\t-h\t\tdisplay usage\n");
+			exit(1);
+		}
+	}
+	
+	sysinfo(&sstats);
+	total_ram = sstats.totalram + sstats.totalswap; 
+	total_free = sstats.freeram + sstats.freeswap;
+	/* Total Free Pre-Test RAM */
+	pre_mem = sstats.mem_unit * total_free;   
+	max_pids = total_ram / (unsigned long)FIVE_HUNDRED_MB + 1;
+ 
+	if ((pid_list = malloc(max_pids * sizeof(pid_t))) == NULL)
+		tst_brkm(TBROK|TERRNO, NULL, "malloc failed.");
+	memset(pid_list, 0, max_pids * sizeof(pid_t));
+	
+	/* Currently used memory */
+	C = sstats.mem_unit * (total_ram - total_free);
+	tst_resm(TINFO, "Total memory already used on system = %llu kbytes",
+	    C / 1024);
+	
+	if (maxpercent) {
+		percent = (float)maxpercent / 100.00;
+
+		/* Desired memory needed to reach maxpercent */
+		D = percent * (sstats.mem_unit * total_ram);
+		tst_resm(TINFO,
+		    "Total memory used needed to reach maximum = %llu kbytes",
+		    D / 1024);
+		
+		/* Are we already using more than maxpercent? */
+		if (C > D) {
+			tst_resm(TFAIL,
+			    "More memory than the maximum amount you specified "
+			    " is already being used");
+			free(pid_list);
+			tst_exit();
+		}
+		
+		/* set maxbytes to the extra amount we want to allocate */
+		maxbytes = D - C;
+		tst_resm(TINFO, "Filling up %d%% of ram which is %llu kbytes",
+		    maxpercent, maxbytes / 1024);
+	}
+	original_maxbytes = maxbytes;
+	i = 0;
+	pid_cntr = 0;
+	pid = fork();
+	if (pid != 0)
+		pid_cntr++;
+	pid_list[i] = pid;
+
+#if defined (_s390_) /* s390's 31bit addressing requires smaller chunks */
+	while (pid != 0 && maxbytes > FIVE_HUNDRED_MB) {
+		i++;
+		maxbytes -= FIVE_HUNDRED_MB;
+		pid = fork();
+		if (pid != 0) {
+			pid_cntr++;
+			pid_list[i] = pid;
+		}
+	}
+	if (maxbytes > FIVE_HUNDRED_MB)
+		alloc_bytes = FIVE_HUNDRED_MB;
+	else
+		alloc_bytes = (unsigned long) maxbytes;
+	
+#elif __WORDSIZE == 32
+	while (pid != 0 && maxbytes > ONE_GB) {
+		i++;
+		maxbytes -= ONE_GB;
+		pid = fork();
+		if (pid != 0) {
+			pid_cntr++;
+			pid_list[i]=pid;
+		}
+	}
+	if (maxbytes > ONE_GB)
+		alloc_bytes = ONE_GB;
+	else
+		alloc_bytes = (unsigned long)maxbytes;
+	
+#elif __WORDSIZE == 64
+	while (pid != 0 && maxbytes > THREE_GB) {
+		i++;
+		maxbytes -= THREE_GB;
+		pid = fork();
+		if (pid != 0) {
+			pid_cntr++;
+			pid_list[i] = pid;
+		}
+	}
+	if (maxbytes > THREE_GB)
+		alloc_bytes = THREE_GB;
+	else
+		alloc_bytes = maxbytes;
+#endif
+
+	if (pid == 0) {
+		bytecount = chunksize;
+		while (1) {
+			if ((mem = malloc(chunksize)) == NULL) {
+				tst_resm(TBROK|TERRNO,
+				    "stopped at %lu bytes", bytecount);
+				free(pid_list);
+				tst_exit();
+			}
+			if (dowrite)
+				for (j = 0; j < chunksize; j++)
+					*(mem+j) = 'a';
+			if (verbose)
+				tst_resm(TINFO,
+				    "allocated %lu bytes chunksize is %d",
+				    bytecount, chunksize);
+			bytecount += chunksize;
+			if (alloc_bytes && bytecount >= alloc_bytes)
+				break;
+		}
+		if (dowrite)
+			tst_resm(TINFO, "... %lu bytes allocated and used.",
+			    bytecount);
+		else
+			tst_resm(TINFO, "... %lu bytes allocated only.",
+			    bytecount);
+		kill(getppid(), SIGRTMIN);
+		while (1)
+			sleep(1);
+	} else {
+		i = 0;
+		sysinfo(&sstats);
+		
+		if (dowrite) {
+			/* Total Free Post-Test RAM */
+			post_mem = (unsigned long long)sstats.mem_unit * sstats.freeram;
+			post_mem = post_mem + (unsigned long long)sstats.mem_unit * sstats.freeswap;
+
+			while ((((unsigned long long)pre_mem - post_mem) <
+			    (unsigned long long)original_maxbytes) &&
+			    pid_count < pid_cntr) {
+				sleep(1);
+				sysinfo(&sstats);
+				post_mem = (unsigned long long)sstats.mem_unit * sstats.freeram;
+				post_mem = post_mem + (unsigned long long)sstats.mem_unit * sstats.freeswap;
+			}
+		}
+		while (pid_list[i] != 0) {
+			kill(pid_list[i], SIGKILL);
+			i++;
+		}
+		if (dowrite)
+			tst_resm(TPASS, "%llu kbytes allocated and used.",
+			    original_maxbytes / 1024);
+		else
+			tst_resm(TPASS, "%llu kbytes allocated only.",
+			    original_maxbytes / 1024);
+	}
+	free(pid_list);
+	tst_exit();
+}
diff --git a/code/train/C/0104895_crosscorr.c b/code/train/C/0104895_crosscorr.c
new file mode 100644
index 0000000000000000000000000000000000000000..41a6de9ec8ab1d6e3c95241b4c7c0c1476ea1778
--- /dev/null
+++ b/code/train/C/0104895_crosscorr.c
@@ -0,0 +1,74 @@
+/* crosscorr.c: MEX file that calculates cross correlation of two time 
+ * series (x,y)
+ *
+ * rxy = crosscorr(x,y)
+ *
+ */
+
+#include "mex.h"
+#include "math.h"
+
+void mexFunction( int nlhs, mxArray *plhs[],
+                  int nrhs, const mxArray *prhs[])
+{
+  double sum_x, sum_y, mean_x, mean_y;
+  double dx, dy;
+  double sum_sq_x, sum_sq_y, sum_coproduct;
+  double *x, *y, *rxy;
+  int mrowsX,ncolsX,mrowsY,ncolsY;
+  int i;
+
+  /* Check for proper number of arguments. */
+  if(nrhs!=2) {
+  //  mexErrMsgTxt("Two input required.");
+  } else if(nlhs>1) {
+  //  mexErrMsgTxt("Too many output arguments");
+  } 
+  
+  /* The get size of inputs.*/
+  mrowsX = mxGetM(prhs[0]);
+  ncolsX = mxGetN(prhs[0]);
+  mrowsY = mxGetM(prhs[1]);
+  ncolsY = mxGetN(prhs[1]);
+  
+  /* Check input vector sizes */
+  if(mrowsX!=mrowsY) {
+    //mexErrMsgTxt("Input vectors must be the same length.");
+  } else if( (mrowsX<ncolsX) || (mrowsY<ncolsY) ) {
+    //mexErrMsgTxt("Inputs must be in vector format (Mx1)");  
+  }
+  
+  /* Create matrix for the return argument. */
+  plhs[0] = mxCreateDoubleMatrix(1,1, mxREAL);
+  
+  /*  create a pointer to the input matrix y1 and y2 */
+  x = mxGetPr(prhs[0]);
+  y = mxGetPr(prhs[1]);
+  
+  /* Assign pointers to output. */
+  rxy = mxGetPr(plhs[0]);
+  
+  /* Get Mean x,y */
+  sum_y=0; sum_x=0;
+  for(i=0; i<=mrowsX-1; i++){
+    sum_x += x[i];
+    sum_y += y[i];
+  } 
+  
+  mean_x = sum_x/mrowsX;
+  mean_y = sum_y/mrowsX;
+  
+  /* Calculate Correlation */
+  sum_sq_x=0;
+  sum_sq_y=0;
+  sum_coproduct=0;
+  for(i=0; i<=mrowsX-1; i++)
+  {
+      dx=x[i]-mean_x;
+      dy=y[i]-mean_y;
+      sum_sq_x += (dx*dx);
+      sum_sq_y += (dy*dy);
+      sum_coproduct += (dx*dy);   
+  }
+  rxy[0] = sum_coproduct/sqrt(sum_sq_x * sum_sq_y);
+}
diff --git a/code/train/C/0105439_rfc2198_sim_tests.c b/code/train/C/0105439_rfc2198_sim_tests.c
new file mode 100644
index 0000000000000000000000000000000000000000..ecb124048a1e450084f2838b24efe04890abf6b2
--- /dev/null
+++ b/code/train/C/0105439_rfc2198_sim_tests.c
@@ -0,0 +1,242 @@
+/*
+ * SpanDSP - a series of DSP components for telephony
+ *
+ * rfc2198_sim_tests.c - Tests for the G.1050/TIA-921 model
+ *                       with redundant transmission in the
+ *                       style of UDPTL or RFC2198..
+ *
+ * Written by Steve Underwood <steveu@coppice.org>
+ *
+ * Copyright (C) 2007 Steve Underwood
+ *
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2, as
+ * published by the Free Software Foundation.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: rfc2198_sim_tests.c,v 1.7 2009/05/30 15:23:14 steveu Exp $
+ */
+
+#if defined(HAVE_CONFIG_H)
+#include "config.h"
+#endif
+
+#if defined(HAVE_FL_FL_H)  &&  defined(HAVE_FL_FL_CARTESIAN_H)  &&  defined(HAVE_FL_FL_AUDIO_METER_H)
+#define ENABLE_GUI
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <time.h>
+#include <sndfile.h>
+#if defined(HAVE_MATH_H)
+#define GEN_CONST
+#endif
+
+//#if defined(WITH_SPANDSP_INTERNALS)
+#define SPANDSP_EXPOSE_INTERNAL_STRUCTURES
+//#endif
+
+#include "spandsp.h"
+#include "spandsp-sim.h"
+
+#if defined(ENABLE_GUI)
+#include "media_monitor.h"
+#endif
+
+#define PACKET_SIZE                 256
+#define PACKET_INTERVAL             20
+#define SIMULATION_TIME             300
+
+#define MODEL_NO                    8
+#define SPEED_PATTERN_NO            133
+
+int main(int argc, char *argv[])
+{
+    rfc2198_sim_state_t *s;
+    double *packet_arrival_times;
+    int packets_per_sec;
+    int num_packets;
+    int model_no;
+    int speed_pattern_no;
+    int use_gui;
+    int simulation_time;
+    int i;
+    int len;
+    uint8_t put_pkt[256];
+    uint8_t get_pkt[256];
+    int put_pkt_len;
+    int get_pkt_len;
+    int get_seq_no;
+    double get_departure_time;
+    double get_arrival_time;
+    int packets_put;
+    int packets_really_put;
+    int packets_got;
+    int oos_packets_got;
+    int missing_packets_got;
+    int highest_seq_no_got;
+    int opt;
+    FILE *out_file;
+
+    model_no = MODEL_NO;
+    speed_pattern_no = SPEED_PATTERN_NO;
+    simulation_time = SIMULATION_TIME;
+    use_gui = FALSE;
+    while ((opt = getopt(argc, argv, "gm:s:t:")) != -1)
+    {
+        switch (opt)
+        {
+        case 'g':
+#if defined(ENABLE_GUI)
+            use_gui = TRUE;
+#else
+            fprintf(stderr, "Graphical monitoring not available\n");
+            exit(2);
+#endif
+            break;
+        case 'm':
+            model_no = optarg[0] - 'A' + 1;
+            if (model_no < 0  ||  model_no > 8)
+            {
+                fprintf(stderr, "Bad model ID '%s'\n", optarg);
+                exit(2);
+            }
+            break;
+        case 's':
+            speed_pattern_no = atoi(optarg);
+            if (speed_pattern_no < 1  ||  speed_pattern_no > 133)
+            {
+                fprintf(stderr, "Bad link speed pattern %s\n", optarg);
+                exit(2);
+            }
+            break;
+        case 't':
+            simulation_time = atoi(optarg);
+            break;
+        default:
+            //usage();
+            exit(2);
+            break;
+        }
+    }
+    argc -= optind;
+    argv += optind;
+
+    if ((out_file = fopen("rfc2198_sim_tests.txt", "w")) == NULL)
+    {
+        fprintf(stderr, "Can't open %s\n", "rfc2198_sim_tests.txt");
+        return 2;
+    }
+    packets_per_sec = 1000/PACKET_INTERVAL;
+    num_packets = packets_per_sec*simulation_time;
+
+    if ((packet_arrival_times = calloc(num_packets, sizeof(double))) == NULL)
+    {
+        fprintf(stderr, "Can't allocate the data buffers\n");
+        return 2;
+    }
+    for (i = 0;  i < num_packets;  i++)
+        packet_arrival_times[i] = 0.0;
+
+    /* If we don't initialise this random number generator it gives endless zeros on some systems. */
+    /* Use a fixed seed to produce identical results in successive runs of the simulation, for debug purposes. */
+    srand48(0x1234567);
+
+    if ((s = rfc2198_sim_init(model_no, speed_pattern_no, PACKET_SIZE, packets_per_sec, 3)) == NULL)
+    {
+        fprintf(stderr, "Failed to start the G.1050 model\n");
+        exit(2);
+    }
+    //rfc2198_sim_dump_parms(model_no, speed_pattern_no);
+
+#if defined(ENABLE_GUI)
+    if (use_gui)
+        start_media_monitor();
+#endif
+
+    for (i = 0;  i < 256;  i++)
+        put_pkt[i] = i;
+    put_pkt_len = 256;
+    get_pkt_len = -1;
+    get_seq_no = -1;
+    get_arrival_time = -1;
+    packets_put = 0;
+    packets_really_put = 0;
+    packets_got = 0;
+    oos_packets_got = 0;
+    missing_packets_got = 0;
+    highest_seq_no_got = -1;
+    for (i = 0;  i < num_packets;  i++)
+    {
+        if ((len = rfc2198_sim_put(s, put_pkt, put_pkt_len, i, (double) i*0.001*PACKET_INTERVAL)) > 0)
+            packets_really_put++;
+        packets_put++;
+#if 0        
+        if (i == 5)
+            rfc2198_sim_queue_dump(s);
+#endif
+        if (i >= 5)
+        {
+            do
+            {
+                get_pkt_len = rfc2198_sim_get(s, get_pkt, 256, (double) i*0.001*PACKET_INTERVAL, &get_seq_no, &get_departure_time, &get_arrival_time);
+                if (get_pkt_len >= 0)
+                {
+#if defined(ENABLE_GUI)
+                    if (use_gui)
+                        media_monitor_rx(get_seq_no, get_departure_time, get_arrival_time);
+#endif
+                    packets_got++;
+                    if (get_seq_no < highest_seq_no_got)
+                        oos_packets_got++;
+                    else if (get_seq_no > highest_seq_no_got + 1)
+                        missing_packets_got += (get_seq_no - highest_seq_no_got - 1);
+                    if (get_seq_no > highest_seq_no_got)
+                        highest_seq_no_got = get_seq_no;
+                    fprintf(out_file, "%d, %.3f, %.8f\n", get_seq_no, get_seq_no*0.001*PACKET_INTERVAL, get_arrival_time);
+                }
+            }
+            while (get_pkt_len >= 0);
+        }
+#if defined(ENABLE_GUI)
+        if (use_gui)
+            media_monitor_update_display();
+#endif
+    }
+    /* Clear out anything remaining in the queue, by jumping forwards in time */
+    do
+    {
+        get_pkt_len = rfc2198_sim_get(s, get_pkt, 256, (double) i*0.001*PACKET_INTERVAL + 5.0, &get_seq_no, &get_departure_time, &get_arrival_time);
+        if (get_pkt_len >= 0)
+        {
+            packets_got++;
+            fprintf(out_file, "%d, %.3f, %.8f\n", get_seq_no, get_seq_no*0.001*PACKET_INTERVAL, get_arrival_time);
+        }
+    }
+    while (get_pkt_len >= 0);
+
+    fclose(out_file);
+
+    printf("Put %d packets. Really put %d packets. Got %d packets.\n", packets_put, packets_really_put, packets_got);
+    printf("%d OOS packets, %d missing packets\n", oos_packets_got, missing_packets_got - oos_packets_got);
+    printf("%d packets queued, %d received\n", packets_really_put, packets_got);
+    printf("%.3f%% of packets lost before redundancy\n", 100.0*(packets_put - packets_really_put)/packets_put);
+    printf("%.3f%% of packets lost after redundancy\n", 100.0*(packets_put - packets_got)/packets_put);
+    return 0;
+}
+/*- End of function --------------------------------------------------------*/
+/*- End of file ------------------------------------------------------------*/
diff --git a/code/train/C/0107085_xps-outline.c b/code/train/C/0107085_xps-outline.c
new file mode 100644
index 0000000000000000000000000000000000000000..dd44275575b67b26acc802997d30d125c39aa93d
--- /dev/null
+++ b/code/train/C/0107085_xps-outline.c
@@ -0,0 +1,145 @@
+#include "mupdf/fitz.h"
+#include "xps-imp.h"
+
+#include <stdlib.h>
+#include <math.h>
+
+/*
+ * Parse the document structure / outline parts referenced from fixdoc relationships.
+ */
+
+static fz_outline *
+xps_lookup_last_outline_at_level(fz_context *ctx, xps_document *doc, fz_outline *node, int level, int target_level)
+{
+	while (node->next)
+		node = node->next;
+	if (level == target_level || !node->down)
+		return node;
+	return xps_lookup_last_outline_at_level(ctx, doc, node->down, level + 1, target_level);
+}
+
+static fz_outline *
+xps_parse_document_outline(fz_context *ctx, xps_document *doc, fz_xml *root)
+{
+	fz_xml *node;
+	fz_outline *head = NULL, *entry, *tail;
+	int last_level = 1, this_level;
+	for (node = fz_xml_down(root); node; node = fz_xml_next(node))
+	{
+		if (fz_xml_is_tag(node, "OutlineEntry"))
+		{
+			char *level = fz_xml_att(node, "OutlineLevel");
+			char *target = fz_xml_att(node, "OutlineTarget");
+			char *description = fz_xml_att(node, "Description");
+			if (!target || !description)
+				continue;
+
+			entry = fz_new_outline(ctx);
+			entry->title = Memento_label(fz_strdup(ctx, description), "outline_title");
+			entry->uri = Memento_label(fz_strdup(ctx, target), "outline_uri");
+			entry->page = xps_lookup_link_target(ctx, (fz_document*)doc, target, NULL, NULL).page;
+			entry->down = NULL;
+			entry->next = NULL;
+
+			this_level = level ? atoi(level) : 1;
+
+			if (!head)
+			{
+				head = entry;
+			}
+			else
+			{
+				tail = xps_lookup_last_outline_at_level(ctx, doc, head, 1, this_level);
+				if (this_level > last_level)
+					tail->down = entry;
+				else
+					tail->next = entry;
+			}
+
+			last_level = this_level;
+		}
+	}
+	return head;
+}
+
+static fz_outline *
+xps_parse_document_structure(fz_context *ctx, xps_document *doc, fz_xml *root)
+{
+	fz_xml *node;
+	if (fz_xml_is_tag(root, "DocumentStructure"))
+	{
+		node = fz_xml_down(root);
+		if (node && fz_xml_is_tag(node, "DocumentStructure.Outline"))
+		{
+			node = fz_xml_down(node);
+			if (node && fz_xml_is_tag(node, "DocumentOutline"))
+				return xps_parse_document_outline(ctx, doc, node);
+		}
+	}
+	return NULL;
+}
+
+static fz_outline *
+xps_load_document_structure(fz_context *ctx, xps_document *doc, xps_fixdoc *fixdoc)
+{
+	xps_part *part;
+	fz_xml_doc *xml = NULL;
+	fz_outline *outline = NULL;
+
+	fz_var(xml);
+
+	part = xps_read_part(ctx, doc, fixdoc->outline);
+	fz_try(ctx)
+	{
+		xml = fz_parse_xml(ctx, part->data, 0);
+		outline = xps_parse_document_structure(ctx, doc, fz_xml_root(xml));
+	}
+	fz_always(ctx)
+	{
+		fz_drop_xml(ctx, xml);
+		xps_drop_part(ctx, doc, part);
+	}
+	fz_catch(ctx)
+	{
+		fz_rethrow(ctx);
+	}
+
+	return outline;
+}
+
+fz_outline *
+xps_load_outline(fz_context *ctx, fz_document *doc_)
+{
+	xps_document *doc = (xps_document*)doc_;
+	xps_fixdoc *fixdoc;
+	fz_outline *head = NULL, *tail, *outline = NULL;
+
+	for (fixdoc = doc->first_fixdoc; fixdoc; fixdoc = fixdoc->next)
+	{
+		if (fixdoc->outline)
+		{
+			fz_try(ctx)
+			{
+				outline = xps_load_document_structure(ctx, doc, fixdoc);
+			}
+			fz_catch(ctx)
+			{
+				fz_rethrow_if(ctx, FZ_ERROR_TRYLATER);
+				outline = NULL;
+			}
+			if (!outline)
+				continue;
+
+			if (!head)
+				head = outline;
+			else
+			{
+				while (tail->next)
+					tail = tail->next;
+				tail->next = outline;
+			}
+			tail = outline;
+		}
+	}
+	return head;
+}
diff --git a/code/train/C/0107373_cmdline.c b/code/train/C/0107373_cmdline.c
new file mode 100644
index 0000000000000000000000000000000000000000..390050c943d28f1923b51e726743bc3453f42d08
--- /dev/null
+++ b/code/train/C/0107373_cmdline.c
@@ -0,0 +1,84 @@
+/* cmdline.c: Kernel command line
+ * Copyright © 2019 Lukas Martini
+ *
+ * This file is part of Xelix.
+ *
+ * Xelix 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.
+ *
+ * Xelix 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 Xelix.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cmdline.h>
+#include <string.h>
+#include <mem/kmalloc.h>
+#include <fs/sysfs.h>
+
+static char* options[50] = {0};
+
+char* cmdline_get(const char* key) {
+	size_t key_len = strlen(key);
+
+	for(int i = 0; i < ARRAY_SIZE(options) && options[i]; i++) {
+		char* opt = options[i];
+
+		if(strlen(opt) >= key_len + 2 && !strncmp(key, opt, key_len - 1)) {
+			if(opt[key_len] != '=') {
+				continue;
+			}
+
+			return &opt[key_len + 1];
+		}
+	}
+
+	return NULL;
+}
+
+bool cmdline_get_bool(const char* key) {
+	for(int i = 0; i < ARRAY_SIZE(options) && options[i]; i++) {
+		if(!strcmp(options[i], key)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+static size_t sfs_read(struct vfs_callback_ctx* ctx, void* dest, size_t size) {
+	if(ctx->fp->offset) {
+		return 0;
+	}
+
+	size_t rsize = 0;
+	sysfs_printf("%s\n", cmdline_string());
+	return rsize;
+}
+
+void cmdline_init() {
+	char* cmdline = strdup(cmdline_string());
+	size_t len = strlen(cmdline);
+
+	char* cur = cmdline;
+	char* prev = cmdline;
+	int num_options = 0;
+	for(int i = 0; i < len + 1; i++, cur++) {
+		if(!*cur || *cur == ' ') {
+			*cur = 0;
+			options[num_options++] = prev;
+			prev = cur + 1;
+		}
+	}
+
+	log(LOG_INFO, "cmdline: %s\n", cmdline_string());
+	struct vfs_callbacks sfs_cb = {
+		.read = sfs_read,
+	};
+	sysfs_add_file("cmdline", &sfs_cb);
+}
diff --git a/code/train/C/0109563_scheduler.c b/code/train/C/0109563_scheduler.c
new file mode 100644
index 0000000000000000000000000000000000000000..d611d19af11da3d9bc41dcd29e819e8925f0f6ed
--- /dev/null
+++ b/code/train/C/0109563_scheduler.c
@@ -0,0 +1,230 @@
+/*
+ * This file is part of Cleanflight.
+ *
+ * Cleanflight 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.
+ *
+ * Cleanflight 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 Cleanflight.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define SRC_MAIN_SCHEDULER_C_
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include <platform.h>
+
+#include "scheduler.h"
+#include "debug.h"
+
+#include "common/maths.h"
+
+#include "drivers/system.h"
+#include "config/config_unittest.h"
+
+cfTaskId_e currentTaskId = TASK_NONE;
+
+#define REALTIME_GUARD_INTERVAL_MIN     10
+#define REALTIME_GUARD_INTERVAL_MAX     300
+#define REALTIME_GUARD_INTERVAL_MARGIN  25
+
+static uint32_t totalWaitingTasks;
+static uint32_t totalWaitingTasksSamples;
+static uint32_t realtimeGuardInterval = REALTIME_GUARD_INTERVAL_MAX;
+
+uint32_t currentTime = 0;
+uint16_t averageSystemLoadPercent = 0;
+
+
+void taskSystem(void)
+{
+    uint8_t taskId;
+
+    /* Calculate system load */
+    if (totalWaitingTasksSamples > 0) {
+        averageSystemLoadPercent = 100 * totalWaitingTasks / totalWaitingTasksSamples;
+        totalWaitingTasksSamples = 0;
+        totalWaitingTasks = 0;
+    }
+
+    /* Calculate guard interval */
+    uint32_t maxNonRealtimeTaskTime = 0;
+    for (taskId = 0; taskId < TASK_COUNT; taskId++) {
+        if (cfTasks[taskId].staticPriority != TASK_PRIORITY_REALTIME) {
+            maxNonRealtimeTaskTime = MAX(maxNonRealtimeTaskTime, cfTasks[taskId].averageExecutionTime);
+        }
+    }
+
+    realtimeGuardInterval = constrain(maxNonRealtimeTaskTime, REALTIME_GUARD_INTERVAL_MIN, REALTIME_GUARD_INTERVAL_MAX) + REALTIME_GUARD_INTERVAL_MARGIN;
+#if defined SCHEDULER_DEBUG
+    debug[2] = realtimeGuardInterval;
+#endif
+}
+
+#ifndef SKIP_TASK_STATISTICS
+void getTaskInfo(cfTaskId_e taskId, cfTaskInfo_t * taskInfo)
+{
+    taskInfo->taskName = cfTasks[taskId].taskName;
+    taskInfo->isEnabled= cfTasks[taskId].isEnabled;
+    taskInfo->desiredPeriod = cfTasks[taskId].desiredPeriod;
+    taskInfo->staticPriority = cfTasks[taskId].staticPriority;
+    taskInfo->maxExecutionTime = cfTasks[taskId].maxExecutionTime;
+    taskInfo->totalExecutionTime = cfTasks[taskId].totalExecutionTime;
+    taskInfo->averageExecutionTime = cfTasks[taskId].averageExecutionTime;
+}
+#endif
+
+void rescheduleTask(cfTaskId_e taskId, uint32_t newPeriodMicros)
+{
+    if (taskId == TASK_SELF)
+        taskId = currentTaskId;
+
+    if (taskId < TASK_COUNT) {
+        cfTasks[taskId].desiredPeriod = MAX(100, newPeriodMicros);  // Limit delay to 100us (10 kHz) to prevent scheduler clogging
+    }
+}
+
+void setTaskEnabled(cfTaskId_e taskId, bool newEnabledState)
+{
+    if (taskId == TASK_SELF)
+        taskId = currentTaskId;
+
+    if (taskId < TASK_COUNT) {
+        cfTasks[taskId].isEnabled = newEnabledState;
+    }
+}
+
+uint32_t getTaskDeltaTime(cfTaskId_e taskId)
+{
+    if (taskId == TASK_SELF)
+        taskId = currentTaskId;
+
+    if (taskId < TASK_COUNT) {
+        return cfTasks[taskId].taskLatestDeltaTime;
+    }
+    else {
+        return 0;
+    }
+}
+
+void scheduler(void)
+{
+    uint8_t taskId;
+    /* The task to be invoked */
+    uint8_t selectedTaskId = TASK_NONE;
+    uint8_t selectedTaskDynPrio = 0;
+    uint16_t waitingTasks = 0;
+    uint32_t timeToNextRealtimeTask = UINT32_MAX;
+
+    SET_SCHEDULER_LOCALS();
+    /* Cache currentTime */
+    currentTime = micros();
+
+    /* Check for realtime tasks */
+    for (taskId = 0; taskId < TASK_COUNT; taskId++) {
+        if (cfTasks[taskId].staticPriority == TASK_PRIORITY_REALTIME) {
+            uint32_t nextExecuteAt = cfTasks[taskId].lastExecutedAt + cfTasks[taskId].desiredPeriod;
+            if ((int32_t)(currentTime - nextExecuteAt) >= 0) {
+                timeToNextRealtimeTask = 0;
+            }
+            else {
+                uint32_t newTimeInterval = nextExecuteAt - currentTime;
+                timeToNextRealtimeTask = MIN(timeToNextRealtimeTask, newTimeInterval);
+            }
+        }
+    }
+
+    bool outsideRealtimeGuardInterval = (timeToNextRealtimeTask > realtimeGuardInterval);
+
+    /* Update task dynamic priorities */
+    for (taskId = 0; taskId < TASK_COUNT; taskId++) {
+        if (cfTasks[taskId].isEnabled) {
+            /* Task has checkFunc - event driven */
+            if (cfTasks[taskId].checkFunc != NULL) {
+                /* Increase priority for event driven tasks */
+                if (cfTasks[taskId].dynamicPriority > 0) {
+                    cfTasks[taskId].taskAgeCycles = 1 + ((currentTime - cfTasks[taskId].lastSignaledAt) / cfTasks[taskId].desiredPeriod);
+                    cfTasks[taskId].dynamicPriority = 1 + cfTasks[taskId].staticPriority * cfTasks[taskId].taskAgeCycles;
+                    waitingTasks++;
+                }
+                else if (cfTasks[taskId].checkFunc(currentTime - cfTasks[taskId].lastExecutedAt)) {
+                    cfTasks[taskId].lastSignaledAt = currentTime;
+                    cfTasks[taskId].taskAgeCycles = 1;
+                    cfTasks[taskId].dynamicPriority = 1 + cfTasks[taskId].staticPriority;
+                    waitingTasks++;
+                }
+                else {
+                    cfTasks[taskId].taskAgeCycles = 0;
+                }
+            }
+            /* Task is time-driven, dynamicPriority is last execution age measured in desiredPeriods) */
+            else {
+                // Task age is calculated from last execution
+                cfTasks[taskId].taskAgeCycles = ((currentTime - cfTasks[taskId].lastExecutedAt) / cfTasks[taskId].desiredPeriod);
+                if (cfTasks[taskId].taskAgeCycles > 0) {
+                    cfTasks[taskId].dynamicPriority = 1 + cfTasks[taskId].staticPriority * cfTasks[taskId].taskAgeCycles;
+                    waitingTasks++;
+                }
+            }
+
+            /* limit new priority to avoid overflow of uint8_t */
+            cfTasks[taskId].dynamicPriority = MIN(cfTasks[taskId].dynamicPriority, TASK_PRIORITY_MAX);;
+
+            bool taskCanBeChosenForScheduling =
+                (outsideRealtimeGuardInterval) ||
+                (cfTasks[taskId].taskAgeCycles > 1) ||
+                (cfTasks[taskId].staticPriority == TASK_PRIORITY_REALTIME);
+
+            if (taskCanBeChosenForScheduling && (cfTasks[taskId].dynamicPriority > selectedTaskDynPrio)) {
+                selectedTaskDynPrio = cfTasks[taskId].dynamicPriority;
+                selectedTaskId = taskId;
+            }
+        }
+    }
+
+    totalWaitingTasksSamples += 1;
+    totalWaitingTasks += waitingTasks;
+
+    /* Found a task that should be run */
+    if (selectedTaskId != TASK_NONE) {
+        cfTasks[selectedTaskId].taskLatestDeltaTime = currentTime - cfTasks[selectedTaskId].lastExecutedAt;
+        cfTasks[selectedTaskId].lastExecutedAt = currentTime;
+        cfTasks[selectedTaskId].dynamicPriority = 0;
+
+        currentTaskId = selectedTaskId;
+
+        uint32_t currentTimeBeforeTaskCall = micros();
+
+        /* Execute task */
+        if (cfTasks[selectedTaskId].taskFunc != NULL) {
+            cfTasks[selectedTaskId].taskFunc();
+        }
+
+        uint32_t taskExecutionTime = micros() - currentTimeBeforeTaskCall;
+
+        cfTasks[selectedTaskId].averageExecutionTime = ((uint32_t)cfTasks[selectedTaskId].averageExecutionTime * 31 + taskExecutionTime) / 32;
+#ifndef SKIP_TASK_STATISTICS
+        cfTasks[selectedTaskId].totalExecutionTime += taskExecutionTime;   // time consumed by scheduler + task
+        cfTasks[selectedTaskId].maxExecutionTime = MAX(cfTasks[selectedTaskId].maxExecutionTime, taskExecutionTime);
+#endif
+#if defined SCHEDULER_DEBUG
+        debug[3] = (micros() - currentTime) - taskExecutionTime;
+#endif
+    }
+    else {
+        currentTaskId = TASK_NONE;
+#if defined SCHEDULER_DEBUG
+        debug[3] = (micros() - currentTime);
+#endif
+    }
+    GET_SCHEDULER_LOCALS();
+}
diff --git a/code/train/C/0109934_alecto_ws1700.c b/code/train/C/0109934_alecto_ws1700.c
new file mode 100644
index 0000000000000000000000000000000000000000..1b744938701daa1d135e3d03aaaa0b85d945cfb2
--- /dev/null
+++ b/code/train/C/0109934_alecto_ws1700.c
@@ -0,0 +1,218 @@
+/*
+	Copyright (C) 2014 CurlyMo
+
+	This file is part of pilight.
+
+	pilight 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.
+
+	pilight 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 pilight. If not, see	<http://www.gnu.org/licenses/>
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "../../core/pilight.h"
+#include "../../core/common.h"
+#include "../../core/dso.h"
+#include "../../core/log.h"
+#include "../protocol.h"
+#include "../../core/binary.h"
+#include "../../core/gc.h"
+#include "alecto_ws1700.h"
+
+#define PULSE_MULTIPLIER	20
+#define MIN_PULSE_LENGTH	261
+#define AVG_PULSE_LENGTH	266
+#define MAX_PULSE_LENGTH	280
+#define RAW_LENGTH				74
+
+typedef struct settings_t {
+	double id;
+	double temp;
+	double humi;
+	struct settings_t *next;
+} settings_t;
+
+static struct settings_t *settings = NULL;
+
+static int validate(void) {
+	if(alecto_ws1700->rawlen == RAW_LENGTH) {
+		if(alecto_ws1700->raw[alecto_ws1700->rawlen-1] >= (MIN_PULSE_LENGTH*PULSE_DIV) &&
+		   alecto_ws1700->raw[alecto_ws1700->rawlen-1] <= (MAX_PULSE_LENGTH*PULSE_DIV)) {
+			return 0;
+		}
+	}
+
+	return -1;
+}
+
+static void parseCode(void) {
+	int i = 0, x = 0, binary[RAW_LENGTH/2];
+	int id = 0, battery = 0, header = 0;
+	double humi_offset = 0.0, temp_offset = 0.0;
+	double temperature = 0.0, humidity = 0.0;
+
+	if(alecto_ws1700->rawlen>RAW_LENGTH) {
+		logprintf(LOG_ERR, "alecto_ws1700: parsecode - invalid parameter passed %d", alecto_ws1700->rawlen);
+		return;
+	}
+
+	for(x=1;x<alecto_ws1700->rawlen-1;x+=2) {
+		if(alecto_ws1700->raw[x] > (int)((double)AVG_PULSE_LENGTH*((double)PULSE_MULTIPLIER/2))) {
+			binary[i++] = 1;
+		} else {
+			binary[i++] = 0;
+		}
+	}
+
+	header = binToDecRev(binary, 0, 3);
+	if (header != 5) {
+		return;
+	}
+	id = binToDecRev(binary, 4, 11);
+	battery = binary[12];
+	temperature = (double)binToSignedRev(binary, 16, 27);
+	humidity = (double)binToDecRev(binary, 28, 35);
+
+	temperature /= 10;
+
+	struct settings_t *tmp = settings;
+	while(tmp) {
+		if(fabs(tmp->id-id) < EPSILON) {
+			humi_offset = tmp->humi;
+			temp_offset = tmp->temp;
+			break;
+		}
+		tmp = tmp->next;
+	}
+
+	temperature += temp_offset;
+	humidity += humi_offset;
+
+	alecto_ws1700->message = json_mkobject();
+	json_append_member(alecto_ws1700->message, "id", json_mknumber(id, 0));
+	json_append_member(alecto_ws1700->message, "temperature", json_mknumber(temperature, 1));
+	json_append_member(alecto_ws1700->message, "humidity", json_mknumber(humidity, 1));
+	json_append_member(alecto_ws1700->message, "battery", json_mknumber(battery, 0));
+}
+
+static int checkValues(struct JsonNode *jvalues) {
+	struct JsonNode *jid = NULL;
+
+	if((jid = json_find_member(jvalues, "id"))) {
+		struct settings_t *snode = NULL;
+		struct JsonNode *jchild = NULL;
+		struct JsonNode *jchild1 = NULL;
+		double id = -1;
+		int match = 0;
+
+		jchild = json_first_child(jid);
+		while(jchild) {
+			jchild1 = json_first_child(jchild);
+			while(jchild1) {
+				if(strcmp(jchild1->key, "id") == 0) {
+					id = jchild1->number_;
+				}
+				jchild1 = jchild1->next;
+			}
+			jchild = jchild->next;
+		}
+
+		struct settings_t *tmp = settings;
+		while(tmp) {
+			if(fabs(tmp->id-id) < EPSILON) {
+				match = 1;
+				break;
+			}
+			tmp = tmp->next;
+		}
+
+		if(match == 0) {
+			if((snode = MALLOC(sizeof(struct settings_t))) == NULL) {
+				fprintf(stderr, "out of memory\n");
+				exit(EXIT_FAILURE);
+			}
+			snode->id = id;
+			snode->temp = 0;
+			snode->humi = 0;
+
+			json_find_number(jvalues, "temperature-offset", &snode->temp);
+			json_find_number(jvalues, "humidity-offset", &snode->humi);
+
+			snode->next = settings;
+			settings = snode;
+		}
+	}
+	return 0;
+}
+
+static void gc(void) {
+	struct settings_t *tmp = NULL;
+	while(settings) {
+		tmp = settings;
+		settings = settings->next;
+		FREE(tmp);
+	}
+	if(settings != NULL) {
+		FREE(settings);
+	}
+}
+
+#if !defined(MODULE) && !defined(_WIN32)
+__attribute__((weak))
+#endif
+void alectoWS1700Init(void) {
+
+	protocol_register(&alecto_ws1700);
+	protocol_set_id(alecto_ws1700, "alecto_ws1700");
+	protocol_device_add(alecto_ws1700, "alecto_ws1700", "Alecto WS1700 Weather Stations");
+	protocol_device_add(alecto_ws1700, "iboutique", "iBoutique Weather Stations");
+	alecto_ws1700->devtype = WEATHER;
+	alecto_ws1700->hwtype = RF433;
+	alecto_ws1700->minrawlen = RAW_LENGTH;
+	alecto_ws1700->maxrawlen = RAW_LENGTH;
+	alecto_ws1700->maxgaplen = MAX_PULSE_LENGTH*PULSE_DIV;
+	alecto_ws1700->mingaplen = MIN_PULSE_LENGTH*PULSE_DIV;
+
+	options_add(&alecto_ws1700->options, 't', "temperature", OPTION_HAS_VALUE, DEVICES_VALUE, JSON_NUMBER, NULL, "^[0-9]{1,3}$");
+	options_add(&alecto_ws1700->options, 'i', "id", OPTION_HAS_VALUE, DEVICES_ID, JSON_NUMBER, NULL, "[0-9]");
+	options_add(&alecto_ws1700->options, 'h', "humidity", OPTION_HAS_VALUE, DEVICES_VALUE, JSON_NUMBER, NULL, "[0-9]");
+	options_add(&alecto_ws1700->options, 'b', "battery", OPTION_HAS_VALUE, DEVICES_VALUE, JSON_NUMBER, NULL, "^[01]$");
+
+	// options_add(&alecto_ws1700->options, 0, "decimals", OPTION_HAS_VALUE, DEVICES_SETTING, JSON_NUMBER, (void *)1, "[0-9]");
+	options_add(&alecto_ws1700->options, 0, "temperature-offset", OPTION_HAS_VALUE, DEVICES_SETTING, JSON_NUMBER, (void *)0, "[0-9]");
+	options_add(&alecto_ws1700->options, 0, "humidity-offset", OPTION_HAS_VALUE, DEVICES_SETTING, JSON_NUMBER, (void *)0, "[0-9]");
+	options_add(&alecto_ws1700->options, 0, "temperature-decimals", OPTION_HAS_VALUE, GUI_SETTING, JSON_NUMBER, (void *)1, "[0-9]");
+	options_add(&alecto_ws1700->options, 0, "humidity-decimals", OPTION_HAS_VALUE, GUI_SETTING, JSON_NUMBER, (void *)1, "[0-9]");
+	options_add(&alecto_ws1700->options, 0, "show-humidity", OPTION_HAS_VALUE, GUI_SETTING, JSON_NUMBER, (void *)1, "^[10]{1}$");
+	options_add(&alecto_ws1700->options, 0, "show-temperature", OPTION_HAS_VALUE, GUI_SETTING, JSON_NUMBER, (void *)1, "^[10]{1}$");
+	options_add(&alecto_ws1700->options, 0, "show-battery", OPTION_HAS_VALUE, GUI_SETTING, JSON_NUMBER, (void *)1, "^[10]{1}$");
+
+	alecto_ws1700->parseCode=&parseCode;
+	alecto_ws1700->checkValues=&checkValues;
+	alecto_ws1700->validate=&validate;
+	alecto_ws1700->gc=&gc;
+}
+
+#if defined(MODULE) && !defined(_WIN32)
+void compatibility(struct module_t *module) {
+	module->name = "alecto_ws1700";
+	module->version = "2.5";
+	module->reqversion = "6.0";
+	module->reqcommit = "84";
+}
+
+void init(void) {
+	alectoWS1700Init();
+}
+#endif
diff --git a/code/train/C/0111658_hal_flash.c b/code/train/C/0111658_hal_flash.c
new file mode 100644
index 0000000000000000000000000000000000000000..94c1c007f6ea96ccf16f68e90f544f73c72df6d6
--- /dev/null
+++ b/code/train/C/0111658_hal_flash.c
@@ -0,0 +1,265 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 <sys/mman.h>
+#include <fcntl.h>
+#include <assert.h>
+#include <string.h>
+#include <inttypes.h>
+#include <stdlib.h>
+
+#include <syscfg/syscfg.h>
+
+#include "hal/hal_flash_int.h"
+#include "mcu/mcu_sim.h"
+
+char *native_flash_file;
+static int file;
+static void *file_loc;
+
+static int native_flash_init(const struct hal_flash *dev);
+static int native_flash_read(const struct hal_flash *dev, uint32_t address,
+        void *dst, uint32_t length);
+static int native_flash_write(const struct hal_flash *dev, uint32_t address,
+        const void *src, uint32_t length);
+static int native_flash_erase_sector(const struct hal_flash *dev,
+        uint32_t sector_address);
+static int native_flash_sector_info(const struct hal_flash *dev, int idx,
+        uint32_t *address, uint32_t *size);
+
+static const struct hal_flash_funcs native_flash_funcs = {
+    .hff_read = native_flash_read,
+    .hff_write = native_flash_write,
+    .hff_erase_sector = native_flash_erase_sector,
+    .hff_sector_info = native_flash_sector_info,
+    .hff_init = native_flash_init
+};
+
+#if MYNEWT_VAL(MCU_FLASH_STYLE_ST)
+static const uint32_t native_flash_sectors[] = {
+    0x00000000, /* 16 * 1024 */
+    0x00004000, /* 16 * 1024 */
+    0x00008000, /* 16 * 1024 */
+    0x0000c000, /* 16 * 1024 */
+    0x00010000, /* 64 * 1024 */
+    0x00020000, /* 128 * 1024 */
+    0x00040000, /* 128 * 1024 */
+    0x00060000, /* 128 * 1024 */
+    0x00080000, /* 128 * 1024 */
+    0x000a0000, /* 128 * 1024 */
+    0x000c0000, /* 128 * 1024 */
+    0x000e0000, /* 128 * 1024 */
+};
+#elif MYNEWT_VAL(MCU_FLASH_STYLE_NORDIC)
+static uint32_t native_flash_sectors[1024 * 1024 / 2048];
+#else
+#error "Need to specify either MCU_FLASH_STYLE_NORDIC or MCU_FLASH_STYLE_ST"
+#endif
+
+#define FLASH_NUM_AREAS   (int)(sizeof native_flash_sectors /           \
+                                sizeof native_flash_sectors[0])
+
+const struct hal_flash native_flash_dev = {
+    .hf_itf = &native_flash_funcs,
+    .hf_base_addr = 0,
+    .hf_size = 1024 * 1024,
+    .hf_sector_cnt = FLASH_NUM_AREAS,
+    .hf_align = 1
+};
+
+static void
+flash_native_erase(uint32_t addr, uint32_t len)
+{
+    memset(file_loc + addr, 0xff, len);
+}
+
+static void
+flash_native_file_open(char *name)
+{
+    int created = 0;
+    extern char *tmpnam(char *s);
+    extern int ftruncate(int fd, off_t length);
+
+    if (!name) {
+        name = tmpnam(NULL);
+    }
+    file = open(name, O_RDWR);
+    if (file < 0) {
+        file = open(name, O_RDWR | O_CREAT, 0660);
+        assert(file > 0);
+        created = 1;
+        if (ftruncate(file, native_flash_dev.hf_size) < 0) {
+            assert(0);
+        }
+    }
+    file_loc = mmap(0, native_flash_dev.hf_size,
+          PROT_READ | PROT_WRITE, MAP_SHARED, file, 0);
+    assert(file_loc != MAP_FAILED);
+    if (created) {
+        flash_native_erase(0, native_flash_dev.hf_size);
+    }
+}
+
+static void
+flash_native_ensure_file_open(void)
+{
+    if (file == 0) {
+        flash_native_file_open(NULL);
+    }
+}
+
+static int
+flash_native_write_internal(uint32_t address, const void *src, uint32_t length,
+                            int allow_overwrite)
+{
+    static uint8_t buf[256];
+    uint32_t cur;
+    uint32_t end;
+    int chunk_sz;
+    int rc;
+    int i;
+
+    if (length == 0) {
+        return 0;
+    }
+
+    end = address + length;
+
+    flash_native_ensure_file_open();
+
+    cur = address;
+    while (cur < end) {
+        if (end - cur < sizeof buf) {
+            chunk_sz = end - cur;
+        } else {
+            chunk_sz = sizeof buf;
+        }
+
+        /* Ensure data is not being overwritten. */
+        if (!allow_overwrite) {
+            rc = native_flash_read(NULL, cur, buf, chunk_sz);
+            assert(rc == 0);
+            for (i = 0; i < chunk_sz; i++) {
+                assert(buf[i] == 0xff);
+            }
+        }
+
+        cur += chunk_sz;
+    }
+
+    memcpy((char *)file_loc + address, src, length);
+
+    return 0;
+}
+
+static int
+native_flash_write(const struct hal_flash *dev, uint32_t address,
+        const void *src, uint32_t length)
+{
+    assert(address % native_flash_dev.hf_align == 0);
+    return flash_native_write_internal(address, src, length, 0);
+}
+
+int
+flash_native_memset(uint32_t offset, uint8_t c, uint32_t len)
+{
+    memset(file_loc + offset, c, len);
+    return 0;
+}
+
+static int
+native_flash_read(const struct hal_flash *dev, uint32_t address, void *dst,
+        uint32_t length)
+{
+    flash_native_ensure_file_open();
+    memcpy(dst, (char *)file_loc + address, length);
+
+    return 0;
+}
+
+static int
+find_area(uint32_t address)
+{
+    int i;
+
+    for (i = 0; i < FLASH_NUM_AREAS; i++) {
+        if (native_flash_sectors[i] == address) {
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+static int
+flash_sector_len(int sector)
+{
+    uint32_t end;
+
+    if (sector == FLASH_NUM_AREAS - 1) {
+        end = native_flash_dev.hf_size + native_flash_sectors[0];
+    } else {
+        end = native_flash_sectors[sector + 1];
+    }
+    return end - native_flash_sectors[sector];
+}
+
+static int
+native_flash_erase_sector(const struct hal_flash *dev, uint32_t sector_address)
+{
+    int area_id;
+    uint32_t len;
+
+    flash_native_ensure_file_open();
+
+    area_id = find_area(sector_address);
+    if (area_id == -1) {
+        return -1;
+    }
+    len = flash_sector_len(area_id);
+    flash_native_erase(sector_address, len);
+    return 0;
+}
+
+static int
+native_flash_sector_info(const struct hal_flash *dev, int idx,
+        uint32_t *address, uint32_t *size)
+{
+    assert(idx < FLASH_NUM_AREAS);
+
+    *address = native_flash_sectors[idx];
+    *size = flash_sector_len(idx);
+    return 0;
+}
+
+static int
+native_flash_init(const struct hal_flash *dev)
+{
+    if (native_flash_file) {
+        flash_native_file_open(native_flash_file);
+    }
+#if MYNEWT_VAL(MCU_FLASH_STYLE_NORDIC)
+    int i;
+
+    for (i = 0; i < FLASH_NUM_AREAS; i++) {
+        native_flash_sectors[i] = i * 2048;
+    }
+#endif
+    return 0;
+}
diff --git a/code/train/C/0112501_app_rand.c b/code/train/C/0112501_app_rand.c
new file mode 100644
index 0000000000000000000000000000000000000000..b6fe294a6827112c045ef32fa66905112b518acc
--- /dev/null
+++ b/code/train/C/0112501_app_rand.c
@@ -0,0 +1,226 @@
+/* apps/app_rand.c */
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
+ * All rights reserved.
+ *
+ * This package is an SSL implementation written
+ * by Eric Young (eay@cryptsoft.com).
+ * The implementation was written so as to conform with Netscapes SSL.
+ *
+ * This library is free for commercial and non-commercial use as long as
+ * the following conditions are aheared to.  The following conditions
+ * apply to all code found in this distribution, be it the RC4, RSA,
+ * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
+ * included with this distribution is covered by the same copyright terms
+ * except that the holder is Tim Hudson (tjh@cryptsoft.com).
+ *
+ * Copyright remains Eric Young's, and as such any Copyright notices in
+ * the code are not to be removed.
+ * If this package is used in a product, Eric Young should be given attribution
+ * as the author of the parts of the library used.
+ * This can be in the form of a textual message at program startup or
+ * in documentation (online or textual) provided with the package.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *    "This product includes cryptographic software written by
+ *     Eric Young (eay@cryptsoft.com)"
+ *    The word 'cryptographic' can be left out if the rouines from the library
+ *    being used are not cryptographic related :-).
+ * 4. If you include any Windows specific code (or a derivative thereof) from
+ *    the apps directory (application code) you must include an acknowledgement:
+ *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``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 AUTHOR 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.
+ *
+ * The licence and distribution terms for any publically available version or
+ * derivative of this code cannot be changed.  i.e. this code cannot simply be
+ * copied and put under another distribution licence
+ * [including the GNU Public Licence.]
+ */
+/* ====================================================================
+ * Copyright (c) 1998-2000 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED 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 OpenSSL PROJECT OR
+ * ITS 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.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
+
+#define NON_MAIN
+#include "apps.h"
+#undef NON_MAIN
+#include <openssl/bio.h>
+#include <openssl/rand.h>
+
+static int seeded = 0;
+static int egdsocket = 0;
+
+int app_RAND_load_file(const char *file, BIO *bio_e, int dont_warn)
+{
+    int consider_randfile = (file == NULL);
+    char buffer[200];
+
+#ifdef OPENSSL_SYS_WINDOWS
+    /*
+     * allocate 2 to dont_warn not to use RAND_screen() via
+     * -no_rand_screen option in s_client
+     */
+    if (dont_warn != 2) {
+      BIO_printf(bio_e, "Loading 'screen' into random state -");
+      BIO_flush(bio_e);
+      RAND_screen();
+      BIO_printf(bio_e, " done\n");
+    }
+#endif
+
+    if (file == NULL)
+        file = RAND_file_name(buffer, sizeof buffer);
+    else if (RAND_egd(file) > 0) {
+        /*
+         * we try if the given filename is an EGD socket. if it is, we don't
+         * write anything back to the file.
+         */
+        egdsocket = 1;
+        return 1;
+    }
+    if (file == NULL || !RAND_load_file(file, -1)) {
+        if (RAND_status() == 0) {
+            if (!dont_warn) {
+                BIO_printf(bio_e, "unable to load 'random state'\n");
+                BIO_printf(bio_e,
+                           "This means that the random number generator has not been seeded\n");
+                BIO_printf(bio_e, "with much random data.\n");
+                if (consider_randfile) { /* explanation does not apply when a
+                                          * file is explicitly named */
+                    BIO_printf(bio_e,
+                               "Consider setting the RANDFILE environment variable to point at a file that\n");
+                    BIO_printf(bio_e,
+                               "'random' data can be kept in (the file will be overwritten).\n");
+                }
+            }
+            return 0;
+        }
+    }
+    seeded = 1;
+    return 1;
+}
+
+long app_RAND_load_files(char *name)
+{
+    char *p, *n;
+    int last;
+    long tot = 0;
+    int egd;
+
+    for (;;) {
+        last = 0;
+        for (p = name; ((*p != '\0') && (*p != LIST_SEPARATOR_CHAR)); p++) ;
+        if (*p == '\0')
+            last = 1;
+        *p = '\0';
+        n = name;
+        name = p + 1;
+        if (*n == '\0')
+            break;
+
+        egd = RAND_egd(n);
+        if (egd > 0)
+            tot += egd;
+        else
+            tot += RAND_load_file(n, -1);
+        if (last)
+            break;
+    }
+    if (tot > 512)
+        app_RAND_allow_write_file();
+    return (tot);
+}
+
+int app_RAND_write_file(const char *file, BIO *bio_e)
+{
+    char buffer[200];
+
+    if (egdsocket || !seeded)
+        /*
+         * If we did not manage to read the seed file, we should not write a
+         * low-entropy seed file back -- it would suppress a crucial warning
+         * the next time we want to use it.
+         */
+        return 0;
+
+    if (file == NULL)
+        file = RAND_file_name(buffer, sizeof buffer);
+    if (file == NULL || !RAND_write_file(file)) {
+        BIO_printf(bio_e, "unable to write 'random state'\n");
+        return 0;
+    }
+    return 1;
+}
+
+void app_RAND_allow_write_file(void)
+{
+    seeded = 1;
+}
diff --git a/code/train/C/0113311_adaline.c b/code/train/C/0113311_adaline.c
new file mode 100644
index 0000000000000000000000000000000000000000..511ac2d161c9f3c41fd5b758f190f3d0594afcbb
--- /dev/null
+++ b/code/train/C/0113311_adaline.c
@@ -0,0 +1,135 @@
+
+#include "adaline.h"
+
+float getRandomNumberF(float inf, float sup)
+{
+    /* Control de errores de los parametros de entrada*/
+    if ((sup < inf) || (sup > RAND_MAX) || (sup < 0) || (sup > RAND_MAX))
+        return -1;
+    /*la función rand() limita el rango [0, 1) debido a la división entre RAND_MAX+1.
+     * La segunda parte multiplica dicho valor por un número que se encuentre aproximadamente
+     * en la mitad del rango (sup-inf +1), de este modo se normaliza el anterior valor
+     * acotándolo entre 0 y el número intermedio.  Sin embargo, es necesario sumar el límite
+     * inferior al resultado con el fin de que se obtenga un valor superior a este.*/
+    return (float)((rand()/(RAND_MAX+1.))*(sup-inf))+inf;
+}
+
+void initWeightsAdaline(Perceptron *perceptron)
+{
+	int i;
+
+	for(i=0; i<perceptron->output.numConnections; i++)
+		perceptron->output.weights[i] = getRandomNumberF(-0.1,0.1);
+
+	for(i=0; i<perceptron->output.numConnections; i++)
+		printf("W %.3f ",perceptron->output.weights[i]);
+	printf("\n");
+}
+
+int learnAdaline(
+	Perceptron *perceptron, float learningRate, 
+	float threshold, Pattern *patterns, 
+	int numberPatterns, float errorTolerance)
+{
+	int p, i, w;
+	float biggerWeightChange;
+	float deltaChange;
+	int n_iter = 1;
+	int currentCategory;
+	float errors = 0;
+	float y_in;
+
+	do{
+
+		errors = 0;
+
+		biggerWeightChange = LONG_MIN;
+
+		if(DEBUG_TEST)
+			printf("=========EPOCA %d==========\n", n_iter);
+
+
+		for (p = 0; p < numberPatterns; p++)
+		{
+
+			if(DEBUG_TEST)
+				printf("Entrada: ");
+			// Estimulacion de las entradas
+			for (i = 0; i < perceptron->numInputs ; i++)
+			{
+				perceptron->output.inputs[i] = patterns->attributes[p][i];
+				if(DEBUG_TEST)
+					printf("%.1f ", perceptron->output.inputs[i]);
+			}
+			if(DEBUG_TEST)
+				printf("\n");
+
+			y_in = 0;
+
+			// Aplicación de la función de transferencia, en este caso la entrada neta
+			for(i=0;i<perceptron->output.numConnections;i++){
+				y_in += perceptron->output.inputs[i] * perceptron->output.weights[i];
+			}
+
+			y_in += perceptron->output.b;
+
+			if(DEBUG_TEST)
+				printf("Y_IN %.3f\n",y_in);
+			// Conversión de categoria original a la necesaria para learn
+			if (patterns->categories[p][0] == 1)
+				currentCategory = 1;
+			else
+				currentCategory = -1;
+
+			if(DEBUG_TEST)
+				printf("T = %d\n", currentCategory);
+
+			errors += (float)pow((currentCategory - y_in),2);
+
+			// Cambio en los pesos
+			
+			for (w = 0; w < perceptron->numInputs; w++)
+			{
+				deltaChange = learningRate * patterns->attributes[p][w] * 
+					(currentCategory - y_in);
+				perceptron->output.weights[w] += deltaChange;
+
+				if(deltaChange > biggerWeightChange)
+					biggerWeightChange = deltaChange;
+
+				if(DEBUG_TEST)
+					printf("DELTA peso %d  %.2f\n",w, deltaChange);
+			}
+			deltaChange = learningRate * (currentCategory - y_in);
+			perceptron->output.b += deltaChange;
+
+			if(deltaChange > biggerWeightChange)
+					biggerWeightChange = deltaChange;
+				
+			if(DEBUG_TEST)
+				printf("\n");
+	
+			if(DEBUG_TEST)
+			{
+				for(i=0;i<perceptron->output.numConnections;i++)
+					printf("W %.2f ",perceptron->output.weights[i]);
+				printf("\n");
+			}
+      	}
+
+
+      	printf("Epoca %d Error Cuadrático Medio :%.4f\n",
+				n_iter, (float)errors/numberPatterns);
+      	if(DEBUG_TEST)
+      		printf("BIGGEST CHANGE %.3f ERROR TOLERANCE %.3f\n",fabs(biggerWeightChange),errorTolerance);
+      	n_iter++;
+      	if (n_iter > NUM_MAX_ITER)
+      		break;
+
+      	//printf("\nEPOCA %d ERRORES = %.4f\n", n_iter, (float)errors/numberPatterns*100);
+
+	}while (fabs(biggerWeightChange) > errorTolerance);
+
+	return 0;
+
+}
diff --git a/code/train/C/0116272_deletelistnode.c b/code/train/C/0116272_deletelistnode.c
new file mode 100644
index 0000000000000000000000000000000000000000..363dced9e584ebad6a34c40b0eecb614a69e505b
--- /dev/null
+++ b/code/train/C/0116272_deletelistnode.c
@@ -0,0 +1,154 @@
+/* 链表的删除 */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+struct llist   //链表结构声明
+{
+	int num;   //邮寄编号
+	struct llist *next;   //指向下一标签
+};
+
+typedef struct llist node;  //定义新类型
+typedef node *llink;    //定义新类型指针
+
+/* 链表的输出 */
+int printllist(llink ptr)
+{
+	while(ptr != NULL)  //链表遍历循环
+	{
+		printf("[%d]",ptr->num);    //输出结点数据
+		ptr = ptr->next;     //指向下一结点
+	}
+	printf("\n");  //结点
+	return 0;
+}
+
+/* 链表的创建 */
+
+llink createllist(int *array,int len)
+{
+	llink head;   //链表的开始指针
+	llink ptr,ptr1;
+	int i;
+
+	//创建第一个结点
+	head = (llink) malloc(sizeof(node));  //分配内存
+	if(!head)    //检查指针
+		return NULL;
+	head->num = array[0];   //创建结点内容
+	head->next = NULL;    //设置指针初值
+	ptr = head;   //将ptr指向链表开始
+
+	for(i = 1; i < len; i++)   //创建其他结点循环
+	{
+		ptr1 = (llink) malloc(sizeof(node));
+		if(!ptr)
+			return NULL;
+		ptr1->num = array[i];  //创建结点内容
+		ptr1->next = NULL;    //设置指针初值
+		ptr->next = ptr1; //连接结点
+		ptr = ptr->next;  //指向下一结点
+	}
+
+	return head;
+}
+
+/* 链表的结点遍历 */
+llink findnode(llink head,int num)
+{
+	llink ptr;
+	ptr = head;      //指向链表起始
+	while(ptr != NULL)  //遍历链表
+	{
+		if(ptr->num == num)   //查找编号
+		{
+			return ptr;
+		}
+		ptr = ptr->next;   //指向下一结点
+	}
+	return ptr;
+}
+
+/*链表的结点删除 */
+
+llink deletenode(llink head,llink ptr)
+{
+	llink previous;    //指向前一结点
+
+	if(ptr == head)   //是否是链表开始
+	{
+		//头结点，删除第一个结点
+		return head->next;   //输入第二结点指针
+	}
+	else
+	{
+		previous = head;
+		while(previous->next != ptr)  //找结点ptr的前结点
+			previous = previous->next;
+
+		if(ptr->next == NULL)   //是否是链表结束
+			//是链表的最后一个结点
+			previous->next = NULL;   //最后一个结点
+		else
+			//结点在中间
+			previous->next = ptr->next;   //中间结点
+	}
+	free(ptr);  //释放结点内存
+	return head;
+}
+
+/* 链表的内存释放 */
+
+int freellist(llink head)
+{
+	llink ptr;
+	while(head != NULL)  //遍历链表循环
+	{
+		ptr = head;
+		head = head->next; //指向下一结点
+		free(ptr);   //释放结点内存
+	}
+	return 0;
+}
+
+int main()
+{
+	int llist1[6] = {1,2,3,4,5,6};   //数组内容
+	llink head;    //指向链表开始
+	llink ptr;
+	int num;    //邮寄编号变量
+
+	head = createllist(llist1,6);  //创建链表
+	if(!head)
+	{
+		printf("内存分配失败！ \n");
+		exit(1);
+	}
+	printf("原来的链表：\n");
+	printllist(head);   //输出原来链表
+	while(1)
+	{
+		printf("请输入要删除的邮寄编号 ==>");
+		scanf("%d",&num);   //读取邮寄编号
+		if(num != -1)
+		{
+			ptr = findnode(head,num);   //查找邮寄编号
+			if(!ptr)
+				printf("没有找到\n");
+			else
+			{
+				head = deletenode(head,ptr);   //删除此结点
+				printf("删除后链表：");
+				printllist(head);   //输出删除后链表
+			}
+		
+		}
+		else
+			exit(1);   
+	}
+	
+	freellist(head);   //释放链表内存
+	return 0;
+}
+
diff --git a/code/train/C/0116323_cortex_pmc.c b/code/train/C/0116323_cortex_pmc.c
new file mode 100644
index 0000000000000000000000000000000000000000..4e5c9b5f3d19892055a838a76e3dc6b0473d3b6d
--- /dev/null
+++ b/code/train/C/0116323_cortex_pmc.c
@@ -0,0 +1,114 @@
+/* Copyright (c) 2007 Microsoft
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Microsoft
+ *
+ * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``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 WASABI SYSTEMS, INC
+ * 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.
+ */
+
+
+/*
+ * support for ARM cortex Performance Monitor Counters
+ * based on arm11_pmc.c
+ */
+
+#include <sys/cdefs.h>
+/* __KERNEL_RCSID(0, "$NetBSD: cortex_pmc.c,v 1.2.16.1 2015/09/04 14:48:57 martin Exp $"); */
+#include "opt_perfctrs.h"
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>  
+#include <sys/time.h>
+#include <sys/timetc.h>
+
+#include <dev/clock_subr.h>
+
+#include <uvm/uvm_extern.h>
+
+#include <arm/armreg.h>
+#include <arm/cpufunc.h>
+#include <arm/arm32/machdep.h>
+
+#ifndef CORTEX_PMC_CCNT_HZ
+# define CORTEX_PMC_CCNT_HZ	400000000	/* 400MHz */
+#endif
+
+#define COUNTS_PER_USEC	(curcpu()->ci_data.cpu_cc_freq / (1000*1000))
+
+static const uint32_t counts_per_wrap = ~0UL - 1;
+
+/*
+ * enable the PMC CCNT for delay()
+ */
+void
+cortex_pmc_ccnt_init(void)
+{
+	if (curcpu()->ci_data.cpu_cc_freq == 0) {
+		curcpu()->ci_data.cpu_cc_freq = CORTEX_PMC_CCNT_HZ;
+	}
+}
+
+/*
+ * delay - for "at least" arg usec
+ *
+ *	NOTE: at 400MHz we are restricted to (uint32_t)~0 "counts"
+ *	if this is a problem, accumulate counts in LL vars
+ */
+void
+delay(u_int arg)
+{
+	uint32_t ctrl;
+	uint32_t cur;
+	uint32_t last;
+	uint32_t delta = 0;
+	uint32_t usecs = 0;
+	const uint32_t counts_per_usec = COUNTS_PER_USEC;
+	const uint32_t delay_arg_limit = ~0UL / counts_per_usec; /* about 10 sec */
+
+	if (arg > delay_arg_limit)
+		panic("%s: arg %u overflow, limit is %u usec\n",
+		    __func__, arg, delay_arg_limit);
+
+	last = armreg_pmccntr_read();
+	delta = usecs = 0;
+	while (arg > usecs) {
+		cur = armreg_pmccntr_read();
+		
+		/* overflow flag is moved to a separate register
+		   and is not read from PMC Control Register */
+		ctrl = armreg_pmovsr_read();
+		if (ctrl & CORTEX_CNTOFL_C) {
+		  /* Reset overflow flag for cycle counter in overflow register */
+			armreg_pmovsr_write(CORTEX_CNTOFL_C);
+			delta += (cur + (counts_per_wrap - last));
+		} else {
+			delta += (cur - last);
+		}
+		last = cur;
+		if (delta >= counts_per_usec) {
+			usecs += delta / counts_per_usec;
+			delta %= counts_per_usec;
+		}
+	}
+}
diff --git a/code/train/C/0116410_vehicle-speed.c b/code/train/C/0116410_vehicle-speed.c
new file mode 100644
index 0000000000000000000000000000000000000000..994d69c18fd367033d1cbc39df05eb4b16e2a01c
--- /dev/null
+++ b/code/train/C/0116410_vehicle-speed.c
@@ -0,0 +1,181 @@
+/**************************************************************************
+* Component Name: SensorsService
+* Author: Marco Residori <marco.residori@xse.de>
+*
+* Copyright (C) 2013, XS Embedded GmbH
+* 
+* License:
+* This Source Code Form is subject to the terms of the
+* Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with
+* this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*
+**************************************************************************/
+
+#include "globals.h"
+#include "vehicle-speed.h"
+#include "sns-meta-data.h"
+
+static pthread_mutex_t mutexCb  = PTHREAD_MUTEX_INITIALIZER;   //protects the callbacks
+static pthread_mutex_t mutexData = PTHREAD_MUTEX_INITIALIZER;  //protects the data
+
+static volatile VehicleSpeedCallback cbVehicleSpeed = 0;
+static TVehicleSpeedData gVehicleSpeedData = {0};
+
+static TSensorStatus gStatus = {0};
+static volatile SensorStatusCallback cbStatus = 0;
+
+bool iVehicleSpeedInit()
+{
+    pthread_mutex_lock(&mutexCb);
+    cbVehicleSpeed = 0;
+    pthread_mutex_unlock(&mutexCb);
+
+    pthread_mutex_lock(&mutexData);
+    gVehicleSpeedData.validityBits = 0;
+    pthread_mutex_unlock(&mutexData);
+
+    return true;
+}
+
+bool iVehicleSpeedDestroy()
+{
+    pthread_mutex_lock(&mutexCb);
+    cbVehicleSpeed = 0;
+    pthread_mutex_unlock(&mutexCb);
+
+    return true;
+}
+
+bool snsVehicleSpeedGetVehicleSpeedData(TVehicleSpeedData* vehicleSpeed)
+{
+    bool retval = false;
+    if(vehicleSpeed)
+    {
+        pthread_mutex_lock(&mutexData);
+        *vehicleSpeed = gVehicleSpeedData;
+        pthread_mutex_unlock(&mutexData);
+        retval = true;
+    }
+    return retval;
+}
+
+bool snsVehicleSpeedRegisterCallback(VehicleSpeedCallback callback)
+{
+    bool retval = false;
+
+    pthread_mutex_lock(&mutexCb);
+    //only if valid callback and not already registered
+    if(callback && !cbVehicleSpeed)
+    {
+        cbVehicleSpeed = callback;
+        retval = true;
+    }
+    pthread_mutex_unlock(&mutexCb);
+
+    return retval;
+}
+
+bool snsVehicleSpeedDeregisterCallback(VehicleSpeedCallback callback)
+{
+    bool retval = false;
+
+    pthread_mutex_lock(&mutexCb);
+    if((cbVehicleSpeed == callback) && callback)
+    {
+        cbVehicleSpeed = 0;
+        retval = true;
+    }
+    pthread_mutex_unlock(&mutexCb);
+
+    return retval;
+}
+
+bool snsVehicleSpeedGetMetaData(TSensorMetaData *data)
+{
+    bool retval = false;    
+    
+    if(data) 
+    {
+        pthread_mutex_lock(&mutexData);
+        *data = gSensorsMetaData[2];
+        pthread_mutex_unlock(&mutexData);
+        retval = true;
+    }
+
+    return retval;
+}
+
+void updateVehicleSpeedData(const TVehicleSpeedData vehicleSpeedData[], uint16_t numElements)
+{
+    if (vehicleSpeedData != NULL && numElements > 0)
+    {
+        pthread_mutex_lock(&mutexData);
+        gVehicleSpeedData = vehicleSpeedData[numElements-1];
+        pthread_mutex_unlock(&mutexData);
+        pthread_mutex_lock(&mutexCb);
+        if (cbVehicleSpeed)
+        {
+            cbVehicleSpeed(vehicleSpeedData, numElements);
+        }
+        pthread_mutex_unlock(&mutexCb);
+    }
+}
+
+bool snsVehicleSpeedGetStatus(TSensorStatus* status){
+    bool retval = false;
+    if(status)
+    {
+        pthread_mutex_lock(&mutexData);
+        *status = gStatus;
+        pthread_mutex_unlock(&mutexData);
+        retval = true;
+    }
+    return retval;
+}
+
+bool snsVehicleSpeedRegisterStatusCallback(SensorStatusCallback callback)
+{
+    bool retval = false;
+
+    pthread_mutex_lock(&mutexCb);
+    //only if valid callback and not already registered
+    if(callback && !cbStatus)
+    {
+        cbStatus = callback;
+        retval = true;
+    }
+    pthread_mutex_unlock(&mutexCb);
+
+    return retval;
+}
+
+bool snsVehicleSpeedDeregisterStatusCallback(SensorStatusCallback callback)
+{
+    bool retval = false;
+
+    pthread_mutex_lock(&mutexCb);
+    if((cbStatus == callback) && callback)
+    {
+        cbStatus = 0;
+        retval = true;
+    }
+    pthread_mutex_unlock(&mutexCb);
+
+    return retval;
+}
+
+void updateVehicleSpeedStatus(const TSensorStatus* status)
+{
+    if (status)
+    {
+        pthread_mutex_lock(&mutexData);
+        gStatus = *status;
+        pthread_mutex_unlock(&mutexData);
+        pthread_mutex_lock(&mutexCb);
+        if (cbStatus)
+        {
+            cbStatus(status);
+        }
+        pthread_mutex_unlock(&mutexCb);
+    }
+}
\ No newline at end of file
diff --git a/code/train/C/0117935_func_db.c b/code/train/C/0117935_func_db.c
new file mode 100644
index 0000000000000000000000000000000000000000..b56fef9f5e3937a4cb3cf8a63d0e44d69a0174cf
--- /dev/null
+++ b/code/train/C/0117935_func_db.c
@@ -0,0 +1,362 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2005-2006, Russell Bryant <russelb@clemson.edu> 
+ *
+ * func_db.c adapted from the old app_db.c, copyright by the following people 
+ * Copyright (C) 2005, Mark Spencer <markster@digium.com>
+ * Copyright (C) 2003, Jefferson Noxon <jeff@debian.org>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief Functions for interaction with the Asterisk database
+ *
+ * \author Russell Bryant <russelb@clemson.edu>
+ *
+ * \ingroup functions
+ */
+
+/*** MODULEINFO
+	<support_level>core</support_level>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include <regex.h>
+
+#include "asterisk/module.h"
+#include "asterisk/channel.h"
+#include "asterisk/pbx.h"
+#include "asterisk/utils.h"
+#include "asterisk/app.h"
+#include "asterisk/astdb.h"
+
+/*** DOCUMENTATION
+	<function name="DB" language="en_US">
+		<synopsis>
+			Read from or write to the Asterisk database.
+		</synopsis>
+		<syntax argsep="/">
+			<parameter name="family" required="true" />
+			<parameter name="key" required="true" />
+		</syntax>
+		<description>
+			<para>This function will read from or write a value to the Asterisk database.  On a
+			read, this function returns the corresponding value from the database, or blank
+			if it does not exist.  Reading a database value will also set the variable
+			DB_RESULT.  If you wish to find out if an entry exists, use the DB_EXISTS
+			function.</para>
+		</description>
+		<see-also>
+			<ref type="application">DBdel</ref>
+			<ref type="function">DB_DELETE</ref>
+			<ref type="application">DBdeltree</ref>
+			<ref type="function">DB_EXISTS</ref>
+		</see-also>
+	</function>
+	<function name="DB_EXISTS" language="en_US">
+		<synopsis>
+			Check to see if a key exists in the Asterisk database.
+		</synopsis>
+		<syntax argsep="/">
+			<parameter name="family" required="true" />
+			<parameter name="key" required="true" />
+		</syntax>
+		<description>
+			<para>This function will check to see if a key exists in the Asterisk
+			database. If it exists, the function will return <literal>1</literal>. If not,
+			it will return <literal>0</literal>.  Checking for existence of a database key will
+			also set the variable DB_RESULT to the key's value if it exists.</para>
+		</description>
+		<see-also>
+			<ref type="function">DB</ref>
+		</see-also>
+	</function>
+	<function name="DB_KEYS" language="en_US">
+		<synopsis>
+			Obtain a list of keys within the Asterisk database.
+		</synopsis>
+		<syntax>
+			<parameter name="prefix" />
+		</syntax>
+		<description>
+			<para>This function will return a comma-separated list of keys existing
+			at the prefix specified within the Asterisk database.  If no argument is
+			provided, then a list of key families will be returned.</para>
+		</description>
+	</function>
+	<function name="DB_DELETE" language="en_US">
+		<synopsis>
+			Return a value from the database and delete it.
+		</synopsis>
+		<syntax argsep="/">
+			<parameter name="family" required="true" />
+			<parameter name="key" required="true" />
+		</syntax>
+		<description>
+			<para>This function will retrieve a value from the Asterisk database
+			and then remove that key from the database. <variable>DB_RESULT</variable>
+			will be set to the key's value if it exists.</para>
+			<note>
+				<para>If <literal>live_dangerously</literal> in <literal>asterisk.conf</literal>
+				is set to <literal>no</literal>, this function can only be read from the
+				dialplan, and not directly from external protocols. It can, however, be
+				executed as a write operation (<literal>DB_DELETE(family, key)=ignored</literal>)</para>
+			</note>
+		</description>
+		<see-also>
+			<ref type="application">DBdel</ref>
+			<ref type="function">DB</ref>
+			<ref type="application">DBdeltree</ref>
+		</see-also>
+	</function>
+ ***/
+
+static int function_db_read(struct ast_channel *chan, const char *cmd,
+			    char *parse, char *buf, size_t len)
+{
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(family);
+		AST_APP_ARG(key);
+	);
+
+	buf[0] = '\0';
+
+	if (ast_strlen_zero(parse)) {
+		ast_log(LOG_WARNING, "DB requires an argument, DB(<family>/<key>)\n");
+		return -1;
+	}
+
+	AST_NONSTANDARD_APP_ARGS(args, parse, '/');
+
+	if (args.argc < 2) {
+		ast_log(LOG_WARNING, "DB requires an argument, DB(<family>/<key>)\n");
+		return -1;
+	}
+
+	if (ast_db_get(args.family, args.key, buf, len - 1)) {
+		ast_debug(1, "DB: %s/%s not found in database.\n", args.family, args.key);
+	} else {
+		pbx_builtin_setvar_helper(chan, "DB_RESULT", buf);
+	}
+
+	return 0;
+}
+
+static int function_db_write(struct ast_channel *chan, const char *cmd, char *parse,
+			     const char *value)
+{
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(family);
+		AST_APP_ARG(key);
+	);
+
+	if (ast_strlen_zero(parse)) {
+		ast_log(LOG_WARNING, "DB requires an argument, DB(<family>/<key>)=<value>\n");
+		return -1;
+	}
+
+	AST_NONSTANDARD_APP_ARGS(args, parse, '/');
+
+	if (args.argc < 2) {
+		ast_log(LOG_WARNING, "DB requires an argument, DB(<family>/<key>)=value\n");
+		return -1;
+	}
+
+	if (ast_db_put(args.family, args.key, value)) {
+		ast_log(LOG_WARNING, "DB: Error writing value to database.\n");
+	}
+
+	return 0;
+}
+
+static struct ast_custom_function db_function = {
+	.name = "DB",
+	.read = function_db_read,
+	.write = function_db_write,
+};
+
+static int function_db_exists(struct ast_channel *chan, const char *cmd,
+			      char *parse, char *buf, size_t len)
+{
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(family);
+		AST_APP_ARG(key);
+	);
+
+	buf[0] = '\0';
+
+	if (ast_strlen_zero(parse)) {
+		ast_log(LOG_WARNING, "DB_EXISTS requires an argument, DB(<family>/<key>)\n");
+		return -1;
+	}
+
+	AST_NONSTANDARD_APP_ARGS(args, parse, '/');
+
+	if (args.argc < 2) {
+		ast_log(LOG_WARNING, "DB_EXISTS requires an argument, DB(<family>/<key>)\n");
+		return -1;
+	}
+
+	if (ast_db_get(args.family, args.key, buf, len - 1)) {
+		strcpy(buf, "0");
+	} else {
+		pbx_builtin_setvar_helper(chan, "DB_RESULT", buf);
+		strcpy(buf, "1");
+	}
+
+	return 0;
+}
+
+static struct ast_custom_function db_exists_function = {
+	.name = "DB_EXISTS",
+	.read = function_db_exists,
+	.read_max = 2,
+};
+
+static int function_db_keys(struct ast_channel *chan, const char *cmd, char *parse, struct ast_str **result, ssize_t maxlen)
+{
+	size_t parselen = strlen(parse);
+	struct ast_db_entry *dbe, *orig_dbe;
+	struct ast_str *escape_buf = NULL;
+	const char *last = "";
+
+	/* Remove leading and trailing slashes */
+	while (parse[0] == '/') {
+		parse++;
+		parselen--;
+	}
+	while (parse[parselen - 1] == '/') {
+		parse[--parselen] = '\0';
+	}
+
+	ast_str_reset(*result);
+
+	/* Nothing within the database at that prefix? */
+	if (!(orig_dbe = dbe = ast_db_gettree(parse, NULL))) {
+		return 0;
+	}
+
+	for (; dbe; dbe = dbe->next) {
+		/* Find the current component */
+		char *curkey = &dbe->key[parselen + 1], *slash;
+		if (*curkey == '/') {
+			curkey++;
+		}
+		/* Remove everything after the current component */
+		if ((slash = strchr(curkey, '/'))) {
+			*slash = '\0';
+		}
+
+		/* Skip duplicates */
+		if (!strcasecmp(last, curkey)) {
+			continue;
+		}
+		last = curkey;
+
+		if (orig_dbe != dbe) {
+			ast_str_append(result, maxlen, ",");
+		}
+		ast_str_append_escapecommas(result, maxlen, curkey, strlen(curkey));
+	}
+	ast_db_freetree(orig_dbe);
+	ast_free(escape_buf);
+	return 0;
+}
+
+static struct ast_custom_function db_keys_function = {
+	.name = "DB_KEYS",
+	.read2 = function_db_keys,
+};
+
+static int function_db_delete(struct ast_channel *chan, const char *cmd,
+			      char *parse, char *buf, size_t len)
+{
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(family);
+		AST_APP_ARG(key);
+	);
+
+	buf[0] = '\0';
+
+	if (ast_strlen_zero(parse)) {
+		ast_log(LOG_WARNING, "DB_DELETE requires an argument, DB_DELETE(<family>/<key>)\n");
+		return -1;
+	}
+
+	AST_NONSTANDARD_APP_ARGS(args, parse, '/');
+
+	if (args.argc < 2) {
+		ast_log(LOG_WARNING, "DB_DELETE requires an argument, DB_DELETE(<family>/<key>)\n");
+		return -1;
+	}
+
+	if (ast_db_get(args.family, args.key, buf, len - 1)) {
+		ast_debug(1, "DB_DELETE: %s/%s not found in database.\n", args.family, args.key);
+	} else {
+		if (ast_db_del(args.family, args.key)) {
+			ast_debug(1, "DB_DELETE: %s/%s could not be deleted from the database\n", args.family, args.key);
+		}
+	}
+
+	pbx_builtin_setvar_helper(chan, "DB_RESULT", buf);
+
+	return 0;
+}
+
+/*!
+ * \brief Wrapper to execute DB_DELETE from a write operation. Allows execution
+ * even if live_dangerously is disabled.
+ */
+static int function_db_delete_write(struct ast_channel *chan, const char *cmd, char *parse,
+	const char *value)
+{
+	/* Throwaway to hold the result from the read */
+	char buf[128];
+	return function_db_delete(chan, cmd, parse, buf, sizeof(buf));
+}
+
+static struct ast_custom_function db_delete_function = {
+	.name = "DB_DELETE",
+	.read = function_db_delete,
+	.write = function_db_delete_write,
+};
+
+static int unload_module(void)
+{
+	int res = 0;
+
+	res |= ast_custom_function_unregister(&db_function);
+	res |= ast_custom_function_unregister(&db_exists_function);
+	res |= ast_custom_function_unregister(&db_delete_function);
+	res |= ast_custom_function_unregister(&db_keys_function);
+
+	return res;
+}
+
+static int load_module(void)
+{
+	int res = 0;
+
+	res |= ast_custom_function_register_escalating(&db_function, AST_CFE_BOTH);
+	res |= ast_custom_function_register(&db_exists_function);
+	res |= ast_custom_function_register_escalating(&db_delete_function, AST_CFE_READ);
+	res |= ast_custom_function_register(&db_keys_function);
+
+	return res;
+}
+
+AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Database (astdb) related dialplan functions");
diff --git a/code/train/C/0118079_animation.c b/code/train/C/0118079_animation.c
new file mode 100644
index 0000000000000000000000000000000000000000..36a06c8ad73ee9fdddc12a51a5e62fd47223e1b7
--- /dev/null
+++ b/code/train/C/0118079_animation.c
@@ -0,0 +1,164 @@
+#define _GNU_SOURCE
+#include "testParameters.h"
+#include "animation.h"
+#include <stdbool.h>
+#include <sched.h>
+#include <pthread.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+
+
+void draw_ball(int x, int y, int c)
+{
+	circlefill(screen, x, y, L, c);
+}
+
+void print_id_task(int id, int x, int y, int color){
+
+	textprintf_ex(screen, font, x, y, color, BGC, "T%d", id);
+
+}
+
+void periodicBall_testParam() {
+
+	int	i, j = 0;
+	int dcol = BGC;
+	int *pun_col;
+	int color;
+	int x, ox, xStart;
+	int y, oy;
+	float vel = VELX;
+    float tx = 0.0, dt;
+
+    i = ptask_get_index();
+    pun_col = ptask_get_argument();
+    color = *pun_col;
+
+    x 	= ox = xStart = XMIN ;
+    y 	= oy = BASE -1 + 20 +(i * 4 * L);
+    dt = ptask_get_period(i, MILLI) / 100.;
+
+    /* print task's id on screen on the right of task animation */
+    pthread_mutex_lock(&mxa);
+    print_id_task(i, 5, y , color);
+    pthread_mutex_unlock(&mxa);
+
+    sample[i] = 0;
+	while (1) {
+
+		/* update position x of the ball */
+		x = xStart + vel * tx;
+
+		if (x > XMAX) {
+					tx 		= 0.0;
+					xStart 	= XMAX;
+					vel		= -vel;
+					x 		= xStart;
+			}
+		if (x < XMIN) {
+					tx 		= 0.0;
+					xStart 	= XMIN;
+					vel		= -vel;
+					x 		= xStart ;
+			}
+
+		pthread_mutex_lock(&mxa);
+		draw_ball( ox,	y , BGC);
+		draw_ball( x, 	y , color );
+		pthread_mutex_unlock(&mxa);
+
+		dt = ptask_get_period(i, MILLI) / 100.;
+		tx += dt;
+		ox = x;
+
+		if (ptask_deadline_miss()) {
+						/* draw with a different color a circle that represent deadline miss */
+						dcol = (dcol + 1) % 15;
+						pthread_mutex_lock(&mxa);
+						draw_ball( XMAX + 15, y , dcol );
+						pthread_mutex_unlock(&mxa);
+		}
+
+		ptask_wait_for_period();
+
+		/* get sample of start time and next_activation time (not more than MAX_SAMPLE)*/
+		if (j < MAX_SAMPLE) {
+			start_time[i][j] = ptask_gettime(MILLI);
+			v_next_at[i][j] = ptask_get_nextactivation(MILLI);
+			sample[i]++;
+			j++;
+		}
+	}
+}
+
+
+void periodicBall_testParamDEP_PER() {
+
+	int	i, j = 0;
+	int dcol = BGC;
+	int *pun_col;
+	int color;
+	int x, ox, xStart ;
+	int y, oy;
+	float vel= VELX;
+    float tx = 0.0;
+    float dt = 20.0 / 100.0;  	/* dt is constant */
+
+    i = ptask_get_index();
+    pun_col = ptask_get_argument();
+    color = *pun_col;
+
+    x 	= ox = xStart = XMIN ;
+    y 	= oy = BASE -1 + 20 +(i * 4 * L);
+
+    /* print task's id on screen on the right of task animation */
+    pthread_mutex_lock(&mxa);
+    print_id_task(i, 5, y , color);
+    pthread_mutex_unlock(&mxa);
+
+    sample[i] = 0;
+	while (1) {
+
+		/* update position x of the ball */
+		x = xStart + vel * tx;
+
+		if (x > XMAX) {
+					tx 		= 0.0;
+					xStart 	= XMAX;
+					vel		= -vel;
+					x 		= xStart;
+			}
+		if (x < XMIN) {
+					tx 		= 0.0;
+					xStart 	= XMIN;
+					vel		= -vel;
+					x 		= xStart ;
+		}
+
+		pthread_mutex_lock(&mxa);
+		draw_ball( ox,	y , BGC);
+		draw_ball( x, 	y , color );
+		pthread_mutex_unlock(&mxa);
+
+		tx += dt;
+		ox = x;
+
+		if (ptask_deadline_miss()) {
+						/* draw with a different color a circle that represent deadline miss */
+						dcol = (dcol + 1) % 15;
+						pthread_mutex_lock(&mxa);
+						draw_ball( XMAX + 15, y , dcol );
+						pthread_mutex_unlock(&mxa);
+		}
+
+		ptask_wait_for_period();
+
+		/* get sample of start time and next_activation time (not more than MAX_SAMPLE)*/
+		if (j < MAX_SAMPLE) {
+			start_time[i][j] = ptask_gettime(MILLI);
+			v_next_at[i][j] = ptask_get_nextactivation(MILLI);
+			sample[i]++;
+			j++;
+		}
+	}
+}
diff --git a/code/train/C/0118263_plugin_idlejitter.c b/code/train/C/0118263_plugin_idlejitter.c
new file mode 100644
index 0000000000000000000000000000000000000000..c59541ecba4b71206b607352b1281515e12d613e
--- /dev/null
+++ b/code/train/C/0118263_plugin_idlejitter.c
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "plugin_idlejitter.h"
+
+#define CPU_IDLEJITTER_SLEEP_TIME_MS 20
+
+static void cpuidlejitter_main_cleanup(void *ptr) {
+    struct netdata_static_thread *static_thread = (struct netdata_static_thread *)ptr;
+    static_thread->enabled = NETDATA_MAIN_THREAD_EXITING;
+
+    info("cleaning up...");
+
+    static_thread->enabled = NETDATA_MAIN_THREAD_EXITED;
+}
+
+void *cpuidlejitter_main(void *ptr) {
+    netdata_thread_cleanup_push(cpuidlejitter_main_cleanup, ptr);
+
+    usec_t sleep_ut = config_get_number("plugin:idlejitter", "loop time in ms", CPU_IDLEJITTER_SLEEP_TIME_MS) * USEC_PER_MS;
+    if(sleep_ut <= 0) {
+        config_set_number("plugin:idlejitter", "loop time in ms", CPU_IDLEJITTER_SLEEP_TIME_MS);
+        sleep_ut = CPU_IDLEJITTER_SLEEP_TIME_MS * USEC_PER_MS;
+    }
+
+    RRDSET *st = rrdset_create_localhost(
+            "system"
+            , "idlejitter"
+            , NULL
+            , "idlejitter"
+            , NULL
+            , "CPU Idle Jitter"
+            , "microseconds lost/s"
+            , "idlejitter.plugin"
+            , NULL
+            , NETDATA_CHART_PRIO_SYSTEM_IDLEJITTER
+            , localhost->rrd_update_every
+            , RRDSET_TYPE_AREA
+    );
+    RRDDIM *rd_min = rrddim_add(st, "min", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
+    RRDDIM *rd_max = rrddim_add(st, "max", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
+    RRDDIM *rd_avg = rrddim_add(st, "average", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
+
+    usec_t update_every_ut = localhost->rrd_update_every * USEC_PER_SEC;
+    struct timeval before, after;
+    unsigned long long counter;
+
+    for(counter = 0; 1 ;counter++) {
+        int iterations = 0;
+        usec_t error_total = 0,
+                error_min = 0,
+                error_max = 0,
+                elapsed = 0;
+
+        if(netdata_exit) break;
+
+        while(elapsed < update_every_ut) {
+            now_monotonic_high_precision_timeval(&before);
+            sleep_usec(sleep_ut);
+            now_monotonic_high_precision_timeval(&after);
+
+            usec_t dt = dt_usec(&after, &before);
+            elapsed += dt;
+
+            usec_t error = dt - sleep_ut;
+            error_total += error;
+
+            if(unlikely(!iterations))
+                error_min = error;
+            else if(error < error_min)
+                error_min = error;
+
+            if(error > error_max)
+                error_max = error;
+
+            iterations++;
+        }
+
+        if(netdata_exit) break;
+
+        if(iterations) {
+            if (likely(counter)) rrdset_next(st);
+            rrddim_set_by_pointer(st, rd_min, error_min);
+            rrddim_set_by_pointer(st, rd_max, error_max);
+            rrddim_set_by_pointer(st, rd_avg, error_total / iterations);
+            rrdset_done(st);
+        }
+    }
+
+    netdata_thread_cleanup_pop(1);
+    return NULL;
+}
+
diff --git a/code/train/C/0118640_random_seed.c b/code/train/C/0118640_random_seed.c
new file mode 100644
index 0000000000000000000000000000000000000000..f7f4f938a234ba0c420bdc8102a9b9ea53fa6b50
--- /dev/null
+++ b/code/train/C/0118640_random_seed.c
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2009 Baptiste Coudurier <baptiste.coudurier@gmail.com>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "config.h"
+
+#if HAVE_IO_H
+#include <io.h>
+#endif
+#if HAVE_CRYPTGENRANDOM
+#include <windows.h>
+#include <wincrypt.h>
+#endif
+
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <fcntl.h>
+#include <math.h>
+#include <time.h>
+#include <string.h>
+#include "avassert.h"
+#include "internal.h"
+#include "intreadwrite.h"
+#include "timer.h"
+#include "random_seed.h"
+#include "sha.h"
+
+#ifndef TEST
+#define TEST 0
+#endif
+
+static int read_random(uint32_t *dst, const char *file)
+{
+#if HAVE_UNISTD_H
+    int fd = avpriv_open(file, O_RDONLY);
+    int err = -1;
+
+    if (fd == -1)
+        return -1;
+    err = read(fd, dst, sizeof(*dst));
+    close(fd);
+
+    return err;
+#else
+    return -1;
+#endif
+}
+
+static uint32_t get_generic_seed(void)
+{
+    uint8_t tmp[120];
+    struct AVSHA *sha = (void*)tmp;
+    clock_t last_t  = 0;
+    static uint64_t i = 0;
+    static uint32_t buffer[512] = { 0 };
+    unsigned char digest[20];
+    uint64_t last_i = i;
+
+    av_assert0(sizeof(tmp) >= av_sha_size);
+
+    if(TEST){
+        memset(buffer, 0, sizeof(buffer));
+        last_i = i = 0;
+    }else{
+#ifdef AV_READ_TIME
+        buffer[13] ^= AV_READ_TIME();
+        buffer[41] ^= AV_READ_TIME()>>32;
+#endif
+    }
+
+    for (;;) {
+        clock_t t = clock();
+
+        if (last_t == t) {
+            buffer[i & 511]++;
+        } else {
+            buffer[++i & 511] += (t - last_t) % 3294638521U;
+            if (last_i && i - last_i > 4 || i - last_i > 64 || TEST && i - last_i > 8)
+                break;
+        }
+        last_t = t;
+    }
+
+    if(TEST)
+        buffer[0] = buffer[1] = 0;
+
+    av_sha_init(sha, 160);
+    av_sha_update(sha, (const uint8_t *)buffer, sizeof(buffer));
+    av_sha_final(sha, digest);
+    return AV_RB32(digest) + AV_RB32(digest + 16);
+}
+
+uint32_t av_get_random_seed(void)
+{
+    uint32_t seed;
+
+#if HAVE_CRYPTGENRANDOM
+    HCRYPTPROV provider;
+    if (CryptAcquireContext(&provider, NULL, NULL, PROV_RSA_FULL,
+                            CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
+        BOOL ret = CryptGenRandom(provider, sizeof(seed), (PBYTE) &seed);
+        CryptReleaseContext(provider, 0);
+        if (ret)
+            return seed;
+    }
+#endif
+
+#ifdef __amigaos4__
+    if (read_random(&seed, "RANDOM:") == sizeof(seed))
+        return seed;
+#else
+    if (read_random(&seed, "/dev/urandom") == sizeof(seed))
+        return seed;
+    if (read_random(&seed, "/dev/random")  == sizeof(seed))
+        return seed;
+#endif
+    return get_generic_seed();
+}
+
+#if TEST
+#undef printf
+#define N 256
+#include <stdio.h>
+
+int main(void)
+{
+    int i, j, retry;
+    uint32_t seeds[N];
+
+    for (retry=0; retry<3; retry++){
+        for (i=0; i<N; i++){
+            seeds[i] = av_get_random_seed();
+            for (j=0; j<i; j++)
+                if (seeds[j] == seeds[i])
+                    goto retry;
+        }
+        printf("seeds OK\n");
+        return 0;
+        retry:;
+    }
+    printf("FAIL at %d with %X\n", j, seeds[j]);
+    return 1;
+}
+#endif
diff --git a/code/train/C/0118652_7-performance.c b/code/train/C/0118652_7-performance.c
new file mode 100644
index 0000000000000000000000000000000000000000..3a01a253b2039b682fed98f35160f70714eb46ba
--- /dev/null
+++ b/code/train/C/0118652_7-performance.c
@@ -0,0 +1,176 @@
+/*
+* Copyright (c) Bull S.A.  2007 All Rights Reserved.
+*
+* This program is free software; you can redistribute it and/or modify it
+* under the terms of version 2 of the GNU General Public License as
+* published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it would be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+*
+* Further, this software is distributed without any warranty that it is
+* free of the rightful claim of any third person regarding infringement
+* or the like.  Any license provided herein, whether implied or
+* otherwise, applies only to this software file.  Patent licenses, if
+* any, provided herein do not apply to combinations of this program with
+* other software, or any other product whatsoever.
+*
+* You should have received a copy of the GNU General Public License along
+* with this program; if not, write the Free Software Foundation, Inc., 59
+* Temple Place - Suite 330, Boston MA 02111-1307, USA.
+*
+* History:
+* Created by: Cyril Lacabanne (Cyril.Lacabanne@bull.net)
+*
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <tirpc/rpc/rpc.h>
+
+//Standard define
+#define PROCNUM 1
+#define VERSNUM 1
+
+//Set number of test call
+int maxIter;
+
+double average(double *tbl)
+{
+	//Return average of values in tbl
+	int i;
+	double rslt = 0;
+
+	for (i = 0; i < maxIter; i++)
+	{
+		rslt += tbl[i];
+	}
+	rslt = rslt / maxIter;
+	return rslt;
+}
+
+double mini(double *tbl)
+{
+	//Return minimal of values in tbl
+	int i;
+	double rslt = tbl[0];
+
+	for (i = 0; i < maxIter; i++)
+	{
+		if (rslt > tbl[i])
+			rslt = tbl[i];
+	}
+	return rslt;
+}
+
+double maxi(double *tbl)
+{
+	//Return maximal of values in tbl
+	int i;
+	double rslt = tbl[0];
+
+	for (i = 0; i < maxIter; i++)
+	{
+		if (rslt < tbl[i])
+			rslt = tbl[i];
+	}
+	return rslt;
+}
+
+int main(int argn, char *argc[])
+{
+	//Program parameters : argc[1] : HostName or Host IP
+	//					   argc[2] : Server Program Number
+	//					   argc[3] : Number of test call
+	//					   other arguments depend on test case
+
+	//run_mode can switch into stand alone program or program launch by shell script
+	//1 : stand alone, debug mode, more screen information
+	//0 : launch by shell script as test case, only one printf -> result status
+	int run_mode = 0;
+	int test_status = 0; //Default test result set to FAILED
+	int i;
+	double *resultTbl;
+	struct timeval tv1,tv2;
+    struct timezone tz;
+    long long diff;
+    double rslt;
+	int progNum = atoi(argc[2]);
+    int sndVar = 0;
+    int recVar = -1;
+    CLIENT *client = NULL;
+	struct netconfig *nconf = NULL;
+	struct timeval tv;
+	enum clnt_stat cs;
+
+	//Test initialisation
+    maxIter = atoi(argc[3]);
+    resultTbl = (double *)malloc(maxIter * sizeof(double));
+
+    nconf = getnetconfigent("udp");
+
+    if ((struct netconfig *)nconf == NULL)
+    {
+    	//Test failed
+    	printf("5\n");
+    	return 5;
+    }
+
+    tv.tv_sec = 1;
+	tv.tv_usec = 1;
+
+    client = clnt_tp_create_timed(argc[1], progNum,
+                                  VERSNUM, (struct netconfig *)nconf, &tv);
+
+    if (client == NULL)
+    {
+    	printf("5\n");
+    	return 5;
+    }
+
+	//Call tested function several times
+	for (i = 0; i < maxIter; i++)
+	{
+		//Tic
+		gettimeofday(&tv1, &tz);
+
+		//Call function
+		cs = clnt_call(client, PROCNUM,
+						 (xdrproc_t)xdr_int, (char *)&sndVar, // xdr_in
+                	     (xdrproc_t)xdr_int, (char *)&recVar, // xdr_out
+                    	 tv);
+
+		//Toc
+		gettimeofday(&tv2, &tz);
+
+		//Add function execution time (toc-tic)
+		diff = (tv2.tv_sec-tv1.tv_sec) * 1000000L + (tv2.tv_usec-tv1.tv_usec);
+		rslt = (double)diff / 1000;
+
+    	if (cs == RPC_SUCCESS)
+    	{
+    		resultTbl[i] = rslt;
+    	}
+    	else
+    	{
+    		test_status = 1;
+    		break;
+    	}
+
+    	if (run_mode)
+    	{
+    		fprintf(stderr, "lf time  = %lf usecn\n", resultTbl[i]);
+    	}
+	}
+
+	//This last printf gives the result status to the tests suite
+	//normally should be 0: test has passed or 1: test has failed
+	printf("%d\n", test_status);
+	printf("%lf %d\n", average(resultTbl), maxIter);
+	printf("%lf\n", mini(resultTbl));
+	printf("%lf\n", maxi(resultTbl));
+
+	return test_status;
+}
\ No newline at end of file
diff --git a/code/train/C/0118943_simulator.c b/code/train/C/0118943_simulator.c
new file mode 100644
index 0000000000000000000000000000000000000000..b863d13a2a6d7bb44842d6e0c40ddcc3a62b1dd5
--- /dev/null
+++ b/code/train/C/0118943_simulator.c
@@ -0,0 +1,147 @@
+/*
+  simulator.c - functions to simulate how the buffer is emptied and the
+    stepper interrupt is called
+
+  Part of Grbl Simulator
+
+  Copyright (c) 2012-2014 Jens Geisler
+  Copyright (c) 2014-2015 Adam Shelly
+
+  Grbl 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.
+
+  Grbl 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 Grbl.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "simulator.h"
+#include "avr/eeprom.h"
+#include "avr/io.h"
+#include "avr/interrupt.h"
+
+
+sim_vars_t sim={0};
+
+enum {sh_INIT,sh_TICK,sh_BYTE,sh_EXIT};
+void sim_nop(void) {}
+sim_hook_fp sim_hook[4]={sim_nop,sim_nop,sim_nop,sim_nop};
+void sim_add_hooks(sim_hook_fp initialize, 
+                   sim_hook_fp per_tick,
+                   sim_hook_fp per_byte,
+                   sim_hook_fp shutdown)
+{
+  if (initialize) sim_hook[sh_INIT]=initialize;
+  if (per_tick) sim_hook[sh_TICK]=per_tick;
+  if (per_byte) sim_hook[sh_BYTE]=per_byte;
+  if (shutdown) sim_hook[sh_EXIT]=shutdown;
+}
+
+//setup 
+void init_simulator(float time_multiplier) {
+  sim.speedup = time_multiplier;
+
+  sim_hook[sh_INIT]();
+}
+
+
+
+//shutdown simulator - call exit hooks, save eeprom
+void shutdown_simulator() {
+  sim_hook[sh_EXIT]();
+  eeprom_close();
+}
+
+
+void simulate_hardware(bool do_serial){
+
+  //do one tick
+  sim.masterclock++;
+  sim.sim_time = (float)sim.masterclock/F_CPU;
+
+  timer_interrupts();
+  
+  if (do_serial) simulate_serial();
+
+  //TODO:
+  //  check limit pins,  call pinchange interrupt if enabled
+  //  can ignore pinout int vect - hw start/hold not supported
+
+}
+
+//runs the hardware simulator at the desired rate until sim.exit is set
+void sim_loop(){
+  uint64_t simulated_ticks=0;
+  uint32_t ns_prev = platform_ns();
+  uint64_t next_byte_tick = F_CPU;   //wait 1 sec before reading IO.
+
+
+  while (sim.exit != exit_OK  ) { //don't quit until idle
+
+   if (sim.speedup) {
+    //calculate how many ticks to do.
+    uint32_t ns_now = platform_ns();
+    uint32_t ns_elapsed = (ns_now-ns_prev)*sim.speedup; //todo: try multipling nsnow
+    simulated_ticks += F_CPU/1e9*ns_elapsed;
+    ns_prev = ns_now;
+   }
+   else {
+    simulated_ticks++;  //as fast as possible
+   }
+    
+   while (sim.masterclock < simulated_ticks){
+
+    //only read serial port as fast as the baud rate allows
+    bool read_serial = (sim.masterclock >= next_byte_tick);
+
+    //do low level hardware
+    simulate_hardware(read_serial);
+
+    // do app-specific per-tick processing
+    sim_hook[sh_TICK]();
+    
+    if (read_serial){
+      //decode baud rate. //TODO: maybe do this only once, baud shouldn't change on the fly
+      sim.baud_ticks = 2*((UBRR0H<<8)+UBRR0L)+1;
+      if (UCSR0A & (1<<U2X0)) { sim.baud_ticks*=2; }
+
+      next_byte_tick+=sim.baud_ticks;
+      // do app-specific per-byte processing
+      sim_hook[sh_BYTE]();
+    }
+   }
+
+   platform_sleep(0); //yield
+  }
+}
+
+
+//print serial output to args.serial_out_file
+void sim_serial_out(uint8_t data){
+  static uint8_t buf[128]={0};
+  static uint8_t len=0;
+  static bool continuation = 0;
+
+  buf[len++]=data;
+  // print when we get to newline or run out of buffer
+  if(data=='\n' || data=='\r' || len>=127) {
+   if (args.comment_char && !continuation){
+    fprintf(args.serial_out_file,"%c ",args.comment_char);
+   }
+   buf[len]=0;
+   fprintf(args.serial_out_file,"%s",buf);
+   //don't print comment on next line if we are just printing to avoid buffer overflow
+   continuation = (len>=128); 
+   len=0;
+  }
+}
+
diff --git a/code/train/C/0119449_dumpkeys.c b/code/train/C/0119449_dumpkeys.c
new file mode 100644
index 0000000000000000000000000000000000000000..736ca35e6015f2fb23e4b57f8963edad7ab29840
--- /dev/null
+++ b/code/train/C/0119449_dumpkeys.c
@@ -0,0 +1,196 @@
+/*
+ * dumpkeys.c
+ *
+ * derived from version 0.81 - aeb@cwi.nl
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <unistd.h>
+#include <linux/types.h>
+#include <linux/kd.h>
+#include <linux/keyboard.h>
+#include <sys/ioctl.h>
+#include <string.h>
+#include <errno.h>
+#include "ksyms.h"
+#include "getfd.h"
+#include "modifiers.h"
+#include "nls.h"
+#include "version.h"
+
+static int fd;
+
+static void __attribute__ ((noreturn))
+usage(void) {
+	fprintf(stderr, _("dumpkeys version %s"), PACKAGE_VERSION);
+	fprintf(stderr, _("\
+\n\
+usage: dumpkeys [options...]\n\
+\n\
+valid options are:\n\
+\n\
+	-h --help	    display this help text\n\
+	-i --short-info	    display information about keyboard driver\n\
+	-l --long-info	    display above and symbols known to loadkeys\n\
+	-n --numeric	    display keytable in hexadecimal notation\n\
+	-f --full-table	    don't use short-hand notations, one row per keycode\n\
+	-1 --separate-lines one line per (modifier,keycode) pair\n\
+	   --funcs-only	    display only the function key strings\n\
+	   --keys-only	    display only key bindings\n\
+	   --compose-only   display only compose key combinations\n\
+	-c --charset="));
+	lk_list_charsets(stderr);
+	fprintf(stderr, _("\
+			    interpret character action codes to be from the\n\
+			    specified character set\n\
+"));
+	exit(1);
+}
+
+int
+main (int argc, char *argv[]) {
+	const char *short_opts = "hilvsnf1tkdS:c:V";
+	const struct option long_opts[] = {
+		{ "help",	no_argument,		NULL, 'h' },
+		{ "short-info",	no_argument,		NULL, 'i' },
+		{ "long-info",	no_argument,		NULL, 'l' },
+		{ "numeric",	no_argument,		NULL, 'n' },
+		{ "full-table",	no_argument,		NULL, 'f' },
+		{ "separate-lines",no_argument,		NULL, '1' },
+		{ "shape",	required_argument,	NULL, 'S' },
+		{ "funcs-only",	no_argument,		NULL, 't' },
+		{ "keys-only",	no_argument,		NULL, 'k' },
+		{ "compose-only",no_argument,		NULL, 'd' },
+		{ "charset",	required_argument,	NULL, 'c' },
+		{ "verbose",	no_argument,		NULL, 'v' },
+		{ "version",	no_argument,		NULL, 'V' },
+		{ NULL,	0, NULL, 0 }
+	};
+	int c, rc;
+	int kbd_mode;
+
+	char long_info = 0;
+	char short_info = 0;
+	char numeric = 0;
+	lk_table_shape table = LK_SHAPE_DEFAULT;
+	char funcs_only = 0;
+	char keys_only = 0;
+	char diac_only = 0;
+
+	struct lk_ctx *ctx;
+
+	set_progname(argv[0]);
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE_NAME, LOCALEDIR);
+	textdomain(PACKAGE_NAME);
+
+	ctx = lk_init();
+	if (!ctx) {
+		exit(EXIT_FAILURE);
+	}
+
+	while ((c = getopt_long(argc, argv,
+		short_opts, long_opts, NULL)) != -1) {
+		switch (c) {
+			case 'i':
+				short_info = 1;
+				break;
+			case 's':
+			case 'l':
+				long_info = 1;
+				break;
+			case 'n':
+				numeric = 1;
+				break;
+			case 'f':
+				table = LK_SHAPE_FULL_TABLE;
+				break;
+			case '1':
+				table = LK_SHAPE_SEPARATE_LINES;
+				break;
+			case 'S':
+				table = atoi(optarg);
+				break;
+			case 't':
+				funcs_only = 1;
+				break;
+			case 'k':
+				keys_only = 1;
+				break;
+			case 'd':
+				diac_only = 1;
+				break;
+			case 'v':
+				lk_set_log_priority(ctx, LOG_INFO);
+				break;
+			case 'c':
+				if ((lk_set_charset(ctx, optarg)) != 0) {
+					fprintf(stderr, _("unknown charset %s - ignoring charset request\n"),
+						optarg);
+					usage();
+				}
+				printf("charset \"%s\"\n", optarg);
+				break;
+			case 'V':
+				print_version_and_exit();
+			case 'h':
+			case '?':
+				usage();
+		}
+	}
+
+	if (optind < argc)
+		usage();
+
+	fd = getfd(NULL);
+
+	/* check whether the keyboard is in Unicode mode */
+	if (ioctl(fd, KDGKBMODE, &kbd_mode)) {
+		fprintf(stderr, _("%s: error reading keyboard mode: %m\n"),
+			progname);
+		exit(EXIT_FAILURE);
+	}
+
+	if (kbd_mode == K_UNICODE) {
+		lk_set_parser_flags(ctx, LK_FLAG_PREFER_UNICODE);
+	}
+
+	if ((rc = lk_kernel_keymap(ctx, fd)) < 0)
+		goto fail;
+
+	if (short_info || long_info) {
+		lk_dump_summary(ctx, stdout, fd);
+
+		if (long_info) {
+			printf(_("Symbols recognized by %s:\n(numeric value, symbol)\n\n"),
+				progname);
+			lk_dump_symbols(ctx, stdout);
+		}
+		exit(EXIT_SUCCESS);
+	}
+
+#ifdef KDGKBDIACR
+	if (!diac_only) {
+#endif
+	if (!funcs_only) {
+		lk_dump_keymap(ctx, stdout, table, numeric);
+	}
+#ifdef KDGKBDIACR
+	}
+
+	if (!funcs_only && !keys_only)
+		lk_dump_diacs(ctx, stdout);
+#endif
+
+ fail:	lk_free(ctx);
+	close(fd);
+
+	if (rc < 0)
+		exit(EXIT_FAILURE);
+
+	exit(EXIT_SUCCESS);
+}
diff --git a/code/train/C/0119828_preempt_timing.c b/code/train/C/0119828_preempt_timing.c
new file mode 100644
index 0000000000000000000000000000000000000000..b84d5469242adea1b1818c2fe859498810645601
--- /dev/null
+++ b/code/train/C/0119828_preempt_timing.c
@@ -0,0 +1,159 @@
+/******************************************************************************
+ *
+ *   Copyright © International Business Machines  Corp., 2006, 2008
+ *
+ *   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
+ *
+ * NAME
+ *      preempt_timing.c
+ *
+ * DESCRIPTION
+ *      This program indicated the preemption delays that may be encountered
+ *      by realtime apps. The program runs with the scheduling policy of
+ *      SCHED_FIFO at a maximum SCHED_FIFO priority. It is bound to a single
+ *      processor and its address space is locked as well. It makes successive
+ *      calls to the gettimeofday() function(via inlined assembly to read the
+ *      TSC).The value returned between two such consecutive calls is reported
+ *	as the latency.
+ *      The maximum, minimum and average delays are reported for x pairs of such
+ *      calls.
+ *
+ * USAGE:
+ *      Use run_auto.sh script in current directory to build and run test.
+ *
+ * AUTHOR
+ *
+ *
+ * HISTORY
+ *
+ *
+ *****************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sched.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/mman.h>
+#include <stdint.h>
+#include <librttest.h>
+
+#include "tst_tsc.h"
+
+#define ITERATIONS 1000000ULL
+#define INTERVALS 10
+
+void usage(void)
+{
+	rt_help();
+	printf("preempt_timing specific options:\n");
+}
+
+int parse_args(int c, char *v)
+{
+
+	int handled = 1;
+	switch (c) {
+	case 'h':
+		usage();
+		exit(0);
+	default:
+		handled = 0;
+		break;
+	}
+	return handled;
+}
+
+unsigned long long sample_list[ITERATIONS];
+int main(int argc, char *argv[])
+{
+	unsigned long long i, j, delta, min, max, avg;
+	struct sched_param param;
+	cpu_set_t mask;
+	int err;
+
+#ifdef TSC_UNSUPPORTED
+	printf("Error: test cannot be executed on an arch wihout TSC.\n");
+	return ENOTSUP;
+#endif
+
+	max = avg = 0;
+	min = -1;
+	setup();
+
+	rt_init("h", parse_args, argc, argv);
+
+	/* switch to SCHED_FIFO 99 */
+	param.sched_priority = sched_get_priority_max(SCHED_FIFO);
+	err = sched_setscheduler(0, SCHED_FIFO, &param);
+
+	/* Check that the user has the appropriate privileges */
+	if (err) {
+		if (errno == EPERM) {
+			fprintf(stderr,
+				"This program runs with a scheduling policy of SCHED_FIFO at priority %d\n",
+				param.sched_priority);
+			fprintf(stderr,
+				"You don't have the necessary privileges to create such a real-time process.\n");
+		} else {
+			fprintf(stderr, "Failed to set scheduler, errno %d\n",
+				errno);
+		}
+		exit(1);
+	}
+
+	/* BIND TO A SINGLE CPU */
+	CPU_ZERO(&mask);
+	CPU_SET(0, &mask);
+	err = sched_setaffinity(0, sizeof(mask), &mask);
+	if (err < 0) {
+		printf("Can't set affinity: %d %s\n", err, strerror(err));
+		exit(-1);
+	}
+
+	for (j = 0; j < INTERVALS; j++) {
+		/* Collect samples */
+		for (i = 0; i < ITERATIONS; i++)
+			rdtscll(sample_list[i]);
+
+		/* Process samples */
+		for (i = 0; i < (ITERATIONS - 1); i++) {
+			delta = sample_list[i + 1] - sample_list[i];
+			if (delta < min)
+				min = delta;
+			if (delta > max)
+				max = delta;
+			if (delta > 100000)
+				printf("maxd(%llu:%llu): %llu %llu = %llu\n", j,
+				       i, sample_list[i], sample_list[i + 1],
+				       delta);
+			avg += delta;
+		}
+		usleep(100);	/*let necessary things happen */
+	}
+	avg /= (ITERATIONS * INTERVALS);
+
+	printf("%lld pairs of gettimeofday() calls completed\n",
+	       ITERATIONS * INTERVALS);
+	printf("Time between calls:\n");
+	printf("Minimum: %llu \n", min);
+	printf("Maximum: %llu \n", max);
+	printf("Average: %llu \n", avg);
+
+	return 0;
+}
diff --git a/code/train/C/0119953_benchmark.c b/code/train/C/0119953_benchmark.c
new file mode 100644
index 0000000000000000000000000000000000000000..fda8268f189f0a88b1762cc59564d77ddcbbb812
--- /dev/null
+++ b/code/train/C/0119953_benchmark.c
@@ -0,0 +1,145 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000-2017 Expat development team
+   Licensed under the MIT license:
+
+   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 <sys/stat.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include "expat.h"
+
+#ifdef XML_LARGE_SIZE
+#  define XML_FMT_INT_MOD "ll"
+#else
+#  define XML_FMT_INT_MOD "l"
+#endif
+
+#ifdef XML_UNICODE_WCHAR_T
+#  define XML_FMT_STR "ls"
+#else
+#  define XML_FMT_STR "s"
+#endif
+
+static void
+usage(const char *prog, int rc) {
+  fprintf(stderr, "usage: %s [-n] filename bufferSize nr_of_loops\n", prog);
+  exit(rc);
+}
+
+int
+main(int argc, char *argv[]) {
+  XML_Parser parser;
+  char *XMLBuf, *XMLBufEnd, *XMLBufPtr;
+  FILE *fd;
+  struct stat fileAttr;
+  int nrOfLoops, bufferSize, fileSize, i, isFinal;
+  int j = 0, ns = 0;
+  clock_t tstart, tend;
+  double cpuTime = 0.0;
+
+  if (argc > 1) {
+    if (argv[1][0] == '-') {
+      if (argv[1][1] == 'n' && argv[1][2] == '\0') {
+        ns = 1;
+        j = 1;
+      } else
+        usage(argv[0], 1);
+    }
+  }
+
+  if (argc != j + 4)
+    usage(argv[0], 1);
+
+  if (stat(argv[j + 1], &fileAttr) != 0) {
+    fprintf(stderr, "could not access file '%s'\n", argv[j + 1]);
+    return 2;
+  }
+
+  fd = fopen(argv[j + 1], "r");
+  if (! fd) {
+    fprintf(stderr, "could not open file '%s'\n", argv[j + 1]);
+    exit(2);
+  }
+
+  bufferSize = atoi(argv[j + 2]);
+  nrOfLoops = atoi(argv[j + 3]);
+  if (bufferSize <= 0 || nrOfLoops <= 0) {
+    fprintf(stderr, "buffer size and nr of loops must be greater than zero.\n");
+    exit(3);
+  }
+
+  XMLBuf = malloc(fileAttr.st_size);
+  fileSize = fread(XMLBuf, sizeof(char), fileAttr.st_size, fd);
+  fclose(fd);
+
+  if (ns)
+    parser = XML_ParserCreateNS(NULL, '!');
+  else
+    parser = XML_ParserCreate(NULL);
+
+  i = 0;
+  XMLBufEnd = XMLBuf + fileSize;
+  while (i < nrOfLoops) {
+    XMLBufPtr = XMLBuf;
+    isFinal = 0;
+    tstart = clock();
+    do {
+      int parseBufferSize = XMLBufEnd - XMLBufPtr;
+      if (parseBufferSize <= bufferSize)
+        isFinal = 1;
+      else
+        parseBufferSize = bufferSize;
+      if (! XML_Parse(parser, XMLBufPtr, parseBufferSize, isFinal)) {
+        fprintf(stderr,
+                "error '%" XML_FMT_STR "' at line %" XML_FMT_INT_MOD
+                "u character %" XML_FMT_INT_MOD "u\n",
+                XML_ErrorString(XML_GetErrorCode(parser)),
+                XML_GetCurrentLineNumber(parser),
+                XML_GetCurrentColumnNumber(parser));
+        free(XMLBuf);
+        XML_ParserFree(parser);
+        exit(4);
+      }
+      XMLBufPtr += bufferSize;
+    } while (! isFinal);
+    tend = clock();
+    cpuTime += ((double)(tend - tstart)) / CLOCKS_PER_SEC;
+    XML_ParserReset(parser, NULL);
+    i++;
+  }
+
+  XML_ParserFree(parser);
+  free(XMLBuf);
+
+  printf("%d loops, with buffer size %d. Average time per loop: %f\n",
+         nrOfLoops, bufferSize, cpuTime / (double)nrOfLoops);
+  return 0;
+}
diff --git a/code/train/C/0120137_guillemot.c b/code/train/C/0120137_guillemot.c
new file mode 100644
index 0000000000000000000000000000000000000000..6a70ec429f063eb28d6f6f251037b695cb794841
--- /dev/null
+++ b/code/train/C/0120137_guillemot.c
@@ -0,0 +1,289 @@
+/*
+ * $Id: guillemot.c,v 1.10 2002/01/22 20:28:12 vojtech Exp $
+ *
+ *  Copyright (c) 2001 Vojtech Pavlik
+ */
+
+/*
+ * Guillemot Digital Interface Protocol driver for Linux
+ */
+
+/*
+ * 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
+ *
+ * Should you need to contact me, the author, you can do so either by
+ * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
+ * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
+ */
+
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/init.h>
+#include <linux/gameport.h>
+#include <linux/input.h>
+
+#define DRIVER_DESC	"Guillemot Digital joystick driver"
+
+MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+
+#define GUILLEMOT_MAX_START	600	/* 600 us */
+#define GUILLEMOT_MAX_STROBE	60	/* 60 us */
+#define GUILLEMOT_MAX_LENGTH	17	/* 17 bytes */
+
+static short guillemot_abs_pad[] =
+	{ ABS_X, ABS_Y, ABS_THROTTLE, ABS_RUDDER, -1 };
+
+static short guillemot_btn_pad[] =
+	{ BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, BTN_TL, BTN_TR, BTN_MODE, BTN_SELECT, -1 };
+
+static struct {
+        int x;
+        int y;
+} guillemot_hat_to_axis[16] = {{ 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}};
+
+struct guillemot_type {
+	unsigned char id;
+	short *abs;
+	short *btn;
+	int hat;
+	char *name;
+};
+
+struct guillemot {
+	struct gameport *gameport;
+	struct input_dev dev;
+	int bads;
+	int reads;
+	struct guillemot_type *type;
+	unsigned char length;
+	char phys[32];
+};
+
+static struct guillemot_type guillemot_type[] = {
+	{ 0x00, guillemot_abs_pad, guillemot_btn_pad, 1, "Guillemot Pad" },
+	{ 0 }};
+
+/*
+ * guillemot_read_packet() reads Guillemot joystick data.
+ */
+
+static int guillemot_read_packet(struct gameport *gameport, u8 *data)
+{
+	unsigned long flags;
+	unsigned char u, v;
+	unsigned int t, s;
+	int i;
+
+	for (i = 0; i < GUILLEMOT_MAX_LENGTH; i++)
+		data[i] = 0;
+
+	i = 0;
+	t = gameport_time(gameport, GUILLEMOT_MAX_START);
+	s = gameport_time(gameport, GUILLEMOT_MAX_STROBE);
+
+	local_irq_save(flags);
+	gameport_trigger(gameport);
+	v = gameport_read(gameport);
+
+	while (t > 0 && i < GUILLEMOT_MAX_LENGTH * 8) {
+		t--;
+		u = v; v = gameport_read(gameport);
+		if (v & ~u & 0x10) {
+			data[i >> 3] |= ((v >> 5) & 1) << (i & 7);
+			i++;
+			t = s;
+		}
+	}
+
+	local_irq_restore(flags);
+
+	return i;
+}
+
+/*
+ * guillemot_poll() reads and analyzes Guillemot joystick data.
+ */
+
+static void guillemot_poll(struct gameport *gameport)
+{
+	struct guillemot *guillemot = gameport_get_drvdata(gameport);
+	struct input_dev *dev = &guillemot->dev;
+	u8 data[GUILLEMOT_MAX_LENGTH];
+	int i;
+
+	guillemot->reads++;
+
+	if (guillemot_read_packet(guillemot->gameport, data) != GUILLEMOT_MAX_LENGTH * 8 ||
+		data[0] != 0x55 || data[16] != 0xaa) {
+		guillemot->bads++;
+	} else {
+
+		for (i = 0; i < 6 && guillemot->type->abs[i] >= 0; i++)
+			input_report_abs(dev, guillemot->type->abs[i], data[i + 5]);
+
+		if (guillemot->type->hat) {
+			input_report_abs(dev, ABS_HAT0X, guillemot_hat_to_axis[data[4] >> 4].x);
+			input_report_abs(dev, ABS_HAT0Y, guillemot_hat_to_axis[data[4] >> 4].y);
+		}
+
+		for (i = 0; i < 16 && guillemot->type->btn[i] >= 0; i++)
+			input_report_key(dev, guillemot->type->btn[i], (data[2 + (i >> 3)] >> (i & 7)) & 1);
+	}
+
+	input_sync(dev);
+}
+
+/*
+ * guillemot_open() is a callback from the input open routine.
+ */
+
+static int guillemot_open(struct input_dev *dev)
+{
+	struct guillemot *guillemot = dev->private;
+
+	gameport_start_polling(guillemot->gameport);
+	return 0;
+}
+
+/*
+ * guillemot_close() is a callback from the input close routine.
+ */
+
+static void guillemot_close(struct input_dev *dev)
+{
+	struct guillemot *guillemot = dev->private;
+
+	gameport_stop_polling(guillemot->gameport);
+}
+
+/*
+ * guillemot_connect() probes for Guillemot joysticks.
+ */
+
+static int guillemot_connect(struct gameport *gameport, struct gameport_driver *drv)
+{
+	struct guillemot *guillemot;
+	u8 data[GUILLEMOT_MAX_LENGTH];
+	int i, t;
+	int err;
+
+	if (!(guillemot = kzalloc(sizeof(struct guillemot), GFP_KERNEL)))
+		return -ENOMEM;
+
+	guillemot->gameport = gameport;
+
+	gameport_set_drvdata(gameport, guillemot);
+
+	err = gameport_open(gameport, drv, GAMEPORT_MODE_RAW);
+	if (err)
+		goto fail1;
+
+	i = guillemot_read_packet(gameport, data);
+
+	if (i != GUILLEMOT_MAX_LENGTH * 8 || data[0] != 0x55 || data[16] != 0xaa) {
+		err = -ENODEV;
+		goto fail2;
+	}
+
+	for (i = 0; guillemot_type[i].name; i++)
+		if (guillemot_type[i].id == data[11])
+			break;
+
+	if (!guillemot_type[i].name) {
+		printk(KERN_WARNING "guillemot.c: Unknown joystick on %s. [ %02x%02x:%04x, ver %d.%02d ]\n",
+			gameport->phys, data[12], data[13], data[11], data[14], data[15]);
+		err = -ENODEV;
+		goto fail2;
+	}
+
+	gameport_set_poll_handler(gameport, guillemot_poll);
+	gameport_set_poll_interval(gameport, 20);
+
+	sprintf(guillemot->phys, "%s/input0", gameport->phys);
+
+	guillemot->type = guillemot_type + i;
+
+	guillemot->dev.private = guillemot;
+	guillemot->dev.open = guillemot_open;
+	guillemot->dev.close = guillemot_close;
+
+	guillemot->dev.name = guillemot_type[i].name;
+	guillemot->dev.phys = guillemot->phys;
+	guillemot->dev.id.bustype = BUS_GAMEPORT;
+	guillemot->dev.id.vendor = GAMEPORT_ID_VENDOR_GUILLEMOT;
+	guillemot->dev.id.product = guillemot_type[i].id;
+	guillemot->dev.id.version = (int)data[14] << 8 | data[15];
+
+	guillemot->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
+
+	for (i = 0; (t = guillemot->type->abs[i]) >= 0; i++)
+		input_set_abs_params(&guillemot->dev, t, 0, 255, 0, 0);
+
+	if (guillemot->type->hat) {
+		input_set_abs_params(&guillemot->dev, ABS_HAT0X, -1, 1, 0, 0);
+		input_set_abs_params(&guillemot->dev, ABS_HAT0Y, -1, 1, 0, 0);
+	}
+
+	for (i = 0; (t = guillemot->type->btn[i]) >= 0; i++)
+		set_bit(t, guillemot->dev.keybit);
+
+	input_register_device(&guillemot->dev);
+	printk(KERN_INFO "input: %s ver %d.%02d on %s\n",
+		guillemot->type->name, data[14], data[15], gameport->phys);
+
+	return 0;
+
+fail2:	gameport_close(gameport);
+fail1:  gameport_set_drvdata(gameport, NULL);
+	kfree(guillemot);
+	return err;
+}
+
+static void guillemot_disconnect(struct gameport *gameport)
+{
+	struct guillemot *guillemot = gameport_get_drvdata(gameport);
+
+	printk(KERN_INFO "guillemot.c: Failed %d reads out of %d on %s\n", guillemot->reads, guillemot->bads, guillemot->phys);
+	input_unregister_device(&guillemot->dev);
+	gameport_close(gameport);
+	kfree(guillemot);
+}
+
+static struct gameport_driver guillemot_drv = {
+	.driver		= {
+		.name	= "guillemot",
+	},
+	.description	= DRIVER_DESC,
+	.connect	= guillemot_connect,
+	.disconnect	= guillemot_disconnect,
+};
+
+static int __init guillemot_init(void)
+{
+	gameport_register_driver(&guillemot_drv);
+	return 0;
+}
+
+static void __exit guillemot_exit(void)
+{
+	gameport_unregister_driver(&guillemot_drv);
+}
+
+module_init(guillemot_init);
+module_exit(guillemot_exit);
diff --git a/code/train/C/0120163_bwtmisc.c b/code/train/C/0120163_bwtmisc.c
new file mode 100644
index 0000000000000000000000000000000000000000..c35d684fd5fe7f01899d4a226f110d1e3201c113
--- /dev/null
+++ b/code/train/C/0120163_bwtmisc.c
@@ -0,0 +1,230 @@
+/* The MIT License
+
+   Copyright (c) 2008 Genome Research Ltd (GRL).
+
+   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.
+*/
+
+/* Contact: Heng Li <lh3@sanger.ac.uk> */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include "bntseq.h"
+#include "utils.h"
+#include "main.h"
+#include "bwt.h"
+
+#ifdef _DIVBWT
+#include "divsufsort.h"
+#endif
+
+int is_bwt(ubyte_t *T, int n);
+
+int64_t bwa_seq_len(const char *fn_pac)
+{
+	FILE *fp;
+	int64_t pac_len;
+	ubyte_t c;
+	fp = xopen(fn_pac, "rb");
+	fseek(fp, -1, SEEK_END);
+	pac_len = ftell(fp);
+	fread(&c, 1, 1, fp);
+	fclose(fp);
+	return (pac_len - 1) * 4 + (int)c;
+}
+
+bwt_t *bwt_pac2bwt(const char *fn_pac, int use_is)
+{
+	bwt_t *bwt;
+	ubyte_t *buf, *buf2;
+	int i, pac_size;
+	FILE *fp;
+
+	// initialization
+	bwt = (bwt_t*)calloc(1, sizeof(bwt_t));
+	bwt->seq_len = bwa_seq_len(fn_pac);
+	bwt->bwt_size = (bwt->seq_len + 15) >> 4;
+	fp = xopen(fn_pac, "rb");
+
+	// prepare sequence
+	pac_size = (bwt->seq_len>>2) + ((bwt->seq_len&3) == 0? 0 : 1);
+	buf2 = (ubyte_t*)calloc(pac_size, 1);
+	fread(buf2, 1, pac_size, fp);
+	fclose(fp);
+	memset(bwt->L2, 0, 5 * 4);
+	buf = (ubyte_t*)calloc(bwt->seq_len + 1, 1);
+	for (i = 0; i < bwt->seq_len; ++i) {
+		buf[i] = buf2[i>>2] >> ((3 - (i&3)) << 1) & 3;
+		++bwt->L2[1+buf[i]];
+	}
+	for (i = 2; i <= 4; ++i) bwt->L2[i] += bwt->L2[i-1];
+	free(buf2);
+
+	// Burrows-Wheeler Transform
+	if (use_is) {
+		bwt->primary = is_bwt(buf, bwt->seq_len);
+	} else {
+#ifdef _DIVBWT
+		bwt->primary = divbwt(buf, buf, 0, bwt->seq_len);
+#else
+		err_fatal_simple("libdivsufsort is not compiled in.");
+#endif
+	}
+	bwt->bwt = (u_int32_t*)calloc(bwt->bwt_size, 4);
+	for (i = 0; i < bwt->seq_len; ++i)
+		bwt->bwt[i>>4] |= buf[i] << ((15 - (i&15)) << 1);
+	free(buf);
+	return bwt;
+}
+
+int bwa_pac2bwt(int argc, char *argv[])
+{
+	bwt_t *bwt;
+	int c, use_is = 1;
+	while ((c = getopt(argc, argv, "d")) >= 0) {
+		switch (c) {
+		case 'd': use_is = 0; break;
+		default: return 1;
+		}
+	}
+	if (optind + 2 > argc) {
+		fprintf(stderr, "Usage: bwa pac2bwt [-d] <in.pac> <out.bwt>\n");
+		return 1;
+	}
+	bwt = bwt_pac2bwt(argv[optind], use_is);
+	bwt_dump_bwt(argv[optind+1], bwt);
+	bwt_destroy(bwt);
+	return 0;
+}
+
+#define bwt_B00(b, k) ((b)->bwt[(k)>>4]>>((~(k)&0xf)<<1)&3)
+
+void bwt_bwtupdate_core(bwt_t *bwt)
+{
+	bwtint_t i, k, c[4], n_occ;
+	uint32_t *buf;
+
+	n_occ = (bwt->seq_len + OCC_INTERVAL - 1) / OCC_INTERVAL + 1;
+	bwt->bwt_size += n_occ * sizeof(bwtint_t); // the new size
+	buf = (uint32_t*)calloc(bwt->bwt_size, 4); // will be the new bwt
+	c[0] = c[1] = c[2] = c[3] = 0;
+	for (i = k = 0; i < bwt->seq_len; ++i) {
+		if (i % OCC_INTERVAL == 0) {
+			memcpy(buf + k, c, sizeof(bwtint_t) * 4);
+			k += sizeof(bwtint_t); // in fact: sizeof(bwtint_t)=4*(sizeof(bwtint_t)/4)
+		}
+		if (i % 16 == 0) buf[k++] = bwt->bwt[i/16]; // 16 == sizeof(uint32_t)/2
+		++c[bwt_B00(bwt, i)];
+	}
+	// the last element
+	memcpy(buf + k, c, sizeof(bwtint_t) * 4);
+	xassert(k + sizeof(bwtint_t) == bwt->bwt_size, "inconsistent bwt_size");
+	// update bwt
+	free(bwt->bwt); bwt->bwt = buf;
+}
+
+int bwa_bwtupdate(int argc, char *argv[])
+{
+	bwt_t *bwt;
+	if (argc < 2) {
+		fprintf(stderr, "Usage: bwa bwtupdate <the.bwt>\n");
+		return 1;
+	}
+	bwt = bwt_restore_bwt(argv[1]);
+	bwt_bwtupdate_core(bwt);
+	bwt_dump_bwt(argv[1], bwt);
+	bwt_destroy(bwt);
+	return 0;
+}
+
+const int nst_color_space_table[] = { 4, 0, 0, 1, 0, 2, 3, 4, 0, 3, 2, 4, 1, 4, 4, 4};
+
+/* this function is not memory efficient, but this will make life easier
+   Ideally we should also change .amb files as one 'N' in the nucleotide
+   sequence leads to two ambiguous colors. I may do this later... */
+uint8_t *bwa_pac2cspac_core(const bntseq_t *bns)
+{
+	uint8_t *pac, *cspac;
+	bwtint_t i;
+	int c1, c2;
+	pac = (uint8_t*)calloc(bns->l_pac/4 + 1, 1);
+	cspac = (uint8_t*)calloc(bns->l_pac/4 + 1, 1);
+	fread(pac, 1, bns->l_pac/4+1, bns->fp_pac);
+	rewind(bns->fp_pac);
+	c1 = pac[0]>>6; cspac[0] = c1<<6;
+	for (i = 1; i < bns->l_pac; ++i) {
+		c2 = pac[i>>2] >> (~i&3)*2 & 3;
+		cspac[i>>2] |= nst_color_space_table[(1<<c1)|(1<<c2)] << (~i&3)*2;
+		c1 = c2;
+	}
+	free(pac);
+	return cspac;
+}
+
+int bwa_pac2cspac(int argc, char *argv[])
+{
+	bntseq_t *bns;
+	uint8_t *cspac, ct;
+	char *str;
+	FILE *fp;
+
+	if (argc < 3) {
+		fprintf(stderr, "Usage: bwa pac2cspac <in.nt.prefix> <out.cs.prefix>\n");
+		return 1;
+	}
+	bns = bns_restore(argv[1]);
+	cspac = bwa_pac2cspac_core(bns);
+	bns_dump(bns, argv[2]);
+	// now write cspac
+	str = (char*)calloc(strlen(argv[2]) + 5, 1);
+	strcat(strcpy(str, argv[2]), ".pac");
+	fp = xopen(str, "wb");
+	fwrite(cspac, 1, bns->l_pac/4 + 1, fp);
+	ct = bns->l_pac % 4;
+	fwrite(&ct, 1, 1, fp);	
+	fclose(fp);
+	bns_destroy(bns);
+	free(cspac);
+	return 0;
+}
+
+int bwa_bwt2sa(int argc, char *argv[])
+{
+	bwt_t *bwt;
+	int c, sa_intv = 32;
+	while ((c = getopt(argc, argv, "i:")) >= 0) {
+		switch (c) {
+		case 'i': sa_intv = atoi(optarg); break;
+		default: return 1;
+		}
+	}
+	if (optind + 2 > argc) {
+		fprintf(stderr, "Usage: bwa bwt2sa [-i %d] <in.bwt> <out.sa>\n", sa_intv);
+		return 1;
+	}
+	bwt = bwt_restore_bwt(argv[optind]);
+	bwt_cal_sa(bwt, sa_intv);
+	bwt_dump_sa(argv[optind+1], bwt);
+	bwt_destroy(bwt);
+	return 0;
+}
diff --git a/code/train/C/0121366_cpulist.c b/code/train/C/0121366_cpulist.c
new file mode 100644
index 0000000000000000000000000000000000000000..fe383ddeb5faa6a14d2cb3864d7c1a60deb70db4
--- /dev/null
+++ b/code/train/C/0121366_cpulist.c
@@ -0,0 +1,214 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sched.h>
+
+#if CPUINFO_MOCK
+	#include <cpuinfo-mock.h>
+#endif
+#include <linux/api.h>
+#include <log.h>
+
+
+/*
+ * Size, in chars, of the on-stack buffer used for parsing cpu lists.
+ * This is also the limit on the length of a single entry
+ * (<cpu-number> or <cpu-number-start>-<cpu-number-end>)
+ * in the cpu list.
+ */
+#define BUFFER_SIZE 256
+
+
+/* Locale-independent */
+inline static bool is_whitespace(char c) {
+	switch (c) {
+		case ' ':
+		case '\t':
+		case '\n':
+		case '\r':
+			return true;
+		default:
+			return false;
+	}
+}
+
+inline static const char* parse_number(const char* string, const char* end, uint32_t number_ptr[restrict static 1]) {
+	uint32_t number = 0;
+	while (string != end) {
+		const uint32_t digit = (uint32_t) (*string) - (uint32_t) '0';
+		if (digit >= 10) {
+			break;
+		}
+		number = number * UINT32_C(10) + digit;
+		string += 1;
+	}
+	*number_ptr = number;
+	return string;
+}
+
+inline static bool parse_entry(const char* entry_start, const char* entry_end, cpuinfo_cpulist_callback callback, void* context) {
+	/* Skip whitespace at the beginning of an entry */
+	for (; entry_start != entry_end; entry_start++) {
+		if (!is_whitespace(*entry_start)) {
+			break;
+		}
+	}
+	/* Skip whitespace at the end of an entry */
+	for (; entry_end != entry_start; entry_end--) {
+		if (!is_whitespace(entry_end[-1])) {
+			break;
+		}
+	}
+
+	const size_t entry_length = (size_t) (entry_end - entry_start);
+	if (entry_length == 0) {
+		cpuinfo_log_warning("unexpected zero-length cpu list entry ignored");
+		return false;
+	}
+
+	#if CPUINFO_LOG_DEBUG_PARSERS
+		cpuinfo_log_debug("parse cpu list entry \"%.*s\" (%zu chars)", (int) entry_length, entry_start, entry_length);
+	#endif
+	uint32_t first_cpu, last_cpu;
+
+	const char* number_end = parse_number(entry_start, entry_end, &first_cpu);
+	if (number_end == entry_start) {
+		/* Failed to parse the number; ignore the entry */
+		cpuinfo_log_warning("invalid character '%c' in the cpu list entry \"%.*s\": entry is ignored",
+			entry_start[0], (int) entry_length, entry_start);
+		return false;
+	} else if (number_end == entry_end) {
+		/* Completely parsed the entry */
+		#if CPUINFO_LOG_DEBUG_PARSERS
+			cpuinfo_log_debug("cpulist: call callback with list_start = %"PRIu32", list_end = %"PRIu32,
+				first_cpu, first_cpu + 1);
+		#endif
+		return callback(first_cpu, first_cpu + 1, context);
+	}
+
+	/* Parse the second part of the entry */
+	if (*number_end != '-') {
+		cpuinfo_log_warning("invalid character '%c' in the cpu list entry \"%.*s\": entry is ignored",
+			*number_end, (int) entry_length, entry_start);
+		return false;
+	}
+
+	const char* number_start = number_end + 1;
+	number_end = parse_number(number_start, entry_end, &last_cpu);
+	if (number_end == number_start) {
+		/* Failed to parse the second number; ignore the entry */
+		cpuinfo_log_warning("invalid character '%c' in the cpu list entry \"%.*s\": entry is ignored",
+			*number_start, (int) entry_length, entry_start);
+		return false;
+	}
+
+	if (number_end != entry_end) {
+		/* Partially parsed the entry; ignore unparsed characters and continue with the parsed part */
+		cpuinfo_log_warning("ignored invalid characters \"%.*s\" at the end of cpu list entry \"%.*s\"",
+			(int) (entry_end - number_end), number_start, (int) entry_length, entry_start);
+	}
+
+	if (last_cpu < first_cpu) {
+		cpuinfo_log_warning("ignored cpu list entry \"%.*s\": invalid range %"PRIu32"-%"PRIu32,
+			(int) entry_length, entry_start, first_cpu, last_cpu);
+		return false;
+	}
+
+	/* Parsed both parts of the entry; update CPU set */
+	#if CPUINFO_LOG_DEBUG_PARSERS
+		cpuinfo_log_debug("cpulist: call callback with list_start = %"PRIu32", list_end = %"PRIu32,
+			first_cpu, last_cpu + 1);
+	#endif
+	return callback(first_cpu, last_cpu + 1, context);
+}
+
+bool cpuinfo_linux_parse_cpulist(const char* filename, cpuinfo_cpulist_callback callback, void* context) {
+	bool status = true;
+	int file = -1;
+	char buffer[BUFFER_SIZE];
+	#if CPUINFO_LOG_DEBUG_PARSERS
+		cpuinfo_log_debug("parsing cpu list from file %s", filename);
+	#endif
+
+#if CPUINFO_MOCK
+	file = cpuinfo_mock_open(filename, O_RDONLY);
+#else
+	file = open(filename, O_RDONLY);
+#endif
+	if (file == -1) {
+		cpuinfo_log_info("failed to open %s: %s", filename, strerror(errno));
+		status = false;
+		goto cleanup;
+	}
+
+	size_t position = 0;
+	const char* buffer_end = &buffer[BUFFER_SIZE];
+	char* data_start = buffer;
+	ssize_t bytes_read;
+	do {
+#if CPUINFO_MOCK
+		bytes_read = cpuinfo_mock_read(file, data_start, (size_t) (buffer_end - data_start));
+#else
+		bytes_read = read(file, data_start, (size_t) (buffer_end - data_start));
+#endif
+		if (bytes_read < 0) {
+			cpuinfo_log_info("failed to read file %s at position %zu: %s", filename, position, strerror(errno));
+			status = false;
+			goto cleanup;
+		}
+
+		position += (size_t) bytes_read;
+		const char* data_end = data_start + (size_t) bytes_read;
+		const char* entry_start = buffer;
+
+		if (bytes_read == 0) {
+			/* No more data in the file: process the remaining text in the buffer as a single entry */
+			const char* entry_end = data_end;
+			const bool entry_status = parse_entry(entry_start, entry_end, callback, context);
+			status &= entry_status;
+		} else {
+			const char* entry_end;
+			do {
+				/* Find the end of the entry, as indicated by a comma (',') */
+				for (entry_end = entry_start; entry_end != data_end; entry_end++) {
+					if (*entry_end == ',') {
+						break;
+					}
+				}
+
+				/*
+				 * If we located separator at the end of the entry, parse it.
+				 * Otherwise, there may be more data at the end; read the file once again.
+				 */
+				if (entry_end != data_end) {
+					const bool entry_status = parse_entry(entry_start, entry_end, callback, context);
+					status &= entry_status;
+					entry_start = entry_end + 1;
+				}
+			} while (entry_end != data_end);
+
+			/* Move remaining partial entry data at the end to the beginning of the buffer */
+			const size_t entry_length = (size_t) (entry_end - entry_start);
+			memmove(buffer, entry_start, entry_length);
+			data_start = &buffer[entry_length];
+		}
+	} while (bytes_read != 0);
+
+cleanup:
+	if (file != -1) {
+#if CPUINFO_MOCK
+		cpuinfo_mock_close(file);
+#else
+		close(file);
+#endif
+		file = -1;
+	}
+	return status;
+}
diff --git a/code/train/C/0122105_pm_pwm.c b/code/train/C/0122105_pm_pwm.c
new file mode 100644
index 0000000000000000000000000000000000000000..1e723dcd82e30b72fc2193b4e492376739183e30
--- /dev/null
+++ b/code/train/C/0122105_pm_pwm.c
@@ -0,0 +1,259 @@
+/*
+ * * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ *
+ * 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 Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * 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.
+ */
+
+#include <Library/LKEnvLib.h>
+
+#include "pm8x41_p.h"
+#include "pm8x41_hw.h"
+#include "pm_pwm.h"
+
+#define NSEC_PER_USEC		1000L
+#define USEC_PER_SEC		1000000L
+#define NSEC_PER_SEC		1000000000L
+
+#define NUM_REF_CLOCKS		3
+#define NSEC_1024HZ			(NSEC_PER_SEC / 1024)
+#define NSEC_32768HZ		(NSEC_PER_SEC / 32768)
+#define NSEC_19P2MHZ		(NSEC_PER_SEC / 19200000)
+
+#define NUM_PRE_DIVIDE		4
+#define PRE_DIVIDE_1		1
+#define PRE_DIVIDE_3		3
+#define PRE_DIVIDE_5		5
+#define PRE_DIVIDE_6		6
+static unsigned int pt_t[NUM_PRE_DIVIDE][NUM_REF_CLOCKS] = {
+	{	PRE_DIVIDE_1 * NSEC_1024HZ,
+		PRE_DIVIDE_1 * NSEC_32768HZ,
+		PRE_DIVIDE_1 * NSEC_19P2MHZ,
+	},
+	{	PRE_DIVIDE_3 * NSEC_1024HZ,
+		PRE_DIVIDE_3 * NSEC_32768HZ,
+		PRE_DIVIDE_3 * NSEC_19P2MHZ,
+	},
+	{	PRE_DIVIDE_5 * NSEC_1024HZ,
+		PRE_DIVIDE_5 * NSEC_32768HZ,
+		PRE_DIVIDE_5 * NSEC_19P2MHZ,
+	},
+	{	PRE_DIVIDE_6 * NSEC_1024HZ,
+		PRE_DIVIDE_6 * NSEC_32768HZ,
+		PRE_DIVIDE_6 * NSEC_19P2MHZ,
+	},
+};
+
+enum pwm_ctl_reg {
+	SIZE_CLK,
+	FREQ_PREDIV_CLK,
+	TYPE_CONFIG,
+	VALUE_LSB,
+	VALUE_MSB,
+};
+
+#define NUM_PWM_CTL_REGS	5
+struct pm_pwm_config {
+	int pwm_size;		/* round up to 6 or 9 for 6/9-bit PWM SIZE */
+	int clk;
+	int pre_div;
+	int pre_div_exp;
+	int pwm_value;
+	uint8_t pwm_ctl[NUM_PWM_CTL_REGS];
+};
+
+static void pm_pwm_reg_write(uint8_t off, uint8_t val)
+{
+	REG_WRITE(PM_PWM_BASE(off), val);
+}
+
+/*
+ * PWM Frequency = Clock Frequency / (N * T)
+ *	or
+ * PWM Period = Clock Period * (N * T)
+ *	where
+ * N = 2^9 or 2^6 for 9-bit or 6-bit PWM size
+ * T = Pre-divide * 2^m, where m = 0..7 (exponent)
+ *
+ * This is the formula to figure out m for the best pre-divide and clock:
+ * (PWM Period / N) = (Pre-divide * Clock Period) * 2^m
+ */
+
+#define PRE_DIVIDE_MAX		6
+#define CLK_PERIOD_MAX		NSEC_1024HZ
+#define PM_PWM_M_MAX		7
+#define MAX_MPT				((PRE_DIVIDE_MAX * CLK_PERIOD_MAX) << PM_PWM_M_MAX)
+static void pm_pwm_calc_period(unsigned int period_us,
+				   struct pm_pwm_config *pwm_config)
+{
+	int	n, m, clk, div;
+	int	best_m, best_div, best_clk;
+	unsigned int last_err, cur_err, min_err;
+	unsigned int tmp_p, period_n;
+
+	n = 6;
+
+	if (period_us < ((unsigned)(-1) / NSEC_PER_USEC))
+		period_n = (period_us * NSEC_PER_USEC) >> n;
+	else
+		period_n = (period_us >> n) * NSEC_PER_USEC;
+
+	if (period_n >= MAX_MPT) {
+		n = 9;
+		period_n >>= 3;
+	}
+
+	min_err = last_err = (unsigned)(-1);
+	best_m = 0;
+	best_clk = 0;
+	best_div = 0;
+	for (clk = 0; clk < NUM_REF_CLOCKS; clk++) {
+		for (div = 0; div < NUM_PRE_DIVIDE; div++) {
+			/* period_n = (PWM Period / N) */
+			/* tmp_p = (Pre-divide * Clock Period) * 2^m */
+			tmp_p = pt_t[div][clk];
+			for (m = 0; m <= PM_PWM_M_MAX; m++) {
+				if (period_n > tmp_p)
+					cur_err = period_n - tmp_p;
+				else
+					cur_err = tmp_p - period_n;
+
+				if (cur_err < min_err) {
+					min_err = cur_err;
+					best_m = m;
+					best_clk = clk;
+					best_div = div;
+				}
+
+				if (m && cur_err > last_err)
+					/* Break for bigger cur_err */
+					break;
+
+				last_err = cur_err;
+				tmp_p <<= 1;
+			}
+		}
+	}
+
+	pwm_config->pwm_size = n;
+	pwm_config->clk = best_clk;
+	pwm_config->pre_div = best_div;
+	pwm_config->pre_div_exp = best_m;
+}
+
+static void pm_pwm_calc_pwm_value(struct pm_pwm_config *pwm_config,
+				      unsigned int period_us,
+				      unsigned int duty_us)
+{
+	int max_pwm_value;
+	unsigned int tmp;
+
+	/* Figure out pwm_value with overflow handling */
+	tmp = 1 << (sizeof(tmp) * 8 - pwm_config->pwm_size);
+	if (duty_us < tmp) {
+		tmp = duty_us << pwm_config->pwm_size;
+		pwm_config->pwm_value = tmp / period_us;
+	} else {
+		tmp = period_us >> pwm_config->pwm_size;
+		pwm_config->pwm_value = duty_us / tmp;
+	}
+	max_pwm_value = (1 << pwm_config->pwm_size) - 1;
+	if (pwm_config->pwm_value > max_pwm_value)
+		pwm_config->pwm_value = max_pwm_value;
+}
+
+#define PM_PWM_SIZE_9_BIT	1
+#define PM_PWM_SIZE_6_BIT	0
+static void pm_pwm_config_regs(struct pm_pwm_config *pwm_config)
+{
+	int i;
+	uint8_t reg;
+
+	reg = ((pwm_config->pwm_size > 6 ? PM_PWM_SIZE_9_BIT : PM_PWM_SIZE_6_BIT)
+		<< PM_PWM_SIZE_SEL_SHIFT)
+		& PM_PWM_SIZE_SEL_MASK;
+	reg |= (pwm_config->clk + 1) & PM_PWM_CLK_SEL_MASK;
+	pwm_config->pwm_ctl[SIZE_CLK] = reg;
+
+	reg = (pwm_config->pre_div << PM_PWM_PREDIVIDE_SHIFT)
+	    & PM_PWM_PREDIVIDE_MASK;
+	reg |= pwm_config->pre_div_exp & PM_PWM_M_MASK;
+	pwm_config->pwm_ctl[FREQ_PREDIV_CLK] = reg;
+
+	/* Enable glitch removal by default */
+	reg = 1 << PM_PWM_EN_GLITCH_REMOVAL_SHIFT
+		& PM_PWM_EN_GLITCH_REMOVAL_MASK;
+	pwm_config->pwm_ctl[TYPE_CONFIG] = reg;
+
+	if (pwm_config->pwm_size > 6) {
+		pwm_config->pwm_ctl[VALUE_LSB] = pwm_config->pwm_value
+				& PM_PWM_VALUE_BIT7_0;
+		pwm_config->pwm_ctl[VALUE_MSB] = (pwm_config->pwm_value >> 8)
+				& PM_PWM_VALUE_BIT8;
+	} else
+		pwm_config->pwm_ctl[VALUE_LSB] = pwm_config->pwm_value
+			    & PM_PWM_VALUE_BIT5_0;
+
+	for (i = 0; i < NUM_PWM_CTL_REGS; i++)
+		pm_pwm_reg_write(PM_PWM_CTL_REG_OFFSET + i, pwm_config->pwm_ctl[i]);
+
+	reg = 1 & PM_PWM_SYNC_MASK;
+	pm_pwm_reg_write(PM_PWM_SYNC_REG_OFFSET, reg);
+}
+
+/* usec: 19.2M, n=6, m=0, pre=2 */
+#define PM_PWM_PERIOD_MIN	7
+/* 1K, n=9, m=7, pre=6 */
+#define PM_PWM_PERIOD_MAX	(384 * USEC_PER_SEC)
+int pm_pwm_config(unsigned int duty_us, unsigned int period_us)
+{
+	struct pm_pwm_config pwm_config;
+
+	if ((duty_us > period_us) || (period_us > PM_PWM_PERIOD_MAX) ||
+	    (period_us < PM_PWM_PERIOD_MIN)) {
+		dprintf(CRITICAL, "Error in duty cycle and period\n");
+		return -1;
+	}
+
+	pm_pwm_calc_period(period_us, &pwm_config);
+	pm_pwm_calc_pwm_value(&pwm_config, period_us, duty_us);
+
+	dprintf(SPEW, "duty/period=%u/%u usec: pwm_value=%d (of %d)\n",
+		duty_us, period_us, pwm_config.pwm_value, 1 << pwm_config.pwm_size);
+
+	pm_pwm_config_regs(&pwm_config);
+
+	return 0;
+}
+
+void pm_pwm_enable(bool enable)
+{
+	uint8_t reg;
+
+	reg = enable << PM_PWM_ENABLE_CTL_SHIFT
+		& PM_PWM_ENABLE_CTL_MASK;
+
+	pm_pwm_reg_write(PM_PWM_ENABLE_CTL_REG_OFFSET, reg);
+}
diff --git a/code/train/C/0122454_main.c b/code/train/C/0122454_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..f0e76828b7bcf1e3ef45c91cb08e2eec7deeddf6
--- /dev/null
+++ b/code/train/C/0122454_main.c
@@ -0,0 +1,289 @@
+/* GAIWR - an application for the Pololu Baby Orangutan B
+ *
+ * This application uses the Pololu AVR C/C++ Library.  For help, see:
+ * -User's guide: http://www.pololu.com/docs/0J20
+ * -Command reference: http://www.pololu.com/docs/0J18
+ *
+ * Created: 4/26/2012 10:44:19 AM
+ *  Author: jleichty / nwiltsie
+ * 
+ * Modified: rhoadsb 18 Mar 14
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <avr/interrupt.h>
+#include <pololu/orangutan.h>
+#include <string.h>
+
+// adjust F_CPU and SCL_CLOCK in twimaster.c
+
+//DEBUG mode
+// Define DEBUG when BO is wired to PuTTY via FTDI Cable
+// In PuTTY set the baud to 115200
+// The slave wants the null byte (ctrl+shift+2) before anything
+// Type info just like the master would
+// 09009000511 to set servos to 90, 90, 5 degrees and both LAs to 1
+// Terminate info with null byte
+//#define DEBUG 1
+
+// robot parameters
+#define NUM_MOTORS 1
+#define SERIAL_BAUD_RATE 115200
+#define FAST_PERIOD_TICKS 2500      // at 20MHz, ticks are 0.4us
+#define SLOW_PERIOD_MS 1000
+#define LA_MOVE_MS 750
+#define LA_SPEED 100
+
+// serial
+char receive_buffer[13];
+char send_buffer[256];
+
+// timekeeping
+uint32_t prev_ticks = 0;
+uint32_t current_ticks = 0;
+uint32_t last_fast_period_ticks = 0;
+uint32_t lfp_actual = 0;
+uint32_t prev_ms = 0;
+uint32_t current_ms = 0;
+uint32_t last_slow_period_ms = 0;
+uint32_t last_la_move_ms[2];
+
+// encoder gray code storage
+uint8_t enc_gray[NUM_MOTORS];
+
+// Combined RC pulse data
+int16_t RC_motor[NUM_MOTORS];
+// port state storage for changed pin identification
+uint8_t portB_storage;
+uint8_t portD_storage;
+
+int16_t servo_cmds[3];
+int8_t la_cmds[2];
+int8_t la_state[2];
+
+// motor data layout
+typedef struct {
+    int32_t  pos;               // current position
+    int32_t  pos_tgt;           // position target
+    float    pos_tgt_acc;       // position target accumulator
+    int32_t  pos_err;      // position error
+    int32_t  int_err_acc;       // integral error accumulator
+    int16_t  int_err;           // integral error / 256
+    uint8_t  pwm;               // PWM level to drive motor
+    int8_t   dir;               // direction to drive motor
+    uint16_t Kp;                // controller position gain
+    uint16_t Ki;                // controller integral gain
+    uint16_t Kd;                // controller derivative gain
+    uint16_t IL;                // controller integration limit
+    uint8_t  OL;                // PWM output limit
+    uint8_t  SRD;               // servo rate divisor for derivative gain
+    uint8_t  DB;                // amplifier deadband compensation
+} motor;
+// motor array
+motor M[NUM_MOTORS];
+
+void sync_input(void){
+    int synced = 0;
+
+    serial_receive(receive_buffer,1);
+
+    while(!synced){
+        if(serial_receive_buffer_full()){
+            if (receive_buffer[0] == '\0'){
+                synced = 1;
+                serial_receive(receive_buffer, 12);
+            } else {
+                serial_receive(receive_buffer, 1);
+            }
+        }
+    }
+}
+
+void receive_command(void){
+	int16_t n;
+	
+    if (serial_receive_buffer_full()){
+#ifdef DEBUG
+		n = sprintf(send_buffer, "Serial Full\n %s\n", receive_buffer);
+		serial_send(send_buffer, n);
+#endif
+        if (receive_buffer[12] == '\0') {
+            set_digital_output(IO_B2, HIGH);
+            char servo1_str[4];
+            char servo2_str[4];
+            char servo3_str[4];
+            char la1_str[2];
+            char la2_str[2];
+
+            memcpy(servo1_str, receive_buffer + 0, 3);
+            servo1_str[3] = '\0';
+            memcpy(servo2_str, receive_buffer + 3, 3);
+            servo2_str[3] = '\0';
+            memcpy(servo3_str, receive_buffer + 6, 3);
+            servo3_str[3] = '\0';
+
+            memcpy(la1_str, receive_buffer + 9, 1);
+            la1_str[1] = '\0';
+            memcpy(la2_str, receive_buffer + 10, 1);
+            la2_str[1] = '\0';
+
+            servo_cmds[0] = atoi(servo1_str);
+            servo_cmds[1] = atoi(servo2_str);
+            servo_cmds[2] = atoi(servo3_str);
+
+            la_cmds[0] = atoi(la1_str);
+            la_cmds[1] = atoi(la2_str);
+#ifdef DEBUG
+			n = sprintf(send_buffer, "LA %i %i\n", la_cmds[0],la_cmds[1]);
+			serial_send(send_buffer, n);
+#endif
+            serial_receive(receive_buffer, 12);
+            set_digital_output(IO_B2, LOW);			
+			
+			// run the motors
+			set_servos();
+			set_las();
+        } else {
+            sync_input();
+        }
+    }
+}
+
+void set_servos(){
+    int i;
+    for (i=0; i<3; i++){
+        set_servo_target(i, servo_cmds[i] * 10 + 1500);
+    }
+}
+
+void set_mx_speed(int x, int speed){
+	int16_t n;
+    if (x==1){
+        set_m1_speed(speed);
+#ifdef DEBUG
+		n = sprintf(send_buffer, "Set Motor 1 %i\n",speed);
+		serial_send(send_buffer, n);
+#endif
+	}
+    else if (x==2){
+        set_m2_speed(speed);
+    }
+}
+
+void set_las(){
+	int16_t n;
+
+    int i;
+    uint32_t la_ms = get_ms();
+    for (i=0; i<2; i++){
+        if (la_state[i] != la_cmds[i]){
+            last_la_move_ms[i] = la_ms;
+            if (la_cmds[i] == 1){
+                set_mx_speed(i, LA_SPEED);
+            } else if (la_cmds[i] == 0){
+                set_mx_speed(i, -1*LA_SPEED);
+            }
+            la_state[i] = la_cmds[i];
+        } else if ((la_ms - last_la_move_ms[i]) > LA_MOVE_MS){
+            set_mx_speed(i, 0);
+        }
+    }
+	//n = sprintf(send_buffer, "Set LAs %i %i", la_state[0],la_state[1]);
+	//serial_send(send_buffer, n);
+}
+
+void fast_loop(void) {
+    receive_command();
+}
+
+void slow_loop(void) {
+    int16_t n;
+    // debug messages
+    n = sprintf(send_buffer, " CH1: %d\t P1: %ld\t PT1: %ld\t LFP: %ld\r\n", RC_motor[0], M[0].pos, M[0].pos_tgt, lfp_actual);
+    //n = sprintf(send_buffer, "CH1: %d\r\nCH2: %d\r\nCH3: %d\r\nCH4: %d\r\n    ", RC[0], RC[1], RC[2], RC[3]);
+    serial_send(send_buffer, n);
+}
+
+void setup() {
+    uint8_t i;
+	int16_t n;
+
+    // start up OrangutanTime
+    prev_ticks = get_ticks();
+    prev_ms = get_ms();
+
+    // set up the motor parameters
+    // Useful sets, (Kp, Kd, Ki): (50,0,0)
+    for (i = 0; i < NUM_MOTORS; i++) {
+        M[i].pos = 0;
+        M[i].pos_tgt = 0;
+        M[i].pos_tgt_acc = 0;
+        M[i].Kp = 50;
+        M[i].Ki = 0;
+        M[i].Kd = 0;
+        M[i].IL = 10000;
+        M[i].OL = 255;
+        M[i].SRD = 5;
+        M[i].DB = 0;
+    }
+
+    // Initialize the servos
+    servos_start((unsigned char[]) {IO_C0, IO_C1, IO_C2}, 3);
+    // Start the servos at 1500 ms = 90 degrees
+    servo_cmds[0] = 0;
+    servo_cmds[1] = 0;
+    servo_cmds[2] = 0;
+    la_cmds[0] = 0;
+    la_cmds[0] = 0;
+    la_state[0] = 0;
+    la_state[1] = 0;
+    last_la_move_ms[0] = prev_ms;
+    last_la_move_ms[1] = prev_ms;
+    set_servo_target(0, 1500);
+    set_servo_target(1, 1500);
+    set_servo_target(2, 1500);
+
+    // set up the serial port
+    serial_set_baud_rate(SERIAL_BAUD_RATE);
+#ifdef DEBUG
+	// debug messages
+	n = sprintf(send_buffer, "Serial Init\n"); 
+	serial_send(send_buffer, n);
+#endif
+    sync_input();
+#ifdef DEBUG
+	n = sprintf(send_buffer, "Serial Synced\n");
+	serial_send(send_buffer, n);
+#endif
+}
+
+int main()
+{
+    uint32_t t;
+	int16_t n;
+
+    setup();
+
+    // wait for receiver to come up
+    delay_ms(1000);
+
+    // do the loop scheduling
+    while (1) {
+        current_ticks = get_ticks();
+        current_ms = get_ms();
+        t = current_ticks - prev_ticks;
+        if (t >= FAST_PERIOD_TICKS) {
+            last_fast_period_ticks = t;
+            fast_loop();
+            lfp_actual = get_ticks() - current_ticks;
+            prev_ticks = current_ticks;
+        }
+        t = current_ms - prev_ms;
+        if (t >= SLOW_PERIOD_MS) {
+            last_slow_period_ms = t;
+            //slow_loop();
+            prev_ms = current_ms;
+        }
+    }
+}
diff --git a/code/train/C/0122525_long_string.c b/code/train/C/0122525_long_string.c
new file mode 100644
index 0000000000000000000000000000000000000000..0146a759aaf480c0a3f3372b1fcf4124bb196b1d
--- /dev/null
+++ b/code/train/C/0122525_long_string.c
@@ -0,0 +1,66 @@
+/**
+ * Exercise 1-16, page 31
+ * Упражнение 1.16, страница 43
+ * 
+ * Revise the main routine of the longest-line program so it will correctly print the
+ * length of arbitrary long input lines, and as much as possible of the text.
+ *
+ * Доработайте главный модуль программы определения самой длинной строки так,
+ * чтобы она выводила правильное значение для какой угодно длины строк входного
+ * потока, насколько это позволяет текст.
+ */
+
+#include <stdio.h>
+
+#define MAXLINE	10
+
+/** getline was renamed because there is function with the same name in stdio */
+int my_getline(char line[], int maxline);
+void copy(char to[], char from[]);
+
+int main (void) {
+	int c;
+	int len, max;
+	char line[MAXLINE];
+	char longest[MAXLINE];
+
+	max = 0;
+	while ((len = my_getline(line, MAXLINE)) > 0) {
+		/** added just this if-block to increment len till line end */
+		if (line[len-1] != '\n')
+			while ((c = getchar()) != EOF && c != '\n')
+				++len;
+		if (len > max) {
+			max = len;
+			copy(longest, line);
+		}
+	}
+	if (max > 0) {
+		/** print length */
+		printf("longest line is %d characters\n", max);
+		printf("content - '%s'\n", longest);
+	}
+
+	return 0;
+}
+
+int my_getline(char s[], int lim) {
+	/** should be initialized */
+	int c = 0;
+	int i;
+	for (i=0; i < lim-1 && (c = getchar()) != EOF && c !='\n'; i++)
+		s[i] = c;
+	if (c == '\n') {
+		s[i] = c;
+		i++;
+	}
+	s[i] = '\0';
+	return i;
+}
+
+void copy(char to[], char from[]) {
+	int i;
+	i = 0;
+	while ((to[i] = from[i]) != '\0')
+		i++;
+}
diff --git a/code/train/C/0123021_viterbi29_av.c b/code/train/C/0123021_viterbi29_av.c
new file mode 100644
index 0000000000000000000000000000000000000000..31c8d2764bcc7e803eeb0cb8bc8c138c29003532
--- /dev/null
+++ b/code/train/C/0123021_viterbi29_av.c
@@ -0,0 +1,190 @@
+/* K=9 r=1/2 Viterbi decoder for PowerPC G4/G5 Altivec
+ * Copyright Feb 2004, Phil Karn, KA9Q
+ * May be used under the terms of the GNU Lesser General Public License (LGPL)
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <sys/sysctl.h>
+#include "fec.h"
+
+typedef union { unsigned char c[256]; vector bool char v[16]; } decision_t;
+typedef union { unsigned char c[256]; vector unsigned char v[16]; } metric_t;
+
+static union branchtab29 { unsigned char c[128]; vector unsigned char v[8]; } Branchtab29[2];
+static int Init = 0;
+
+/* State info for instance of Viterbi decoder */
+struct v29 {
+  metric_t metrics1; /* path metric buffer 1 */
+  metric_t metrics2; /* path metric buffer 2 */
+  decision_t *dp;          /* Pointer to current decision */
+  metric_t *old_metrics,*new_metrics; /* Pointers to path metrics, swapped on every bit */
+  decision_t *decisions;   /* Beginning of decisions for block */
+};
+
+/* Initialize Viterbi decoder for start of new frame */
+int init_viterbi29_av(void *p,int starting_state){
+  struct v29 *vp = p;
+  int i;
+
+  if(p == NULL)
+    return -1;
+  for(i=0;i<16;i++)
+    vp->metrics1.v[i] = (vector unsigned char)(63);
+
+  vp->old_metrics = &vp->metrics1;
+  vp->new_metrics = &vp->metrics2;
+  vp->dp = vp->decisions;
+  vp->old_metrics->c[starting_state & 255] = 0; /* Bias known start state */
+  return 0;
+}
+
+void set_viterbi29_polynomial_av(int polys[2]){
+  int state;
+
+  for(state=0;state < 128;state++){
+    Branchtab29[0].c[state] = (polys[0] < 0) ^ parity((2*state) & abs(polys[0])) ? 255 : 0;
+    Branchtab29[1].c[state] = (polys[1] < 0) ^ parity((2*state) & abs(polys[1])) ? 255 : 0;
+  }
+  Init++;
+}
+
+/* Create a new instance of a Viterbi decoder */
+void *create_viterbi29_av(int len){
+  struct v29 *vp;
+
+  if(!Init){
+    int polys[2] = { V29POLYA,V29POLYB };
+    set_viterbi29_polynomial_av(polys);
+  }
+  if((vp = (struct v29 *)malloc(sizeof(struct v29))) == NULL)
+    return NULL;
+  if((vp->decisions = (decision_t *)malloc((len+8)*sizeof(decision_t))) == NULL){
+    free(vp);
+    return NULL;
+  }
+  init_viterbi29_av(vp,0);
+  return vp;
+}
+
+/* Viterbi chainback */
+int chainback_viterbi29_av(
+      void *p,
+      unsigned char *data, /* Decoded output data */
+      unsigned int nbits, /* Number of data bits */
+      unsigned int endstate){ /* Terminal encoder state */
+  struct v29 *vp = p;
+  decision_t *d;
+
+  if(p == NULL)
+    return -1;
+  d = (decision_t *)vp->decisions;  
+  /* Make room beyond the end of the encoder register so we can
+   * accumulate a full byte of decoded data
+   */
+  endstate %= 256;
+
+  /* The store into data[] only needs to be done every 8 bits.
+   * But this avoids a conditional branch, and the writes will
+   * combine in the cache anyway
+   */
+  d += 8; /* Look past tail */
+  while(nbits-- != 0){
+    int k;
+    
+    k = d[nbits].c[endstate] & 1;
+    data[nbits>>3] = endstate = (endstate >> 1) | (k << 7);
+  }
+  return 0;
+}
+
+
+/* Delete instance of a Viterbi decoder */
+void delete_viterbi29_av(void *p){
+  struct v29 *vp = p;
+
+  if(vp != NULL){
+    free(vp->decisions);
+    free(vp);
+  }
+}
+
+
+int update_viterbi29_blk_av(void *p,unsigned char *syms,int nbits){
+  struct v29 *vp = p;
+  decision_t *d;
+  int i;
+
+  if(p == NULL)
+    return -1;
+  d = (decision_t *)vp->dp;
+
+  while(nbits--){
+    vector unsigned char sym1v,sym2v;
+    void *tmp;
+    
+    /* All this seems necessary just to load a byte into all elements of a vector! */
+    sym1v = vec_perm(vec_ld(0,syms),vec_ld(1,syms),vec_lvsl(0,syms)); /* sym1v.0 = syms[0]; sym1v.1 = syms[1] */
+    sym2v = vec_splat(sym1v,1); /* Splat syms[1] across sym2v */
+    sym1v = vec_splat(sym1v,0); /* Splat syms[0] across sym1v */
+    syms += 2;
+    
+    for(i=0;i<8;i++){
+      vector bool char decision0,decision1;
+      vector unsigned char metric,m_metric,m0,m1,m2,m3,survivor0,survivor1;
+
+      /* Form branch metrics */
+      metric = vec_avg(vec_xor(Branchtab29[0].v[i],sym1v),vec_xor(Branchtab29[1].v[i],sym2v));
+      metric = vec_sr(metric,(vector unsigned char)(3));
+      m_metric = (vector unsigned char)(31) - metric;
+    
+      /* Add branch metrics to path metrics */
+      m0 = vec_adds(vp->old_metrics->v[i],metric);
+      m3 = vec_adds(vp->old_metrics->v[8+i],metric);
+      m1 = vec_adds(vp->old_metrics->v[8+i],m_metric);
+      m2 = vec_adds(vp->old_metrics->v[i],m_metric);
+    
+      /* Compare and select first set */
+      decision0 = vec_cmpgt(m0,m1);
+      decision1 = vec_cmpgt(m2,m3);
+      survivor0 = vec_min(m0,m1);
+      survivor1 = vec_min(m2,m3);
+
+      /* Interleave and store decisions and survivors */
+      d->v[2*i] = vec_mergeh(decision0,decision1);
+      d->v[2*i+1] = vec_mergel(decision0,decision1);
+      vp->new_metrics->v[2*i] = vec_mergeh(survivor0,survivor1);
+      vp->new_metrics->v[2*i+1] = vec_mergel(survivor0,survivor1);
+    }
+    d++;
+    /* renormalize if necessary */
+    if(vp->new_metrics->c[0] >= 50){
+      int i;
+      vector unsigned char scale0,scale1;
+
+      /* Find smallest metric and splat */
+      scale0 = vp->new_metrics->v[0];
+      scale1 = vp->new_metrics->v[1];
+      for(i=2;i<16;i+=2){
+	scale0 = vec_min(scale0,vp->new_metrics->v[i]);
+	scale1 = vec_min(scale1,vp->new_metrics->v[i+1]);
+      }
+      scale0 = vec_min(scale0,scale1);
+      scale0 = vec_min(scale0,vec_sld(scale0,scale0,8));
+      scale0 = vec_min(scale0,vec_sld(scale0,scale0,4));
+      scale0 = vec_min(scale0,vec_sld(scale0,scale0,2));
+      scale0 = vec_min(scale0,vec_sld(scale0,scale0,1));
+
+      /* Now subtract from all metrics */
+      for(i=0;i<16;i++)
+	vp->new_metrics->v[i] = vec_subs(vp->new_metrics->v[i],scale0);
+    }
+    /* Swap pointers to old and new metrics */
+    tmp = vp->old_metrics;
+    vp->old_metrics = vp->new_metrics;
+    vp->new_metrics = tmp;
+  }
+  vp->dp = d;
+  return 0;
+}
diff --git a/code/train/C/0123194_intlist-delAllGeV.c b/code/train/C/0123194_intlist-delAllGeV.c
new file mode 100644
index 0000000000000000000000000000000000000000..749f5c881901f588814acd4671844f3f7dc6dd77
--- /dev/null
+++ b/code/train/C/0123194_intlist-delAllGeV.c
@@ -0,0 +1,45 @@
+#include "linked_list.h"
+
+/*@ requires acyclic(x);
+*/
+intlist
+delAllGeV (intlist x, int v)
+{
+  intlist z;
+  intlist y = NULL;
+  intlist xi = x;
+  while (xi != NULL)
+    {
+      if (xi->data >= v)
+	{
+	  z = xi;
+	  xi = xi->next;
+	  free (z);
+	  if (y == NULL)
+	    x = xi;
+	  else
+	    y->next = xi;
+	}
+      else
+	{
+	  y = xi;
+	  xi = xi->next;
+	}
+    }
+  return x;
+}
+
+void
+main ()
+{
+  intlist head;
+  int i;
+
+  head = NULL;
+
+  head = allocate (head, 10);	//list of 10 to 1 
+
+  head = delAllGeV (head, 4);
+  printf ("Output after deleting values > value V here 4.. \n");
+  printlist (head);
+}
diff --git a/code/train/C/0123462_pfrng-tests.c b/code/train/C/0123462_pfrng-tests.c
new file mode 100644
index 0000000000000000000000000000000000000000..51fb00d591f8753a5d3f860803c4e7e14de248ca
--- /dev/null
+++ b/code/train/C/0123462_pfrng-tests.c
@@ -0,0 +1,164 @@
+/*
+    libpfrng — CPU jitter based random number generator
+    © 2013–2014, Oleksandr Natalenko aka post-factum <oleksandr@natalenko.name>
+
+    This program 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, version 3 of the License.
+
+    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 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 <getopt.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sysexits.h>
+
+#include "../../libpfrng.h"
+
+#define PASSES		1000000
+#define BUFFER1_SIZE	113
+#define BUFFER2_SIZE	27
+
+int main(int argc, char** argv)
+{
+	int opts;
+	unsigned int fast = 0;
+	struct option longopts[] =
+	{
+		{"fast", no_argument, NULL, 'f'},
+		{0, 0, 0, 0}
+	};
+	while ((opts = getopt_long(argc, argv, "f", longopts, NULL)) != -1)
+		switch (opts)
+		{
+			case 'f':
+				fast = 1;
+				break;
+			default:
+				fprintf(stderr, "Unknown option: %c\n", opts);
+				exit(EX_USAGE);
+				break;
+		}
+
+
+	pfrng_init();
+
+	double sum;
+	FILE *fout;
+
+	printf("Performing normalization test for uniform distribution...\n");
+	sum = 0;
+	fout = fopen("out.uniform", "w");
+	for (uint64_t i = 0; i < PASSES; i++)
+	{
+		double rn;
+		if (fast)
+			rn = pfrng_get_lf_fast();
+		else
+			rn = pfrng_get_lf();
+		sum += rn;
+		fprintf(fout, "%1.16lf\n", rn);
+		fflush(fout);
+	}
+	fclose(fout);
+	printf("%1.16lf\n", sum / PASSES);
+
+	printf("Performing normalization test for normal distribution...\n");
+	sum = 0;
+	fout = fopen("out.normal", "w");
+	for (uint64_t i = 0; i < PASSES; i++)
+	{
+		double rn;
+		if (fast)
+			rn = pfrng_get_gauss_fast();
+		else
+			rn = pfrng_get_gauss();
+		sum += rn;
+		fprintf(fout, "%1.16lf\n", rn);
+		fflush(fout);
+	}
+	fclose(fout);
+	printf("%1.16lf\n", sum / PASSES);
+
+	printf("Filling %u bytes buffer...\n", BUFFER1_SIZE);
+	unsigned char *buffer1 = malloc(BUFFER1_SIZE * sizeof(unsigned char));
+	printf("Buffer 1 address: %p\n", buffer1);
+	uint64_t buffer1_filled;
+	if (fast)
+		buffer1_filled = pfrng_fill_buffer_u_fast(buffer1, BUFFER1_SIZE);
+	else
+		buffer1_filled = pfrng_fill_buffer_u(buffer1, BUFFER1_SIZE);
+	printf("%ju bytes filled:\n", buffer1_filled);
+	for (uint8_t i = 0; i < BUFFER1_SIZE; i++)
+	{
+		if (i % 40 == 0 && i != 0)
+			printf("\n");
+		printf("%02x ", buffer1[i]);
+	}
+	printf("\n");
+
+	printf("Filling %u bytes buffer...\n", BUFFER2_SIZE);
+	unsigned char *buffer2 = malloc(BUFFER2_SIZE * sizeof(unsigned char));
+	printf("Buffer 2 address: %p\n", buffer2);
+	uint64_t buffer2_filled;
+	if (fast)
+		buffer2_filled = pfrng_fill_buffer_u_fast(buffer2, BUFFER2_SIZE);
+	else
+		buffer2_filled = pfrng_fill_buffer_u(buffer2, BUFFER2_SIZE);
+	printf("%ju bytes filled:\n", buffer2_filled);
+	for (uint8_t i = 0; i < BUFFER2_SIZE; i++)
+	{
+		if (i % 40 == 0 && i != 0)
+			printf("\n");
+		printf("%02x ", buffer2[i]);
+	}
+	printf("\n");
+
+	printf("Estimating pi value...\n");
+	uint64_t pi_in = 0;
+	double p = 0;
+	for (uint64_t i = 0; i < PASSES; i++)
+	{
+		double X = 0, Y = 0, D = 0;
+		if (fast)
+		{
+			X = pfrng_get_lf_fast();
+			Y = pfrng_get_lf_fast();
+		} else
+		{
+			X = pfrng_get_lf();
+			Y = pfrng_get_lf();
+		}
+
+		D = pow(X, 2) + pow(Y, 2);
+		if (D <= 1)
+			pi_in++;
+	}
+	p = (double)pi_in / (double)PASSES;
+	printf("pi≈%lf\n", 4.0 * p);
+
+	printf("Building frequency table...\n");
+	fout = fopen("out.freq", "w");
+	pfrng_stats_t stats = pfrng_get_stats();
+	for (uint64_t i = 0; i < UINT64_SIZE; i++)
+	{
+		fprintf(fout, "%ju\t%ju\n", i, stats.freq[i]);
+		fflush(fout);
+	}
+	fclose(fout);
+	
+	printf("Bits misses: %ju\n", stats.bits_misses);
+
+	pfrng_done();
+
+	exit(EX_OK);
+}
+
diff --git a/code/train/C/0123772_packet-redbackli.c b/code/train/C/0123772_packet-redbackli.c
new file mode 100644
index 0000000000000000000000000000000000000000..f74eabb4c35b337bc67556f01c3217cc8810415f
--- /dev/null
+++ b/code/train/C/0123772_packet-redbackli.c
@@ -0,0 +1,289 @@
+/* packet-redbackli.c
+ *
+ * $Id: packet-redbackli.c 45017 2012-09-20 02:03:38Z morriss $
+ *
+ * Redback Lawful Intercept Packet dissector
+ *
+ * Copyright 2008 Florian Lohoff <flo[AT]rfc822.org>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald[AT]wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * 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.
+ */
+
+#include "config.h"
+
+#include <glib.h>
+
+#include <epan/packet.h>
+#include <epan/addr_resolv.h>
+#include <epan/strutil.h>
+
+static int proto_redbackli = -1;
+
+static int hf_redbackli_seqno = -1;		/* Sequence No */
+static int hf_redbackli_liid = -1;		/* LI Id */
+static int hf_redbackli_sessid = -1;		/* Session Id */
+static int hf_redbackli_label = -1;		/* Label */
+static int hf_redbackli_acctid = -1;		/* Accounting Session Id */
+static int hf_redbackli_dir = -1;		/* Direction */
+static int hf_redbackli_eohpad = -1;		/* End Of Header Padding */
+static int hf_redbackli_unknownavp = -1;	/* Unknown AVP */
+
+static int ett_redbackli = -1;
+
+static dissector_handle_t ip_handle;
+
+#define RB_AVP_SEQNO	1
+#define RB_AVP_LIID	2
+#define RB_AVP_SESSID	3
+#define RB_AVP_DIR	4
+#define RB_AVP_LABEL	20
+#define RB_AVP_ACCTID	40
+#define RB_AVP_EOH	0
+
+static const value_string avp_names[] = {
+	{RB_AVP_SEQNO,		"Sequence No"},
+	{RB_AVP_LIID,		"Lawful Intercept Id"},
+	{RB_AVP_SESSID,		"Session Id"},
+	{RB_AVP_LABEL,		"Label"},
+	{RB_AVP_ACCTID,		"Accounting Session Id"},
+	{RB_AVP_DIR,		"Direction"},
+	{RB_AVP_EOH,		"End Of Header"},
+	{0,			NULL}
+};
+
+static void
+redbackli_dissect_avp(guint8 avptype, guint8 avplen, tvbuff_t *tvb, gint offset, proto_tree *tree)
+{
+	const char	*avpname;
+	proto_tree	*ti, *st=NULL;
+
+	avpname=val_to_str_const(avptype, avp_names, "Unknown");
+
+	ti = proto_tree_add_text(tree, tvb, offset, avplen+2, "%s AVP", avpname);
+	st = proto_item_add_subtree(ti, ett_redbackli);
+
+	proto_tree_add_text(st, tvb, offset, 1, "AVP Type: %d", avptype);
+	proto_tree_add_text(st, tvb, offset+1, 1, "AVP Length: %d", avplen);
+
+	if (!avplen)
+		return;
+
+        /* XXX: ToDo: Validate the length (avplen) of the fixed length fields
+                before calling proto_tree_add_item().
+                Note that the field lengths have been validated when
+                dissect_avp() is called from redbackli_dissect_heur().
+         */
+
+	switch(avptype) {
+		case(RB_AVP_SEQNO):
+			proto_tree_add_item(st, hf_redbackli_seqno, tvb,
+					    offset+2, avplen, ENC_BIG_ENDIAN);
+			break;
+		case(RB_AVP_LIID):
+			proto_tree_add_item(st, hf_redbackli_liid, tvb,
+					    offset+2, avplen, ENC_BIG_ENDIAN);
+			break;
+		case(RB_AVP_SESSID):
+			proto_tree_add_item(st, hf_redbackli_sessid, tvb,
+					    offset+2, avplen, ENC_BIG_ENDIAN);
+			break;
+		case(RB_AVP_LABEL):
+			proto_tree_add_item(st, hf_redbackli_label, tvb,
+					    offset+2, avplen, ENC_ASCII|ENC_NA);
+			break;
+		case(RB_AVP_EOH):
+			proto_tree_add_item(st, hf_redbackli_eohpad, tvb,
+					    offset+2, avplen, ENC_NA);
+			break;
+		case(RB_AVP_DIR):
+			proto_tree_add_item(st, hf_redbackli_dir, tvb,
+					offset+2, avplen, ENC_NA);
+			break;
+		case(RB_AVP_ACCTID):
+			proto_tree_add_item(st, hf_redbackli_acctid, tvb,
+					    offset+2, avplen, ENC_NA);
+			break;
+		default:
+			proto_tree_add_item(st, hf_redbackli_unknownavp, tvb,
+					    offset+2, avplen, ENC_NA);
+			break;
+	}
+
+	return;
+}
+
+static void
+redbackli_dissect(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
+{
+	guint8		avptype, avplen;
+	gint		len, offset=0;
+	gboolean	eoh;
+	proto_tree	*ti, *redbackli_tree=NULL;
+	tvbuff_t	*next_tvb;
+
+	col_set_str(pinfo->cinfo,COL_PROTOCOL,"RBLI");
+
+	if (tree) {
+		ti = proto_tree_add_item(tree, proto_redbackli,
+					 tvb, 0, -1, ENC_NA);
+		redbackli_tree = proto_item_add_subtree(ti, ett_redbackli);
+	}
+
+	len=tvb_length(tvb);
+	offset=0;
+	eoh=FALSE;
+	while(!eoh && (len > 2)) {
+		avptype = tvb_get_guint8(tvb, offset+0);
+		avplen = tvb_get_guint8(tvb, offset+1);
+
+		if ((len-2) < avplen)		/* AVP Complete ? */
+			break;
+
+		if (tree)
+			redbackli_dissect_avp(avptype, avplen, tvb, offset, redbackli_tree);
+
+		if (avptype == RB_AVP_EOH)
+			eoh=TRUE;
+
+		offset+=2+avplen;
+		len-=2+avplen;
+	}
+
+	next_tvb = tvb_new_subset_remaining(tvb, offset);
+	call_dissector(ip_handle, next_tvb, pinfo, tree);
+}
+
+
+#define REDBACKLI_INTSIZE	6
+#define REDBACKLI_EOHSIZE	2
+#define MIN_REDBACKLI_SIZE	(3*REDBACKLI_INTSIZE+REDBACKLI_EOHSIZE)
+
+static gboolean
+redbackli_dissect_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
+{
+	gint		len, offset=0;
+	gboolean	eoh=FALSE;
+	guint8		avptype, avplen;
+	guint32		avpfound=0;
+
+	len=tvb_length(tvb);
+	if (len < MIN_REDBACKLI_SIZE)
+		return FALSE;
+
+	/*
+	 * We scan the possible AVPs and look out for mismatches.
+	 * An int AVP needs to be 4 byte long, and the eoh must be 0 or 1
+	 * long .. Unknown AVPs also mean not for us ...
+	 *
+	 */
+	while((len > 2) && !eoh) {
+		avptype = tvb_get_guint8(tvb, offset+0);
+		avplen = tvb_get_guint8(tvb, offset+1);
+
+		switch(avptype) {
+			case(RB_AVP_SEQNO):
+			case(RB_AVP_LIID):
+			case(RB_AVP_SESSID):
+				if (avplen != 4)
+					return FALSE;
+				avpfound|=1<<avptype;
+				break;
+			case(RB_AVP_EOH):
+				if (avplen > 1 || offset == 0)
+					return FALSE;
+				eoh=TRUE;
+				break;
+			case(RB_AVP_LABEL):
+			case(RB_AVP_DIR):   /* Is this correct? the hf_ originally had FT_UINT8 for DIR */
+			case(RB_AVP_ACCTID):
+				break;
+			default:
+				return FALSE;
+		}
+		offset+=2+avplen;
+		len-=2+avplen;
+	}
+
+	if (!(avpfound & (1<<RB_AVP_SEQNO)))
+		return FALSE;
+	if (!(avpfound & (1<<RB_AVP_SESSID)))
+		return FALSE;
+	if (!(avpfound & (1<<RB_AVP_LIID)))
+		return FALSE;
+
+	redbackli_dissect(tvb, pinfo, tree);
+
+	return TRUE;
+}
+void proto_register_redbackli(void) {
+	static hf_register_info hf[] = {
+		{ &hf_redbackli_seqno,
+			{ "Sequence No", "redbackli.seqno", FT_UINT32, BASE_DEC, NULL, 0x0,
+			NULL, HFILL }},
+		{ &hf_redbackli_liid,
+			{ "Lawful Intercept Id", "redbackli.liid", FT_UINT32, BASE_DEC, NULL, 0x0,
+			"LI Identifier", HFILL }},
+		{ &hf_redbackli_sessid,
+			{ "Session Id", "redbackli.sessid", FT_UINT32, BASE_DEC, NULL, 0x0,
+			"Session Identifier", HFILL }},
+		{ &hf_redbackli_dir,
+#if 0 /* XXX: If one goes by the heuristic then this field can be variable length ??
+         In the absence of any documentation We'll assume that's the case
+         (even though 'direction' sounds like a fixed length field */
+			{ "Direction", "redbackli.dir", FT_UINT8, BASE_DEC, NULL, 0x0,
+#endif
+			{ "Direction", "redbackli.dir", FT_BYTES, BASE_NONE, NULL, 0x0,
+			NULL, HFILL }},
+		{ &hf_redbackli_label,
+			{ "Label", "redbackli.label", FT_STRING, BASE_NONE, NULL, 0x0,
+			NULL, HFILL }},
+		{ &hf_redbackli_acctid,
+			{ "Acctid", "redbackli.acctid", FT_BYTES, BASE_NONE, NULL, 0x0,
+			NULL, HFILL }},
+		{ &hf_redbackli_eohpad,
+			{ "End of Header Padding", "redbackli.eohpad", FT_BYTES, BASE_NONE, NULL, 0x0,
+			NULL, HFILL }},
+		{ &hf_redbackli_unknownavp,
+			{ "Unknown AVP", "redbackli.unknownavp", FT_BYTES, BASE_NONE, NULL, 0x0,
+			NULL, HFILL }}
+		};
+
+	static gint *ett[] = {
+		&ett_redbackli
+	};
+
+	proto_redbackli = proto_register_protocol("Redback Lawful Intercept",
+						  "RedbackLI","redbackli");
+
+	proto_register_field_array(proto_redbackli,hf,array_length(hf));
+	proto_register_subtree_array(ett,array_length(ett));
+
+	register_dissector("redbackli", redbackli_dissect, proto_redbackli);
+}
+
+void proto_reg_handoff_redbackli(void) {
+	dissector_handle_t redbackli_handle;
+
+	ip_handle = find_dissector("ip");
+
+	redbackli_handle = find_dissector("redbackli");
+	dissector_add_handle("udp.port", redbackli_handle);  /* for 'decode-as' */
+
+	heur_dissector_add("udp", redbackli_dissect_heur, proto_redbackli);
+}
diff --git a/code/train/C/0123929_tlb.c b/code/train/C/0123929_tlb.c
new file mode 100644
index 0000000000000000000000000000000000000000..02e3e06bb03313b99b3aa1a10c7df57c5f79bef9
--- /dev/null
+++ b/code/train/C/0123929_tlb.c
@@ -0,0 +1,154 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/stddef.h"
+#include "linux/sched.h"
+#include "linux/mm.h"
+#include "asm/page.h"
+#include "asm/pgtable.h"
+#include "asm/mmu.h"
+#include "user_util.h"
+#include "mem_user.h"
+#include "skas.h"
+#include "os.h"
+
+static void fix_range(struct mm_struct *mm, unsigned long start_addr,
+		      unsigned long end_addr, int force)
+{
+	pgd_t *npgd;
+	pmd_t *npmd;
+	pte_t *npte;
+	unsigned long addr;
+	int r, w, x, err, fd;
+
+	if(mm == NULL) return;
+	fd = mm->context.skas.mm_fd;
+	for(addr = start_addr; addr < end_addr;){
+		npgd = pgd_offset(mm, addr);
+		npmd = pmd_offset(npgd, addr);
+		if(pmd_present(*npmd)){
+			npte = pte_offset_kernel(npmd, addr);
+			r = pte_read(*npte);
+			w = pte_write(*npte);
+			x = pte_exec(*npte);
+			if(!pte_dirty(*npte)) w = 0;
+			if(!pte_young(*npte)){
+				r = 0;
+				w = 0;
+			}
+			if(force || pte_newpage(*npte)){
+				err = unmap(fd, (void *) addr, PAGE_SIZE);
+				if(err < 0)
+					panic("munmap failed, errno = %d\n",
+					      -err);
+				if(pte_present(*npte))
+					map(fd, addr, 
+					    pte_val(*npte) & PAGE_MASK,
+					    PAGE_SIZE, r, w, x);
+			}
+			else if(pte_newprot(*npte)){
+				protect(fd, addr, PAGE_SIZE, r, w, x, 1);
+			}
+			*npte = pte_mkuptodate(*npte);
+			addr += PAGE_SIZE;
+		}
+		else {
+			if(force || pmd_newpage(*npmd)){
+				err = unmap(fd, (void *) addr, PMD_SIZE);
+				if(err < 0)
+					panic("munmap failed, errno = %d\n",
+					      -err);
+				pmd_mkuptodate(*npmd);
+			}
+			addr += PMD_SIZE;
+		}
+	}
+}
+
+void flush_tlb_kernel_range_skas(unsigned long start, unsigned long end)
+{
+	struct mm_struct *mm;
+	pgd_t *pgd;
+	pmd_t *pmd;
+	pte_t *pte;
+	unsigned long addr;
+	int updated = 0, err;
+
+	mm = &init_mm;
+	for(addr = start; addr < end;){
+		pgd = pgd_offset(mm, addr);
+		pmd = pmd_offset(pgd, addr);
+		if(pmd_present(*pmd)){
+			pte = pte_offset_kernel(pmd, addr);
+			if(!pte_present(*pte) || pte_newpage(*pte)){
+				updated = 1;
+				err = os_unmap_memory((void *) addr, 
+						      PAGE_SIZE);
+				if(err < 0)
+					panic("munmap failed, errno = %d\n",
+					      -err);
+				if(pte_present(*pte))
+					map_memory(addr, 
+						   pte_val(*pte) & PAGE_MASK,
+						   PAGE_SIZE, 1, 1, 1);
+			}
+			else if(pte_newprot(*pte)){
+				updated = 1;
+				protect_memory(addr, PAGE_SIZE, 1, 1, 1, 1);
+			}
+			addr += PAGE_SIZE;
+		}
+		else {
+			if(pmd_newpage(*pmd)){
+				updated = 1;
+				err = os_unmap_memory((void *) addr, PMD_SIZE);
+				if(err < 0)
+					panic("munmap failed, errno = %d\n",
+					      -err);
+			}
+			addr += PMD_SIZE;
+		}
+	}
+}
+
+void flush_tlb_kernel_vm_skas(void)
+{
+	flush_tlb_kernel_range_skas(start_vm, end_vm);
+}
+
+void __flush_tlb_one_skas(unsigned long addr)
+{
+	flush_tlb_kernel_range_skas(addr, addr + PAGE_SIZE);
+}
+
+void flush_tlb_range_skas(struct vm_area_struct *vma, unsigned long start, 
+		     unsigned long end)
+{
+	if(vma->vm_mm == NULL)
+		flush_tlb_kernel_range_skas(start, end);
+	else fix_range(vma->vm_mm, start, end, 0);
+}
+
+void flush_tlb_mm_skas(struct mm_struct *mm)
+{
+	flush_tlb_kernel_vm_skas();
+	fix_range(mm, 0, host_task_size, 0);
+}
+
+void force_flush_all_skas(void)
+{
+	fix_range(current->mm, 0, host_task_size, 1);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/code/train/C/0124122_verify.c b/code/train/C/0124122_verify.c
new file mode 100644
index 0000000000000000000000000000000000000000..6942fdb21e8c114991140d23118e471ce5fe49e7
--- /dev/null
+++ b/code/train/C/0124122_verify.c
@@ -0,0 +1,247 @@
+/* VERIFY.C - Verify encoded or decoded blocks. */
+
+/* Copyright (c) 2000, 2001 by Radford M. Neal 
+ *
+ * Permission is granted for anyone to copy, use, modify, or distribute this
+ * program and accompanying programs and documents for any purpose, provided 
+ * this copyright notice is retained and prominently displayed, along with
+ * a note saying that the original programs are available from Radford Neal's
+ * web page, and note is made of any changes made to the programs.  The
+ * programs and documents are distributed without any warranty, express or
+ * implied.  As the programs were written for research purposes only, they have
+ * not been tested to the degree that would be advisable in any important
+ * application.  All use of these programs is entirely at the user's own risk.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "alloc.h"
+#include "blockio.h"
+#include "open.h"
+#include "mod2sparse.h"
+#include "mod2dense.h"
+#include "mod2convert.h"
+#include "rcode.h"
+#include "check.h"
+
+void usage(void);
+
+
+/* MAIN PROGRAM. */
+
+int main
+( int argc,
+  char **argv
+)
+{
+  char *coded_file, *source_file;
+  char *pchk_file, *gen_file;
+  int table;
+
+  char *sblk, *cblk, *chks;
+  int seof, ceof;
+  int srcerr, chkerr, bit_errs;
+  int i, n;
+  FILE *srcf, *codef;
+
+  int tot_srcerrs, tot_chkerrs, tot_botherrs;
+
+  /* Look at arguments. */
+
+  table = 0;
+  if (argc>1 && strcmp(argv[1],"-t")==0)
+  { table = 1;
+    argc -= 1;
+    argv += 1;
+  }
+
+  if (argc<3 || argc>5) usage();
+
+  if (!(pchk_file = argv[1])
+   || !(coded_file = argv[2]))
+  { usage();
+  }
+ 
+  gen_file = 0;
+  source_file = 0;
+
+  if (argv[3])
+  { gen_file = argv[3];
+    if (argv[4])
+    { source_file = argv[4];
+      if (argv[5])
+      { usage();
+      }
+    }
+  }
+
+  if ((strcmp(pchk_file,"-")==0) 
+    + (strcmp(coded_file,"-")==0) 
+    + (source_file!=0 && strcmp(source_file,"-")==0)
+    + (gen_file!=0 && strcmp(gen_file,"-")==0) > 1)
+  { fprintf(stderr,"Can't read more than one stream from standard input\n");
+    exit(1);
+  }
+
+  /* Read parity check file. */
+
+  read_pchk(pchk_file);
+
+  if (N<=M)
+  { fprintf(stderr,
+     "Number of bits (%d) should be greater than number of checks (%d)\n",N,M);
+    exit(1);
+  }
+
+  /* Read generator matrix file, if given, up to the point of finding
+     out which are the message bits. */
+
+  if (gen_file!=0)
+  { read_gen(gen_file,1,0);
+  }
+
+  /* Open coded file to check. */
+
+  codef = open_file_std(coded_file,"r");
+  if (codef==NULL)
+  { fprintf(stderr,"Can't open coded file: %s\n",coded_file);
+    exit(1);
+  }
+
+  /* Open source file to verify against, if given. */
+
+  if (source_file!=0)
+  { 
+    srcf = open_file_std(source_file,"r");
+    if (srcf==NULL)
+    { fprintf(stderr,"Can't open source file: %s\n",source_file);
+      exit(1);
+    }
+  }
+
+  sblk = chk_alloc (N-M, sizeof *sblk);
+  cblk = chk_alloc (N, sizeof *cblk);
+  chks = chk_alloc (M, sizeof *chks);
+
+  /* Print header for table. */
+
+  if (table)
+  { if (gen_file!=0)
+    { printf("  block chkerrs srcerrs\n");
+    }
+    else
+    { printf("  block chkerrs\n");
+    }
+  }
+
+  /* Verify successive blocks. */
+
+  tot_srcerrs = 0;
+  tot_chkerrs = 0;
+  tot_botherrs = 0;
+
+  bit_errs = 0;
+
+  seof = 0; 
+  ceof = 0;
+
+  for (n = 0; ; n++)
+  { 
+    /* Read block from coded file. */
+    
+    if (blockio_read(codef,cblk,N)==EOF) 
+    { ceof = 1;
+    }
+
+    /* Read block from source file, if given. */
+
+    if (source_file!=0 && !ceof && !seof)
+    { if (blockio_read(srcf,sblk,N-M)==EOF) 
+      { fprintf(stderr,"Warning: Not enough source blocks (only %d)\n",n);
+        seof = 1;
+      }
+    }
+
+    /* Stop if end of received file. */
+
+    if (ceof) break;
+
+    /* Check that received block is a code word, and if not find the number of
+       parity check errors. */
+
+    chkerr = check(H,cblk,chks);
+
+    /* Check against source block, if provided, or against zeros, if
+       the generator matrix was provided but no source file. */
+
+    if (gen_file!=0)
+    { srcerr = 0;
+      if (source_file!=0 && !seof)
+      { for (i = M; i<N; i++)
+        { if (cblk[cols[i]]!=sblk[i-M])
+          { srcerr += 1;
+          }
+        }
+      }
+      if (source_file==0)
+      { for (i = M; i<N; i++)
+        { if (cblk[cols[i]]!=0)
+          { srcerr += 1;
+          }
+        }
+      }
+      bit_errs += srcerr;
+    }
+
+    /* Print table entry. */
+
+    if (table)
+    { if (gen_file!=0)
+      { printf("%6d %7d %7d\n",n,chkerr,srcerr);
+      }
+      else
+      { printf("%6d %7d\n",n,chkerr);
+      }
+    }
+
+    /* Increment totals. */
+
+    if (chkerr) tot_chkerrs += 1;
+    if (gen_file!=0 && (source_file==0 || !seof))
+    { if (srcerr) tot_srcerrs += 1;
+      if (srcerr && chkerr) tot_botherrs += 1;
+    }
+  }
+
+  /* Write final statistics to standard error.  Flush standard output 
+     first to avoid mixing of output. */
+
+  fflush(stdout);
+
+  if (gen_file!=0)
+  { fprintf(stderr,
+     "Block counts: tot %d, with chk errs %d, with src errs %d, both %d\n",
+      n, tot_chkerrs, tot_srcerrs, tot_botherrs);
+    fprintf(stderr,
+     "Bit error rate (on message bits only): %.3e\n", 
+      (double)bit_errs/(n*(N-M)));
+  }
+  else
+  { fprintf (stderr, 
+     "Block counts: tot %d, with chk errs %d\n", n, tot_chkerrs);
+  }
+
+  return 0;
+}
+
+
+/* PRINT USAGE MESSAGE AND EXIT. */
+
+void usage(void)
+{ fprintf(stderr,
+ "Usage: verify [ -t ] pchk-file decoded-file [ gen-file [ source-file ] ]\n");
+  exit(1);
+}
diff --git a/code/train/C/0124140_getFloatAsTwoInts.c b/code/train/C/0124140_getFloatAsTwoInts.c
new file mode 100644
index 0000000000000000000000000000000000000000..ac7293ad6ff312d57ad65147b81b8dbf59a99c4a
--- /dev/null
+++ b/code/train/C/0124140_getFloatAsTwoInts.c
@@ -0,0 +1,102 @@
+/*
+ * Filename:    getFloatAsTwoInts.c
+ * Author:      Andrew Laing
+ * Email:       parisianconnections@gmail.com
+ * Date:        13/06/2017.
+ * Description: Input a float and store it as two integers, one for
+ *              the left hand side of the decimal point, and one for
+ *              the right hjand side.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define MAXFLOATLEN 14
+#define MAXINTVAL 999999   /* Thus maxFloat = 999999.999999*/
+
+
+int getLine( char [], int );
+int getFloatAsTwoInts(int [2]);
+
+
+int main()
+{
+    int num1[2] = {0};
+    
+    printf("Enter float string (MAX 13 CHARS) > ");
+    getFloatAsTwoInts(num1);
+    
+    printf("lhs = %06d\n", num1[0]);
+    printf("rhs = %06d\n", num1[1]);
+         
+    return 0;
+}
+
+
+/* Read a string into a character array and return the length of the array */
+int getLine( char s[], int maxLength )
+{
+    int c, i=0;
+    
+    while( ( --maxLength > 0)  && ( (c=getchar())!=EOF ) && ( c!='\n' ) )
+        s[i++]=c;
+
+    if(c=='\n')
+        s[i++]=c;
+    s[i] = '\0';
+    
+    fflush(stdin); /* Clear any overflow*/
+    
+    return i;   
+}
+
+
+/* Returns a 1 if valid, -1 if invalid */
+int getFloatAsTwoInts(int floatSides[2])
+{
+    char str[MAXFLOATLEN], rhStr[MAXFLOATLEN];
+    int lhs=0, rhs=0;
+    
+    /* Input a float string */
+    getLine(str, MAXFLOATLEN);
+        
+    /* Get number on lhs of fp */
+    sscanf(str, "%d", &lhs);    
+    floatSides[0] = lhs;    
+
+    /* find index of floating point */
+    int i=0, fpIndex = -1;
+    
+    do {
+        if(str[i]=='.')
+            fpIndex = i;
+        i++;
+    } while(i<MAXFLOATLEN && fpIndex==-1);
+    
+    /* Get number on rhs of fp */
+    if(fpIndex >= 0) 
+    {
+        int k;
+
+        for(i=0, k=fpIndex+1; 
+            k<MAXFLOATLEN && str[k]!='\0' && str[k]!='\n'; i++, k++)
+            rhStr[i] = str[k];
+        rhStr[i]='\0';
+        
+        sscanf(rhStr, "%d", &rhs);
+        
+        /* Remove excess numbers */
+        while(rhs>MAXINTVAL)
+            rhs/=10;
+        
+        floatSides[1] = rhs; 
+    }
+
+    if(lhs > MAXINTVAL) {
+        printf("\n*** Fatal Error! Floating-point Accumulator overflow ***\n");
+        return -1;
+    }
+    else
+        return 1;
+}
+
diff --git a/code/train/C/0124530_Utils.c b/code/train/C/0124530_Utils.c
new file mode 100644
index 0000000000000000000000000000000000000000..594efb4d76aa827faa17db7e9bbc28c10522c5b4
--- /dev/null
+++ b/code/train/C/0124530_Utils.c
@@ -0,0 +1,60 @@
+/*
+	Some stuff from SDL
+ */
+
+#include <sys/time.h>
+#include <unistd.h>
+#include <errno.h>
+#include <android/log.h>
+
+#include "Utils.h"
+
+static struct timeval start;
+
+int a_printf(const char *fmt, ...)
+{
+    va_list ap;
+    va_start(ap,fmt);
+    return __android_log_vprint(ANDROID_LOG_WARN, "ALYNX", fmt, ap);
+}
+
+void StartTicks(void)
+{
+	gettimeofday(&start, NULL);
+}
+
+Uint32 GetTicks()
+{
+	struct timeval now;
+	Uint32 ticks;
+
+	gettimeofday(&now, NULL);
+	ticks=(now.tv_sec-start.tv_sec)*1000+(now.tv_usec-start.tv_usec)/1000;
+	return(ticks);
+}
+
+void Delay(Uint32 ms)
+{
+	int was_error;
+	struct timeval tv;
+	Uint32 then, now, elapsed;
+	then = GetTicks();
+	do {
+		errno = 0;
+
+		/* Calculate the time interval left (in case of interrupt) */
+		now = GetTicks();
+		elapsed = (now-then);
+		then = now;
+		if ( elapsed >= ms ) {
+			break;
+		}
+		ms -= elapsed;
+		tv.tv_sec = ms/1000;
+		tv.tv_usec = (ms%1000)*1000;
+
+		was_error = select(0, NULL, NULL, NULL, &tv);
+
+	} while ( was_error && (errno == EINTR) );
+
+}
\ No newline at end of file
diff --git a/code/train/C/0126323_longtest.c b/code/train/C/0126323_longtest.c
new file mode 100644
index 0000000000000000000000000000000000000000..10f7dfa3c8295014e0aa6842f9cfdaa2d5ed877f
--- /dev/null
+++ b/code/train/C/0126323_longtest.c
@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <math.h>
+extern double era_sinh(double x);
+double abs(double x) {
+	if (x < 0) {return -x;}
+	return x;
+}
+
+int main() {
+    double d = 0;
+    double maxDiviation = 0;
+    double maxErrorD = 0;
+    int i = 0;
+    do {
+        double ms = era_sinh(d);
+        double s = sinh(d);
+	double diviation = abs(1-ms/s);
+        if (diviation > maxDiviation) {
+		maxDiviation = diviation;
+		maxErrorD = d;
+	}
+        if (i % 1000000 == 0) {
+            i = 0;
+            printf("d: %f my_sinh: %9.4e sinh: %9.4e delta: %9.4e\n", d, ms, s, ms/s - 1);
+        }
+        i += 1;
+        d += 0.00001;
+    } while (d <= 710);
+    printf("d: %f diviation: %f", maxErrorD, maxDiviation);
+    return 0;
+}
diff --git a/code/train/C/0127346_quick.c b/code/train/C/0127346_quick.c
new file mode 100644
index 0000000000000000000000000000000000000000..66ddfe72a268e982e642ca47395216660784e04b
--- /dev/null
+++ b/code/train/C/0127346_quick.c
@@ -0,0 +1,42 @@
+#include<stdio.h>
+
+void swap(int a[], int m, int n) {
+	int t;
+	t = a[m];
+	a[m] = a[n];
+	a[n] = t; 
+
+	return;
+}
+
+void quick(int a[], int low, int high) {
+
+	if(low<=high) {
+		int temp = a[low]; // copy this element
+		int p = low;  // this is partition index 
+
+		for(int i=low; i<=high; i++) { //including low and high indices
+			if(a[i] < temp) {
+				p++;
+				swap(a, i, p);
+			}
+		}
+
+		swap(a, low, p);
+
+		quick(a, low, p-1);
+		quick(a, p+1, high);
+	}
+}
+
+int main() {
+
+	int a[] = {3, 6, 1, 4, 7, 8, 9, 2, 5};
+
+	int len = sizeof(a) / sizeof(a[0]);
+	quick(a, 0, len-1);
+
+	for(int i=0; i<len; i++)
+		printf("%d", a[i]);
+	return 0;
+}
diff --git a/code/train/C/0127826_matrix_read_1d.c b/code/train/C/0127826_matrix_read_1d.c
new file mode 100644
index 0000000000000000000000000000000000000000..a621ae2b73762c254d60235a641589465b1270a5
--- /dev/null
+++ b/code/train/C/0127826_matrix_read_1d.c
@@ -0,0 +1,274 @@
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+
+#include "matr_functions_1d.h"
+
+void set_value(int row, int column, matrix_1d matr, double value)
+{
+    matr.values[row*matr.columns + column] = value;
+}
+
+double get_value(int row, int column, matrix_1d matr)
+{
+    return matr.values[row*matr.columns + column];
+}
+
+/*
+*   Checks if the given row is not in the matrix.
+*/
+int row_not_present(matrix_1d matrix, int * row)
+{
+    int i, j=0, val;
+
+    if(0==matrix.rows)  // If the matrix is empty, the row cant be present. (DUH)
+        return 1;
+
+    for(i=0;i<matrix.rows;i++)
+    {
+        while(j<matrix.columns)
+        {
+            // Cast the double to an integer.
+            val = (int )get_value(i, j, matrix);
+
+            if(row[j]!=val)
+            {
+                break;  // If the value is not present, the row isnt either.
+            }
+            j++;
+        }
+
+        if(matrix.columns==j)   // If we went through the inner loop, we
+            return 0;           // found a row that is the same.
+    }
+
+    return 1;
+}
+
+/* Basic Write matrix function. Can write to stdout or a specified file. No return value. */
+void write_matrix_1d(matrix_1d matr, char * file_name)
+{
+	FILE * file;
+	int i, j;
+	double value = 0;
+
+	if(matr.rows == -1)		// Checking for reading error.
+	{
+		fprintf(stderr, "Matrix is empty.\nReason: reading error.\n");
+		return;
+	}
+	else if(matr.columns == -1)		// Checking for matrix multiplication error.
+	{
+		fprintf(stderr, "Matrix is empty.\nReason: multiplication error.\n");
+		return;
+	}
+
+	if(strcmp(file_name, "stdout"))		// Check where we want to write.
+		file = fopen(file_name, "w");
+	else
+	{
+		file = stdout;
+		printf("Details of the matrix:\nRows: %d\nColumns: %d\nThe matrix:\n", matr.rows, matr.columns);
+	}
+
+	if(file == NULL)
+	{
+		perror("Error opening file.\n");
+		return;
+	}
+
+	for(i=0;i<matr.rows;i++)
+	{
+		for(j=0;j<matr.columns;j++)
+		{
+		    value = get_value(i, j, matr);
+			fprintf(file, "%5.6lf\t", value);
+
+			/*if((j+1)==matr.columns)
+			{
+				if((i+1)==matr.rows)
+					goto END;			// Not pretty, but we use it to not write a \n before EOF.
+				fprintf(file, "\n");
+			}
+			else
+				fprintf(file, "\t");*/
+		}
+		fprintf(file, "\n");
+	}
+
+//END:
+	if(file != stdout)		// Dont think we want to close stdout, do we?
+		fclose(file);
+}
+
+matrix_1d read_matrix_1d(char * file_name)
+{
+	matrix_1d matr;
+	FILE * file;
+	int i=0, j=0, c=0;		// Using an int for the characters so we can catch EOF.
+	int par=0;				// Number for checking if the parsing was successful.
+	double num;
+	char ch;
+	char str[100] = "";
+
+	file = fopen(file_name, "r");
+
+	if(file == NULL)
+	{
+		fprintf(stderr, "Error opening file.\n");
+		matr.rows = -1;					// This value is useful to determine later if the reading was successful.
+		return matr;
+	}
+
+	matr.columns = 0;
+
+	do
+	{
+		c = fgetc(file);
+
+		if(j == 0)		// Call the row allocation only if there is a new line.
+		{
+			if(i == 0)	// The first one have to be a calloc for it to be an array.
+				matr.values = (double *)calloc(1, sizeof(double));
+			else if((c==EOF)&&(strlen(str)==0))
+			{
+				i--;
+				break;
+			}
+		}
+
+		if((c==' ')||(c=='\t'))			// Parse the number when encountering a whitespace.
+		{
+			par = sscanf(str, "%lf", &num);
+
+			if((par != EOF)&&(par != -1))		// Store ONLY valid numbers.
+			{
+				++j;
+                matr.values = (double *)realloc(matr.values, (i*matr.columns + j)*sizeof(double));
+				set_value(i, j-1, matr, num);
+			}
+
+			str[0] = '\0';				// "Reset" the string after a parsing.
+		}
+		else if((c=='\n')||(c==EOF))	// Also parse on newline, or EOF.
+		{
+			par = sscanf(str, "%lf", &num);
+
+			if((par != EOF)&&(par != -1))		// Again, only valid numbers.
+			{
+				j++;
+                matr.values = (double *)realloc(matr.values, (i*matr.columns + j)*sizeof(double));
+
+				if(c!=EOF)		// Allocate for the next row ONLY if its not the EOF.
+				{
+					i++;
+					set_value(i-1, j-1, matr, num);
+                    matr.columns = j;		// Set the columns of the matrix. Possible error detection /w if(j!=matr.columns)
+					j = 0;
+				}
+				else
+                    set_value(i, j-1, matr, num);	// If EOF reached, just store the value.
+			}
+			else	// A new line could mean a new row.
+			{
+				if((j!=0)&&(c!=EOF))	// But only if there was at least one element in the last row.
+					i++;				// Also, if EOF is reached, there will be no more rows.
+				j=0;	// A new line ALWAYS starts with the first element.
+			}
+
+			str[0] = '\0';
+		}
+		else
+        {
+			ch = (char )c;
+			if(ch == ',')   // Little code to handle colons.
+                ch = '.';
+			strncat(str, &ch, 1);		// If no "special" characters were found, its probably a "part" of a number.
+        }
+	} while(c != EOF);
+
+	matr.rows = i+1;		// Set the rows.
+
+	fclose(file);
+
+	return matr;
+}
+
+matrix_1d create_identity(int dimensions)
+{
+    int i=0, j=0;
+
+    matrix_1d result;
+    result.columns = dimensions;
+    result.rows = dimensions;
+    result.values = (double *)calloc(dimensions*dimensions, sizeof(double));
+
+    if(-1==dimensions)
+    {
+        fprintf(stderr, "Cannot create identity, because file was not properly read!\n");
+
+        return result;
+    }
+
+    for(i=0;i<dimensions;i++)
+    {
+        for(j=0;j<dimensions;j++)
+        {
+            if(i==j)
+                set_value(i, j, result, 1);
+            else
+                set_value(i, j, result, 0);
+        }
+    }
+
+    return result;
+}
+
+matrix_1d mult_matrices(matrix_1d mat1, matrix_1d mat2)
+{
+	matrix_1d result;
+	int i, j, k;
+	double temp = 0;
+	double t1, t2;
+
+	if(mat1.columns != mat2.rows)   // Checks if the two matrices are compatible.
+	{
+		fprintf(stderr, "The two matrices are not compatible! They cannot be multiplied.\n");
+		result.columns = -1;    // Value for error handling.
+		return result;
+	}
+
+	result.rows = mat1.rows;
+	result.columns = mat2.columns;  // Need to initialize these values, because we use them.
+	result.values = (double *)calloc(mat1.rows*mat2.columns, sizeof(double));
+
+	//printf("Loop boundaries:\nOuter: %d\tMiddle: %d\tInner: %d\n", mat1.rows, mat2.columns, mat1.columns);    Debug code
+
+	for(i=0;i<mat1.rows;i++)
+	{
+		for(j=0;j<mat2.columns;j++)
+		{
+			for(k=0;k<mat1.columns;k++)
+			{
+				t1 = get_value(i, k, mat1);
+				t2 = get_value(k, j, mat2);
+
+				//printf("Multiplying %g (Row: %d Column: %d) with\n", t1, i, k);
+				//printf("with %g (Row: %d Column: %d)\n", t2, k, j);   Debug code
+                //getchar();
+
+				temp += t1*t2;
+            }
+
+            //printf("The value of element at row %d column %d: %g", i, j, temp);   Debug code
+            //getchar();
+
+            set_value(i, j, result, temp);
+            temp = 0;
+		}
+	}
+
+	//printf("Out of the loop!\n"); Debug code
+
+	return result;
+}
diff --git a/code/train/C/0128302_leveldb_benchmark.c b/code/train/C/0128302_leveldb_benchmark.c
new file mode 100644
index 0000000000000000000000000000000000000000..a9559a0ea5c7cc62feb90b5321379a1eb50e045f
--- /dev/null
+++ b/code/train/C/0128302_leveldb_benchmark.c
@@ -0,0 +1,200 @@
+#include "bmbase.c"
+#include <dirent.h>
+#include <leveldb/c.h>
+
+#define DEFAULT_DB "leveldb_bench.db"
+
+typedef struct BM_LEVELDB {
+  leveldb_t *db;
+  leveldb_options_t *options;
+} BM_LEVELDB;
+
+static void env_setup() {
+  fprintf(stderr, " engine: LevelDB %d.%d\n", leveldb_major_version(), leveldb_minor_version());
+}
+
+uint64_t db_size_bytes(BMCTX *ctx) {
+  char buf[PATH_MAX + 1];
+  DIR *d;
+  uint64_t sz = 0;
+  struct dirent *dir;
+  const char *path = bm.param_db ? bm.param_db : DEFAULT_DB;
+  d = opendir(path);
+  if (d) {
+    while ((dir = readdir(d))) {
+      snprintf(buf, sizeof(buf), "%s/%s", path, dir->d_name);
+      IWP_FILE_STAT fst;
+      iwrc rc = iwp_fstat(buf, &fst);
+      if (rc) {
+        iwlog_ecode_error3(rc);
+        return 0;
+      }
+      if (fst.ftype == IWP_TYPE_FILE) {
+        sz += fst.size;
+      }
+    }
+    closedir(d);
+  }
+  return sz;
+}
+
+static void *db_open(BMCTX *ctx) {
+  if (ctx->db) {
+    return 0; // db is not closed properly
+  }
+  char *err = 0;
+  const char *path = bm.param_db ? bm.param_db : DEFAULT_DB;
+  BM_LEVELDB *bmdb = malloc(sizeof(*bmdb));
+  bmdb->options = leveldb_options_create();
+  leveldb_options_set_create_if_missing(bmdb->options, 1);
+  if (ctx->freshdb) {
+    leveldb_destroy_db(bmdb->options, path, &err);
+    if (err) {
+      leveldb_free(err);
+      err = 0;
+    }
+    iwp_removedir(path);
+  }
+  bmdb->db = leveldb_open(bmdb->options, path, &err);
+  if (err) {
+    leveldb_options_destroy(bmdb->options);
+    fprintf(stderr, "ERROR db_open: %s\n", err);
+    leveldb_free(err);
+    free(bmdb);
+    return 0;
+  }
+  return bmdb;
+}
+
+static bool db_close(BMCTX *ctx) {
+  if (!ctx->db) {
+    return false;
+  }
+  BM_LEVELDB *bmdb = ctx->db;
+  leveldb_close(bmdb->db);
+  leveldb_options_destroy(bmdb->options);
+  free(bmdb);
+  return true;
+}
+
+static bool db_put(BMCTX *ctx, const IWKV_val *key, const IWKV_val *val, bool sync) {
+  BM_LEVELDB *bmdb = ctx->db;
+  char *err = 0;
+  bool ret = true;
+  leveldb_writeoptions_t *wopt = leveldb_writeoptions_create();
+  if (sync) {
+    leveldb_writeoptions_set_sync(wopt, 1);
+  }
+  leveldb_put(bmdb->db, wopt, key->data, key->size, val->data, val->size, &err);
+  if (err) {
+    fprintf(stderr, "ERROR db_put: %s\n", err);
+    leveldb_free(err);
+    ret = false;
+  }
+  leveldb_writeoptions_destroy(wopt);
+  return ret;
+}
+
+static bool db_get(BMCTX *ctx, const IWKV_val *key, IWKV_val *val, bool *found) {
+  BM_LEVELDB *bmdb = ctx->db;
+  size_t sz;
+  char *data = 0;
+  char *err = 0;
+  bool ret = true;
+  leveldb_readoptions_t *ropt = leveldb_readoptions_create();
+  data = leveldb_get(bmdb->db, ropt, key->data, key->size, &sz, &err);
+  *found = (data != 0);
+  if (err) {
+    fprintf(stderr, "ERROR db_get: %s\n", err);
+    leveldb_free(err);
+    ret = false;
+  } else {
+    val->data = data;
+    val->size = sz;
+  }
+  leveldb_readoptions_destroy(ropt);
+  return ret;
+}
+
+static bool db_del(BMCTX *ctx, const IWKV_val *key, bool sync) {
+  BM_LEVELDB *bmdb = ctx->db;
+  char *err = 0;
+  bool ret = true;
+  leveldb_writeoptions_t *wopt = leveldb_writeoptions_create();
+  if (sync) {
+    leveldb_writeoptions_set_sync(wopt, 1);
+  }
+  leveldb_delete(bmdb->db, wopt, key->data, key->size, &err);
+  if (err) {
+    fprintf(stderr, "ERROR db_del: %s\n", err);
+    leveldb_free(err);
+    ret = false;
+  }
+  leveldb_writeoptions_destroy(wopt);
+  return ret;
+}
+
+static bool db_read_seq(BMCTX *ctx, bool reverse) {
+  BM_LEVELDB *bmdb = ctx->db;
+  bool ret = true;
+  leveldb_readoptions_t *ropt = leveldb_readoptions_create();
+  leveldb_iterator_t *it = leveldb_create_iterator(bmdb->db, ropt);
+  if (reverse) {
+    leveldb_iter_seek_to_last(it);
+  } else {
+    leveldb_iter_seek_to_first(it);
+  }
+  for (int i = 0; i < bm.param_num && leveldb_iter_valid(it); ++i) {
+    size_t vlen, klen;
+    leveldb_iter_value(it, &vlen);
+    leveldb_iter_key(it, &klen);
+    if (reverse) {
+      leveldb_iter_prev(it);
+    } else {
+      leveldb_iter_next(it);
+    }
+  }
+  leveldb_iter_destroy(it);
+  leveldb_readoptions_destroy(ropt);
+  return ret;
+}
+
+static bool db_cursor_to_key(BMCTX *ctx, const IWKV_val *key, IWKV_val *val, bool *found) {
+  BM_LEVELDB *bmdb = ctx->db;
+  bool ret = true;
+  leveldb_readoptions_t *ropt = leveldb_readoptions_create();
+  leveldb_iterator_t *it = leveldb_create_iterator(bmdb->db, ropt);
+  leveldb_iter_seek(it, key->data, key->size);
+  *found = leveldb_iter_valid(it);
+  val->data = 0;
+  val->size = 0;
+  if (*found) {
+    size_t vlen;
+    const char *v = leveldb_iter_value(it, &vlen);
+    val->data = malloc(vlen);
+    memcpy(val->data, v, vlen);
+  }
+  leveldb_iter_destroy(it);
+  leveldb_readoptions_destroy(ropt);
+  return ret;
+}
+
+int main(int argc, char **argv) {
+  if (argc < 1) {
+    return -1;
+  }
+  g_program = argv[0];
+  bm.env_setup = env_setup;
+  bm.db_size_bytes = db_size_bytes;
+  bm.db_open = db_open;
+  bm.db_close = db_close;
+  bm.db_put = db_put;
+  bm.db_get = db_get;
+  bm.db_del = db_del;
+  bm.db_read_seq = db_read_seq;
+  bm.db_cursor_to_key = db_cursor_to_key;
+  if (!bm_bench_run(argc, argv)) {
+    return 1;
+  }
+  return 0;
+}
diff --git a/code/train/C/0128795_opendcp_cli.c b/code/train/C/0128795_opendcp_cli.c
new file mode 100644
index 0000000000000000000000000000000000000000..cea5fb8fef3606021353c2c1ee71118f4e2c46e9
--- /dev/null
+++ b/code/train/C/0128795_opendcp_cli.c
@@ -0,0 +1,272 @@
+/*
+    OpenDCP: Builds Digital Cinema Packages
+    Copyright (c) 2010-2011 Terrence Meiczinger, All Rights Reserved
+
+    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 <string.h>
+#ifdef WIN32
+#include "win32/opendcp_win32_dirent.h"
+#else
+#include <dirent.h>
+#endif
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <sys/stat.h>
+
+#include "opendcp.h"
+#include "opendcp_cli.h"
+
+extern int build_filelist(char *input, char *output, filelist_t *filelist, int file_type);
+extern int get_file_count(char *path, int file_type);
+
+int check_extension(char *filename, char *pattern) {
+    char *extension;
+
+    extension = strrchr(filename,'.');
+
+    if ( extension == NULL ) {
+        return 0;
+    }
+
+    extension++;
+
+   if (strncasecmp(extension,pattern,3) !=0) {
+       return 0;
+   }
+
+   return 1;
+}
+
+char *get_basename(const char *filename) {
+    char *extension;
+    char *base = 0;
+
+    base = (char *)filename;
+    extension = strrchr(filename,'.');
+    base[(strlen(filename) - strlen(extension))] = '\0';
+
+    return(base);
+}
+
+static int filter;
+int file_filter(struct dirent *filename) {
+    char *extension;
+
+    extension = strrchr(filename->d_name,'.');
+
+    if ( extension == NULL ) {
+        return 0;
+    }
+
+    extension++;
+
+    /* return only known asset types */
+    if (filter == MXF_INPUT) {
+        if (strncasecmp(extension,"j2c",3) != 0 &&
+            strncasecmp(extension,"j2k",3) != 0 &&
+            strncasecmp(extension,"wav",3) != 0)
+        return 0;
+    } else if (filter == J2K_INPUT) {
+        if (strncasecmp(extension,"tif",3) != 0 &&
+            strncasecmp(extension,"dpx",3) != 0)
+        return 0;
+    }
+
+    return 1;
+}
+
+int get_file_count(char *path, int file_type) {
+    struct dirent **files;
+    struct stat st_in;
+
+    int x,count;
+
+    filter = file_type;
+
+    if (stat(path, &st_in) != 0 ) {
+        dcp_log(LOG_ERROR,"Could not open input file %s",path);
+        return DCP_FATAL;
+    }
+
+    if (S_ISDIR(st_in.st_mode)) {
+        count = scandir(path,&files,(void *)file_filter,alphasort);
+        for (x=0;x<count;x++) {
+            free(files[x]);
+        }
+        free(files);
+
+    } else {
+        count = 1;
+    }
+
+    return count;
+}
+
+int build_filelist(char *input, char *output, filelist_t *filelist, int file_type) {
+    struct dirent **files;
+    int x = 0;
+    struct stat st_in;
+
+    if (stat(input, &st_in) != 0 ) {
+        dcp_log(LOG_ERROR,"Could not open input file %s",input);
+        return DCP_FATAL;
+    }
+
+    filelist->file_count = scandir(input,&files,(void *)file_filter,alphasort);
+    if (filelist->file_count) {
+        for (x=0;x<filelist->file_count;x++) {
+            sprintf(filelist->in[x],"%s/%s",input,files[x]->d_name);
+            if (file_type == J2K_INPUT) {
+                sprintf(filelist->out[x],"%s/%s.j2c",output,get_basename(files[x]->d_name));
+            }
+        }
+     }
+    for (x=0;x<filelist->file_count;x++) {
+        free(files[x]);
+    }
+    free(files);
+
+    return DCP_SUCCESS;
+}
+
+filelist_t *filelist_alloc(int count) {
+    int x;
+    filelist_t *filelist;
+
+    filelist = malloc(sizeof(filelist_t));
+
+    filelist->file_count = count;
+    filelist->in  = malloc(filelist->file_count*sizeof(char*));
+    filelist->out = malloc(filelist->file_count*sizeof(char*));
+
+    if (filelist->file_count) {
+        for (x=0;x<filelist->file_count;x++) {
+                filelist->in[x]  = malloc(MAX_FILENAME_LENGTH*sizeof(char *));
+                filelist->out[x] = malloc(MAX_FILENAME_LENGTH*sizeof(char *));
+        }
+    }
+
+    return filelist;
+}
+
+void filelist_free(filelist_t *filelist) {
+    int x;
+
+    for (x=0;x<filelist->file_count;x++) {
+        if (filelist->in[x]) {
+            free(filelist->in[x]);
+        }
+        if (filelist->out[x]) {
+            free(filelist->out[x]);
+        }
+    }
+
+    if (filelist->in) {
+        free(filelist->in);
+    }
+
+    if (filelist->out) {
+        free(filelist->out);
+    }
+
+    if (filelist) {
+        free(filelist);
+    }
+
+    return;
+}
+
+int find_seq_offset(char str1[], char str2[]) {
+    unsigned int i;
+    unsigned int offset = 0;
+
+    for (i = 0; (i < strlen(str1)) && (offset == 0); i++) {
+        if(str1[i] != str2[i])
+            offset = i;
+    }
+
+    return offset;
+}
+
+int find_ext_offset(char str[]) {
+    int i = strlen(str);
+    while(i) {
+        if(str[i] == '.')
+            return i;
+        i--;
+    }
+
+    return 0;
+}
+
+int check_increment(char *str[], int index,int str_size) {
+    long x;
+    int seq_offset;
+
+    seq_offset = find_seq_offset(str[0], str[str_size-1]);
+
+    x = strtol(str[index]+seq_offset,NULL,10);
+
+    if (x == index) {
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
+/* check if two strings are sequential */
+int check_sequential(char str1[],char str2[]) {
+    unsigned i;
+    long     x,y;
+    unsigned int  offset = 0;
+
+    if (strlen(str1) != strlen(str2)) {
+        return STRING_LENGTH_NOTEQUAL;
+    }
+
+    for (i = 0; i < strlen(str1); i++) {
+        if(str1[i] != str2[i]) {
+            offset = i;
+            break;
+        }
+    }
+
+    x = strtol(str1+offset,NULL,10);
+    y = strtol(str2+offset,NULL,10);
+
+    if ((y - x) == 1) {
+        return DCP_SUCCESS;
+    } else {
+        return STRING_NOTSEQUENTIAL;
+    }
+}
+
+int check_file_sequence(char *str[], int count) {
+    int sequential = 0;
+    int x = 0;
+
+    while (x<(count-1) && sequential == DCP_SUCCESS) {
+        sequential = check_sequential(str[x], str[x+1]);
+        x++;
+    }
+
+    if (sequential == DCP_SUCCESS) {
+        return 0;
+    } else {
+        return x+DCP_ERROR_MAX;
+    }
+}
diff --git a/code/train/C/0128930_vec.c b/code/train/C/0128930_vec.c
new file mode 100644
index 0000000000000000000000000000000000000000..9e9498be026a78932ff4b6963f46696eaa35b2d5
--- /dev/null
+++ b/code/train/C/0128930_vec.c
@@ -0,0 +1,191 @@
+#include <float.h>
+#include <stdio.h>
+
+#include "math/vec.h"
+
+ct_export CT_Vec2f *ct_vec2f(float x, float y, CT_MPool *mpool) {
+  CT_Vec2f *v = CT_MP_ALLOC(mpool, CT_Vec2f);
+  if (v != NULL) {
+    v->x = x;
+    v->y = y;
+  }
+  return v;
+}
+
+ct_export CT_Vec2f *ct_vec2fn(float n, CT_MPool *mpool) {
+  return ct_vec2f(n, n, mpool);
+}
+
+ct_export CT_Vec3f *ct_vec3f(float x, float y, float z, CT_MPool *mpool) {
+  CT_Vec3f *v = CT_MP_ALLOC(mpool, CT_Vec3f);
+  if (v != NULL) {
+#ifdef CT_FEATURE_SSE
+    v->mmval = _mm_set_ps(0, z, y, x);
+#else
+    v->x = x;
+    v->y = y;
+    v->z = z;
+#endif
+  }
+  return v;
+}
+
+ct_export CT_Vec3f *ct_vec3fn(float n, CT_MPool *mpool) {
+  CT_Vec3f *v = CT_MP_ALLOC(mpool, CT_Vec3f);
+  if (v != NULL) {
+#ifdef CT_FEATURE_SSE
+    v->mmval = _mm_set1_ps(n);
+#else
+    v->x = v->y = v->z = n;
+#endif
+  }
+  return v;
+}
+
+ct_export CT_Vec4f *ct_vec4f(float x,
+                             float y,
+                             float z,
+                             float w,
+                             CT_MPool *mpool) {
+  CT_Vec4f *v = CT_MP_ALLOC(mpool, CT_Vec4f);
+  if (v != NULL) {
+#ifdef CT_FEATURE_SSE
+    v->mmval = _mm_set_ps(w, z, y, x);
+#else
+    v->x               = x;
+    v->y               = y;
+    v->z               = z;
+    v->w               = w;
+#endif
+  }
+  return v;
+}
+
+ct_export CT_Vec4f *ct_vec4fn(float n, CT_MPool *mpool) {
+  CT_Vec4f *v = CT_MP_ALLOC(mpool, CT_Vec4f);
+  if (v != NULL) {
+#ifdef CT_FEATURE_SSE
+    v->mmval = _mm_set1_ps(n);
+#else
+    v->x = v->y = v->z = v->w = n;
+#endif
+  }
+  return v;
+}
+
+// ---------- array ops
+
+VEC_ARRAYOP(translate2f, CT_Vec2f, float, ct_add2fv_imm)
+VEC_ARRAYOP(scale2f, CT_Vec2f, float, ct_mul2fv_imm)
+VEC_ARRAYOP(translate3f, CT_Vec3f, float, ct_add3fv_imm)
+VEC_ARRAYOP(scale3f, CT_Vec3f, float, ct_mul3fv_imm)
+VEC_ARRAYOP(translate4f, CT_Vec4f, float, ct_add4fv_imm)
+VEC_ARRAYOP(scale4f, CT_Vec4f, float, ct_mul4fv_imm)
+
+ct_export CT_Vec2f *ct_centroid2f(float *ptr,
+                                  size_t num,
+                                  size_t fstride,
+                                  CT_Vec2f *out) {
+  float x  = 0;
+  float y  = 0;
+  size_t n = num;
+  while (n--) {
+    x += ptr[0];
+    y += ptr[1];
+    ptr += fstride;
+  }
+  ct_set2fxy(out, x / num, y / num);
+  return out;
+}
+
+ct_export CT_Vec3f *ct_centroid3f(float *ptr,
+                                  size_t num,
+                                  size_t fstride,
+                                  CT_Vec3f *out) {
+  float x  = 0;
+  float y  = 0;
+  float z  = 0;
+  size_t n = num;
+  while (n--) {
+    x += ptr[0];
+    y += ptr[1];
+    z += ptr[2];
+    ptr += fstride;
+  }
+  ct_set3fxyz(out, x / num, y / num, z / num);
+  return out;
+}
+
+ct_export CT_Vec2f *ct_closest_point2f(float *ptr,
+                                       CT_Vec2f *p,
+                                       size_t num,
+                                       size_t fstride) {
+  float minD        = FLT_MAX;
+  CT_Vec2f *closest = NULL;
+  if (num > 0) {
+    while (num--) {
+      float d = ct_distsq2fv((CT_Vec2f *)ptr, p);
+      if (d < minD) {
+        closest = (CT_Vec2f *)ptr;
+        minD    = d;
+      }
+      ptr += fstride;
+    }
+  }
+  return closest;
+}
+
+ct_export CT_Vec3f *ct_closest_point3f(float *ptr,
+                                       CT_Vec3f *p,
+                                       size_t num,
+                                       size_t fstride) {
+  float minD        = FLT_MAX;
+  CT_Vec3f *closest = NULL;
+  if (num > 0) {
+    while (num--) {
+      const float d = ct_distsq3fv((CT_Vec3f *)ptr, p);
+      if (d < minD) {
+        closest = (CT_Vec3f *)ptr;
+        minD    = d;
+      }
+      ptr += fstride;
+    }
+  }
+  return closest;
+}
+
+ct_export int ct_bounds2fp(float *ptr,
+                           size_t num,
+                           size_t fstride,
+                           CT_Vec2f *min,
+                           CT_Vec2f *max) {
+  if (num > 0) {
+    ct_set2fn(min, FLT_MAX);
+    ct_set2fn(max, -FLT_MAX);
+    while (num--) {
+      ct_min2fv_imm(min, (CT_Vec2f *)ptr);
+      ct_max2fv_imm(max, (CT_Vec2f *)ptr);
+      ptr += fstride;
+    }
+    return 0;
+  }
+  return 1;
+}
+
+ct_export int ct_bounds3fp(float *ptr,
+                           size_t num,
+                           size_t fstride,
+                           CT_Vec3f *min,
+                           CT_Vec3f *max) {
+  if (num > 0) {
+    ct_set3fn(min, FLT_MAX);
+    ct_set3fn(max, -FLT_MAX);
+    while (num--) {
+      ct_min3fv_imm(min, (CT_Vec3f *)ptr);
+      ct_max3fv_imm(max, (CT_Vec3f *)ptr);
+      ptr += fstride;
+    }
+    return 0;
+  }
+  return 1;
+}
diff --git a/code/train/C/0128941_libBinarization.c b/code/train/C/0128941_libBinarization.c
new file mode 100644
index 0000000000000000000000000000000000000000..d24ce33c36e9b48f4e473fce25f3c8bddd574121
--- /dev/null
+++ b/code/train/C/0128941_libBinarization.c
@@ -0,0 +1,59 @@
+/**
+ * Masters Thesis Work: OCR
+ * Christopher Stoll, 2014
+ */
+
+#ifndef LIBBINARIZATION_C
+#define LIBBINARIZATION_C
+
+static int otsuBinarization(int *histogram, int pixelCount, int pixelDepth)
+{
+	unsigned long long sum = 0;
+	unsigned long long oldsum = 0;
+	for(int i = 1; i < pixelDepth; ++i) {
+		oldsum = sum;
+		sum += i * histogram[i];
+		if(oldsum > sum) {
+			printf("ERROR: Integer Overflow (%llu + n => %llu)\n", oldsum, sum);
+		}
+	}
+
+	unsigned long long sumB = 0;
+	unsigned long long wB = 0;
+	unsigned long long wF = 0;
+	unsigned long long mB;
+	unsigned long long mF;
+	long double max = 0.0;
+	long double between = 0.0;
+	long double threshold1 = 0.0;
+	long double threshold2 = 0.0;
+
+	for(int i = 0; i < pixelDepth; ++i) {
+		wB += histogram[i];
+
+		if(wB) {
+			wF = pixelCount - wB;
+
+			if(wF == 0) {
+				break;
+			}
+
+			sumB += i * histogram[i];
+
+			mB = sumB / wB;
+			mF = (sum - sumB) / wF;
+			between = wB * wF * ((mB - mF) * (mB - mF));
+
+			if(between >= max) {
+				threshold1 = i;
+				if(between > max) {
+					threshold2 = i;
+				}
+				max = between;
+			}
+		}
+	}
+	return (int)((threshold1 + threshold2) / 2.0);
+}
+
+#endif
diff --git a/code/train/C/0129309_main.c b/code/train/C/0129309_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..b0439de85f580c479c1980a7d743ce2062490a62
--- /dev/null
+++ b/code/train/C/0129309_main.c
@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) 2016, Stefan Lankes, RWTH Aachen University
+ * All rights reserved.
+ *
+ * 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 University 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 REGENTS 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.
+ */
+
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+#include <multiboot.h>
+#include <elf.h>
+#include <page.h>
+
+#define HALT	asm volatile ("hlt")
+
+/*
+ * Note that linker symbols are not variables, they have no memory allocated for
+ * maintaining a value, rather their address is their value.
+ */
+extern const void kernel_start;
+extern const void kernel_end;
+extern const void bss_start;
+extern const void bss_end;
+extern size_t uartport;
+
+static int load_code(size_t viraddr, size_t phyaddr, size_t limit, uint32_t file_size, size_t mem_size, size_t cmdline, size_t cmdsize)
+{
+	const size_t displacement = 0x200000ULL - (phyaddr & 0x1FFFFFULL);
+
+	kprintf("Found program segment at 0x%zx-0x%zx (viraddr 0x%zx-0x%zx)\n", phyaddr, phyaddr+file_size-1, viraddr, viraddr+file_size-1);
+
+	uint32_t npages = (file_size >> PAGE_BITS);
+	if (file_size & (PAGE_SIZE-1))
+		npages++;
+
+	kprintf("Map %u pages from physical start address 0x%zx linear to 0x%zx\n", npages + (displacement >> PAGE_BITS), phyaddr, viraddr);
+	int ret = page_map(viraddr, phyaddr, npages + (displacement >> PAGE_BITS), PG_GLOBAL|PG_RW);
+	if (ret)
+		return -1;
+
+	phyaddr += displacement;
+	*((uint64_t*) (viraddr + 0x08)) = phyaddr; // physical start address
+	*((uint64_t*) (viraddr + 0x10)) = limit;   // physical limit
+	*((uint32_t*) (viraddr + 0x24)) = 1; // number of used cpus
+	*((uint32_t*) (viraddr + 0x30)) = 0; // apicid
+	*((uint64_t*) (viraddr + 0x38)) = mem_size;
+	*((uint32_t*) (viraddr + 0x60)) = 1; // numa nodes
+	*((uint64_t*) (viraddr + 0x98)) = uartport;
+	*((uint64_t*) (viraddr + 0xA0)) = cmdline;
+	*((uint64_t*) (viraddr + 0xA8)) = cmdsize;
+
+	// move file to a 2 MB boundary
+	for(size_t va = viraddr+(npages << PAGE_BITS)+displacement-sizeof(uint8_t); va >= viraddr+displacement; va-=sizeof(uint8_t))
+		*((uint8_t*) va) = *((uint8_t*) (va-displacement));
+
+	kprintf("Remap %u pages from physical start address 0x%zx linear to 0x%zx\n", npages, phyaddr, viraddr);
+	ret = page_map(viraddr, phyaddr, npages, PG_GLOBAL|PG_RW);
+	if (ret)
+		return -1;
+
+	return 0;
+}
+
+void main(void)
+{
+	size_t limit = 0;
+	size_t viraddr = 0;
+	size_t phyaddr = 0;
+	elf_header_t* header = NULL;
+	uint32_t file_size = 0;
+	size_t mem_size = 0;
+	size_t cmdline_size = 0;
+	size_t cmdline = 0;
+
+	// initialize .bss section
+	memset((void*)&bss_start, 0x00, ((size_t) &bss_end - (size_t) &bss_start));
+
+	koutput_init();
+	kputs("HermitCore loader...\n");
+	kprintf("Loader starts at %p and ends at %p\n", &kernel_start, &kernel_end);
+	kprintf("Found mb_info at %p\n", mb_info);
+
+	if (mb_info && mb_info->cmdline) {
+		cmdline = (size_t) mb_info->cmdline;
+		cmdline_size = strlen((char*)cmdline);
+	}
+
+	// enable paging
+	page_init();
+
+	if (mb_info) {
+		if (mb_info->flags & MULTIBOOT_INFO_MEM_MAP) {
+			size_t end_addr, start_addr;
+			multiboot_memory_map_t* mmap = (multiboot_memory_map_t*) ((size_t) mb_info->mmap_addr);
+			multiboot_memory_map_t* mmap_end = (void*) ((size_t) mb_info->mmap_addr + mb_info->mmap_length);
+
+			// mark available memory as free
+			while (mmap < mmap_end) {
+				if (mmap->type == MULTIBOOT_MEMORY_AVAILABLE) {
+					/* set the available memory as "unused" */
+					start_addr = mmap->addr;
+					end_addr = start_addr + mmap->len;
+
+					if (limit < end_addr)
+						limit = end_addr;
+
+					kprintf("Free region 0x%zx - 0x%zx\n", start_addr, end_addr);
+				}
+				mmap = (multiboot_memory_map_t*) ((size_t) mmap + sizeof(uint32_t) + mmap->size);
+			}
+		} else {
+			goto failed;
+		}
+
+		if (mb_info->flags & MULTIBOOT_INFO_MODS) {
+			if (!mb_info->mods_count) {
+				kputs("Ups, we need at least one module!\n");
+				goto failed;
+			}
+
+			// per default the first module is our HermitCore binary
+			multiboot_module_t* mmodule = (multiboot_module_t*) ((size_t) mb_info->mods_addr);
+			header = (elf_header_t*) ((size_t) mmodule[0].mod_start);
+			kprintf("ELF file is located at %p\n", header);
+		}
+	} else {
+		goto failed;
+	}
+
+	if (BUILTIN_EXPECT(!header, 0))
+		goto failed;
+
+	if (BUILTIN_EXPECT(header->ident.magic != ELF_MAGIC, 0))
+		goto invalid;
+
+	if (BUILTIN_EXPECT(header->type != ELF_ET_EXEC, 0))
+		goto invalid;
+
+	if (BUILTIN_EXPECT(header->machine != ELF_EM_X86_64, 0))
+		goto invalid;
+
+	if (BUILTIN_EXPECT(header->ident._class != ELF_CLASS_64, 0))
+		goto invalid;
+
+	if (BUILTIN_EXPECT(header->ident.data != ELF_DATA_2LSB, 0))
+		goto invalid;
+
+	if (header->ident.pad[0] != 0x42) {
+		kprintf("ELF file doesn't contain a HermitCore application (OS/ABI 0x%x)\n", (uint32_t)header->ident.pad[0]);
+		goto invalid;
+	}
+
+	for (int i=0; i<header->ph_entry_count; i++) {
+		elf_program_header_t* prog_header;
+
+		prog_header = (elf_program_header_t*) (header->ph_offset+i*header->ph_entry_size+(size_t)header);
+
+		switch(prog_header->type)
+		{
+		case  ELF_PT_LOAD: {	// load program segment
+				if (!viraddr)
+					viraddr = prog_header->virt_addr;
+				if (!phyaddr)
+					phyaddr = prog_header->offset + (size_t)header;
+				file_size = prog_header->virt_addr + PAGE_CEIL(prog_header->file_size) - viraddr;
+				mem_size += prog_header->mem_size;
+			}
+			break;
+		case ELF_PT_GNU_STACK:	// Indicates stack executability => nothing to do
+			break;
+		case ELF_PT_TLS: // Definition of the thread local storage => nothing to do
+			break;
+		default:
+			kprintf("Unknown type %d\n", prog_header->type);
+		}
+	}
+
+	if (BUILTIN_EXPECT(load_code(viraddr, phyaddr, limit, file_size, mem_size, cmdline, cmdline_size), 0))
+		goto failed;
+
+	kprintf("Entry point: 0x%zx\n", header->entry);
+	// jump to the HermitCore app
+	asm volatile ("jmp *%0" :: "r"(header->entry), "d"(mb_info) : "memory");
+
+	// we should never reach this point
+	while(1) { HALT; }
+
+failed:
+	kputs("Upps, kernel panic!\n");
+	while(1) { HALT; }
+
+invalid:
+	kprintf("Invalid executable!\n");
+	kprintf("magic number 0x%x\n", (uint32_t) header->ident.magic);
+	kprintf("header type 0x%x\n", (uint32_t) header->type);
+	kprintf("machine type 0x%x\n", (uint32_t) header->machine);
+	kprintf("elf ident class 0x%x\n", (uint32_t) header->ident._class);
+	kprintf("elf identdata 0x%x\n", header->ident.data);
+	kprintf("program entry point 0x%lx\n", (size_t) header->entry);
+	while(1) { HALT; }
+}
diff --git a/code/train/C/0129471_packet-cisco-wids.c b/code/train/C/0129471_packet-cisco-wids.c
new file mode 100644
index 0000000000000000000000000000000000000000..0327cddd3f34f0ce2a3188ff266574b82a9b7b03
--- /dev/null
+++ b/code/train/C/0129471_packet-cisco-wids.c
@@ -0,0 +1,217 @@
+/* packet-cwids.c
+ * Routines for dissecting wireless ids packets sent from a Cisco
+ * access point to the WLSE (or whatever)
+ *
+ * $Id$
+ *
+ * Copyright 2006 Joerg Mayer (see AUTHORS file)
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * 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.
+ */
+
+/* With current IOS, you can use Cisco wireless Bridges/APs as
+ * wireless sniffers and configure them to send the data to some
+ * central IDS:
+ * interface dot11Radio 0
+ *   station-role scanner
+ *   monitor frames endpoint ip address 172.22.1.1 port 8999 truncate 2312
+ * These frames are raw, i.e. they don't have a pcap header.
+ * Running wireshark at the receiving end will provide those.
+ */
+
+/* 2do:
+ *	- Find out more about the contents of the capture header
+ *	- Protect the address fields etc (all columns?)
+ *	- Create subelements and put each header and packet into it
+ *	- fuzz-test the dissector
+ *	- Find some heuristic to detect the packet automagically and
+ *	  convert dissector into a heuristic dissector
+ *	- Is the TRY/CATCH stuff OK?
+ */
+
+#include "config.h"
+
+#include <glib.h>
+#include <epan/packet.h>
+#include <epan/etypes.h>
+#include <epan/expert.h>
+#include <epan/prefs.h>
+
+static guint global_udp_port = 0;
+
+static int proto_cwids = -1;
+static int hf_cwids_version = -1;
+static int hf_cwids_unknown1 = -1;
+static int hf_cwids_channel = -1;
+static int hf_cwids_unknown2 = -1;
+static int hf_cwids_reallength = -1;
+static int hf_cwids_capturelen = -1;
+static int hf_cwids_unknown3 = -1;
+
+static gint ett_cwids = -1;
+
+static dissector_handle_t ieee80211_handle;
+
+static void
+dissect_cwids(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
+{
+	tvbuff_t *wlan_tvb;
+	proto_tree *ti, *cwids_tree;
+	volatile int offset = 0;
+	guint16 capturelen;
+	void *pd_save;
+
+	col_set_str(pinfo->cinfo, COL_PROTOCOL, "CWIDS");
+	col_set_str(pinfo->cinfo, COL_INFO, "Cwids: ");
+	/* FIXME: col_set_fence(pinfo->cinfo, all-cols, only addr-cols?); */
+
+	cwids_tree = NULL;
+
+	while(tvb_length_remaining(tvb, offset) > 0) {
+		ti = proto_tree_add_item(tree, proto_cwids, tvb, offset, 28, ENC_NA);
+		cwids_tree = proto_item_add_subtree(ti, ett_cwids);
+
+		proto_tree_add_item(cwids_tree, hf_cwids_version, tvb, offset, 2, ENC_BIG_ENDIAN);
+		offset += 2;
+		proto_tree_add_item(cwids_tree, hf_cwids_unknown1, tvb, offset, 7, ENC_NA);
+		offset += 7;
+		proto_tree_add_item(cwids_tree, hf_cwids_channel, tvb, offset, 1, ENC_BIG_ENDIAN);
+		offset += 1;
+		proto_tree_add_item(cwids_tree, hf_cwids_unknown2, tvb, offset, 6, ENC_NA);
+		offset += 6;
+		proto_tree_add_item(cwids_tree, hf_cwids_reallength, tvb, offset, 2, ENC_BIG_ENDIAN);
+		offset += 2;
+		capturelen = tvb_get_ntohs(tvb, offset);
+		proto_tree_add_item(cwids_tree, hf_cwids_capturelen, tvb, offset, 2, ENC_BIG_ENDIAN);
+		offset += 2;
+		proto_tree_add_item(cwids_tree, hf_cwids_unknown3, tvb, offset, 8, ENC_NA);
+		offset += 8;
+
+		wlan_tvb = tvb_new_subset(tvb, offset, capturelen, capturelen);
+		/* Continue after ieee80211 dissection errors */
+		pd_save = pinfo->private_data;
+		TRY {
+			call_dissector(ieee80211_handle, wlan_tvb, pinfo, tree);
+		} CATCH2(BoundsError, ReportedBoundsError) {
+
+			expert_add_info_format(pinfo, NULL,
+				PI_MALFORMED, PI_ERROR,
+				"Malformed or short IEEE80211 subpacket");
+
+			/*  Restore the private_data structure in case one of the
+			 *  called dissectors modified it (and, due to the exception,
+			 *  was unable to restore it).
+			 */
+			pinfo->private_data = pd_save;
+
+			col_append_str(pinfo->cinfo, COL_INFO,
+				" [Malformed or short IEEE80211 subpacket] " );
+			col_set_fence(pinfo->cinfo, COL_INFO);
+#if 0
+	wlan_tvb = tvb_new_subset(tvb, offset, capturelen, capturelen);
+			/* FIXME: Why does this throw an exception? */
+			proto_tree_add_text(cwids_tree, wlan_tvb, offset, capturelen,
+				"[Malformed or short IEEE80211 subpacket]");
+#else
+			tvb_new_subset(tvb, offset, capturelen, capturelen);
+#endif
+	;
+		} ENDTRY;
+
+		offset += capturelen;
+	}
+}
+
+void proto_register_cwids(void);
+void proto_reg_handoff_cwids(void);
+
+void
+proto_register_cwids(void)
+{
+	static hf_register_info hf[] = {
+		{ &hf_cwids_version,
+		{ "Capture Version", "cwids.version", FT_UINT16, BASE_DEC, NULL,
+			0x0, "Version or format of record", HFILL }},
+
+		{ &hf_cwids_unknown1,
+		{ "Unknown1", "cwids.unknown1", FT_BYTES, BASE_NONE, NULL,
+			0x0, "1st Unknown block - timestamp?", HFILL }},
+
+		{ &hf_cwids_channel,
+		{ "Channel", "cwids.channel", FT_UINT8, BASE_DEC, NULL,
+			0x0, "Channel for this capture", HFILL }},
+
+		{ &hf_cwids_unknown2,
+		{ "Unknown2", "cwids.unknown2", FT_BYTES, BASE_NONE, NULL,
+			0x0, "2nd Unknown block", HFILL }},
+
+		{ &hf_cwids_reallength,
+		{ "Original length", "cwids.reallen", FT_UINT16, BASE_DEC, NULL,
+			0x0, "Original num bytes in frame", HFILL }},
+
+		{ &hf_cwids_capturelen,
+		{ "Capture length", "cwids.caplen", FT_UINT16, BASE_DEC, NULL,
+			0x0, "Captured bytes in record", HFILL }},
+
+		{ &hf_cwids_unknown3,
+		{ "Unknown3", "cwids.unknown3", FT_BYTES, BASE_NONE, NULL,
+			0x0, "3rd Unknown block", HFILL }},
+
+	};
+	static gint *ett[] = {
+		&ett_cwids,
+	};
+
+	module_t *cwids_module;
+
+	proto_cwids = proto_register_protocol("Cisco Wireless IDS Captures", "CWIDS", "cwids");
+	proto_register_field_array(proto_cwids, hf, array_length(hf));
+	proto_register_subtree_array(ett, array_length(ett));
+
+	cwids_module = prefs_register_protocol(proto_cwids, proto_reg_handoff_cwids);
+	prefs_register_uint_preference(cwids_module, "udp.port",
+		"CWIDS port",
+		"Set the destination UDP port Cisco wireless IDS messages",
+		10, &global_udp_port);
+
+}
+
+void
+proto_reg_handoff_cwids(void)
+{
+	static dissector_handle_t cwids_handle;
+	static guint saved_udp_port;
+	static gboolean initialized = FALSE;
+
+	if (!initialized) {
+		cwids_handle = create_dissector_handle(dissect_cwids, proto_cwids);
+		dissector_add_handle("udp.port", cwids_handle);
+		ieee80211_handle = find_dissector("wlan");
+		initialized = TRUE;
+	} else {
+		if (saved_udp_port != 0) {
+			dissector_delete_uint("udp.port", saved_udp_port, cwids_handle);
+		}
+	}
+	if (global_udp_port != 0) {
+		dissector_add_uint("udp.port", global_udp_port, cwids_handle);
+	}
+	saved_udp_port = global_udp_port;
+}
+
diff --git a/code/train/C/0129776_Filter.c b/code/train/C/0129776_Filter.c
new file mode 100644
index 0000000000000000000000000000000000000000..73c0d6e9018b459c63cebbe27279bd28f335a5e5
--- /dev/null
+++ b/code/train/C/0129776_Filter.c
@@ -0,0 +1,52 @@
+int rightValues[5];
+int leftValues[5];
+
+int doFilter(int * valueList) {
+	// get total
+	int total = 0;
+
+
+	int biggest = valueList[0];
+	int lowest = valueList[0];
+
+
+	for(int i = 0; i < 5; i++){
+			total += valueList[i];
+
+			if(valueList[i] > biggest){
+				biggest = valueList[i];
+			}
+
+			if(valueList[i] < lowest){
+				lowest = valueList[i];
+			}
+
+	}
+int filteredTotal = total - (biggest + lowest);
+int filterAverage = (filteredTotal/3);
+
+return filterAverage;
+
+}
+
+int filterLeft(int value){
+	// maintain left list
+	for(int i=4; i > 0; --i){
+			leftValues[i] = leftValues[i-1];
+	}
+
+	leftValues[0] = value;
+	//get total
+	return doFilter(leftValues);
+}
+
+int filterRight(int value){
+	// maintain list
+	for(int i = 4; i > 0; --i){
+			rightValues[i] = rightValues[i-1];
+	}
+
+	rightValues[0] = value;
+	// get total
+	return doFilter(rightValues);
+}
diff --git a/code/train/C/0130095_bfnmerge.c b/code/train/C/0130095_bfnmerge.c
new file mode 100644
index 0000000000000000000000000000000000000000..c9c5c37c8667a213893224c26a56d8e60f075134
--- /dev/null
+++ b/code/train/C/0130095_bfnmerge.c
@@ -0,0 +1,141 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+	unsigned char *charbuf, *map;
+
+	FILE *fd, *ofd;
+	char *buf;
+	int s, e;
+	int i, j;
+	int w, h, wl;
+
+	charbuf=malloc(65536*128);
+	map=malloc(65536/8);
+	memset(map, 0, 65536/8);
+
+	w=8;
+	h=16;
+	wl=0;
+
+	for(i=2; i<argc; i++)
+	{
+		printf("%s\n", argv[i]);
+		fd=fopen(argv[i], "rb");
+
+		s=fgetc(fd);
+		s+=fgetc(fd)<<8;
+
+		e=fgetc(fd);
+		e+=fgetc(fd)<<8;
+
+		if(s==0xBF00)
+		{
+			buf=malloc(16);
+			fread(buf, 1, e, fd);
+			if(!wl)
+			{
+				w=buf[1];
+				h=buf[2];
+				printf("head %dx%d\n", w, h);
+				wl=1;
+			}else if((buf[1]!=w) || (buf[2]!=h))
+			{
+				printf("font cell dimension mismatch\n");
+				exit(-1);
+			}
+		}else
+		{
+			printf("missing head.\n");
+			exit(-1);
+		}
+
+		while(1)
+		{
+			s=fgetc(fd);
+			s+=fgetc(fd)<<8;
+
+			e=fgetc(fd);
+			e+=fgetc(fd)<<8;
+
+			if(!s && !e)break;
+
+//			printf("%d-%d ", s, e);
+
+			buf=malloc(((e-s)+1)*((w*h)/8));
+			fread(buf, (e-s)+1, (w*h)/8, fd);
+
+			for(j=0; j<((e-s)+1); j++)if(!(map[(s+j)/8]&(1<<((s+j)&7))) )
+			{
+				map[(s+j)/8]|=1<<((s+j)&7);
+				memcpy(charbuf+((s+j)*((w*h)/8)), buf+(j*((w*h)/8)), ((w*h)/8));
+			}
+		}
+//		printf("\n");
+		fclose(fd);
+	}
+
+	ofd=fopen(argv[1], "wb");
+
+	//write head
+	fputc(0x00, ofd);	//0xBF00
+	fputc(0xBF, ofd);
+
+	fputc(0x04, ofd);	//head len
+	fputc(0x00, ofd);
+
+	fputc(0x00, ofd);
+	fputc(w, ofd);
+	fputc(h, ofd);
+	fputc(0x01, ofd);
+
+	s=0;
+	e=0;
+
+	for(i=0; i<65536; i++)
+	{
+		if(map[i/8]&(1<<(i&7)))
+		{
+			if(!s)
+			{
+				s=i;
+				e=i;
+			}else e=i;
+		}else
+		{
+			if(s || e)
+			{
+//				printf("%d-%d ", s, e);
+
+				fputc(s&0xff, ofd);
+				fputc((s>>8)&0xff, ofd);
+				fputc(e&0xff, ofd);
+				fputc((e>>8)&0xff, ofd);
+				fwrite(charbuf+(s*((w*h)/8)), e-s+1, ((w*h)/8), ofd);
+			}
+			s=0;
+			e=0;
+		}
+	}
+	if(s || e)
+	{
+//		printf("%d-%d ", s, e);
+
+		fputc(s&0xff, ofd);
+		fputc((s>>8)&0xff, ofd);
+		fputc(e&0xff, ofd);
+		fputc((e>>8)&0xff, ofd);
+		fwrite(charbuf+(s*((w*h)/8)), e-s+1, ((w*h)/8), ofd);
+	}
+
+	//special end of font marker...
+	fputc(0, ofd);
+	fputc(0, ofd);
+	fputc(0, ofd);
+	fputc(0, ofd);
+
+//	fwrite(outbuf, 256*16, 256*8*3, ofd);
+
+	return(0);
+}
diff --git a/code/train/C/0130499_redboot.c b/code/train/C/0130499_redboot.c
new file mode 100644
index 0000000000000000000000000000000000000000..2349366c5fd18f1c195d10568b1441a9acd5ed06
--- /dev/null
+++ b/code/train/C/0130499_redboot.c
@@ -0,0 +1,272 @@
+/*
+ * $Id: redboot.c,v 1.21 2006/03/30 18:34:37 bjd Exp $
+ *
+ * Parse RedBoot-style Flash Image System (FIS) tables and
+ * produce a Linux partition array to match.
+ */
+
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/vmalloc.h>
+
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/partitions.h>
+
+struct fis_image_desc {
+    unsigned char name[16];      // Null terminated name
+    uint32_t	  flash_base;    // Address within FLASH of image
+    uint32_t	  mem_base;      // Address in memory where it executes
+    uint32_t	  size;          // Length of image
+    uint32_t	  entry_point;   // Execution entry point
+    uint32_t	  data_length;   // Length of actual data
+    unsigned char _pad[256-(16+7*sizeof(uint32_t))];
+    uint32_t	  desc_cksum;    // Checksum over image descriptor
+    uint32_t	  file_cksum;    // Checksum over image data
+};
+
+struct fis_list {
+	struct fis_image_desc *img;
+	struct fis_list *next;
+};
+
+static int directory = CONFIG_MTD_REDBOOT_DIRECTORY_BLOCK;
+module_param(directory, int, 0);
+
+static inline int redboot_checksum(struct fis_image_desc *img)
+{
+	/* RedBoot doesn't actually write the desc_cksum field yet AFAICT */
+	return 1;
+}
+
+static int parse_redboot_partitions(struct mtd_info *master,
+                             struct mtd_partition **pparts,
+                             unsigned long fis_origin)
+{
+	int nrparts = 0;
+	struct fis_image_desc *buf;
+	struct mtd_partition *parts;
+	struct fis_list *fl = NULL, *tmp_fl;
+	int ret, i;
+	size_t retlen;
+	char *names;
+	char *nullname;
+	int namelen = 0;
+	int nulllen = 0;
+	int numslots;
+	unsigned long offset;
+#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
+	static char nullstring[] = "unallocated";
+#endif
+
+	buf = vmalloc(master->erasesize);
+
+	if (!buf)
+		return -ENOMEM;
+
+	if ( directory < 0 )
+		offset = master->size + directory*master->erasesize;
+	else
+		offset = directory*master->erasesize;
+
+	printk(KERN_NOTICE "Searching for RedBoot partition table in %s at offset 0x%lx\n",
+	       master->name, offset);
+
+	ret = master->read(master, offset,
+			   master->erasesize, &retlen, (void *)buf);
+
+	if (ret)
+		goto out;
+
+	if (retlen != master->erasesize) {
+		ret = -EIO;
+		goto out;
+	}
+
+	numslots = (master->erasesize / sizeof(struct fis_image_desc));
+	for (i = 0; i < numslots; i++) {
+		if (!memcmp(buf[i].name, "FIS directory", 14)) {
+			/* This is apparently the FIS directory entry for the
+			 * FIS directory itself.  The FIS directory size is
+			 * one erase block; if the buf[i].size field is
+			 * swab32(erasesize) then we know we are looking at
+			 * a byte swapped FIS directory - swap all the entries!
+			 * (NOTE: this is 'size' not 'data_length'; size is
+			 * the full size of the entry.)
+			 */
+			if (swab32(buf[i].size) == master->erasesize) {
+				int j;
+				for (j = 0; j < numslots; ++j) {
+
+					/* A single 0xff denotes a deleted entry.
+					 * Two of them in a row is the end of the table.
+					 */
+					if (buf[j].name[0] == 0xff) {
+				  		if (buf[j].name[1] == 0xff) {
+							break;
+						} else {
+							continue;
+						}
+					}
+
+					/* The unsigned long fields were written with the
+					 * wrong byte sex, name and pad have no byte sex.
+					 */
+					swab32s(&buf[j].flash_base);
+					swab32s(&buf[j].mem_base);
+					swab32s(&buf[j].size);
+					swab32s(&buf[j].entry_point);
+					swab32s(&buf[j].data_length);
+					swab32s(&buf[j].desc_cksum);
+					swab32s(&buf[j].file_cksum);
+				}
+			}
+			break;
+		}
+	}
+	if (i == numslots) {
+		/* Didn't find it */
+		printk(KERN_NOTICE "No RedBoot partition table detected in %s\n",
+		       master->name);
+		ret = 0;
+		goto out;
+	}
+
+	for (i = 0; i < numslots; i++) {
+		struct fis_list *new_fl, **prev;
+
+		if (buf[i].name[0] == 0xff) {
+			if (buf[i].name[1] == 0xff) {
+				break;
+			} else {
+				continue;
+			}
+		}
+		if (!redboot_checksum(&buf[i]))
+			break;
+
+		new_fl = kmalloc(sizeof(struct fis_list), GFP_KERNEL);
+		namelen += strlen(buf[i].name)+1;
+		if (!new_fl) {
+			ret = -ENOMEM;
+			goto out;
+		}
+		new_fl->img = &buf[i];
+                if (fis_origin) {
+                        buf[i].flash_base -= fis_origin;
+                } else {
+                        buf[i].flash_base &= master->size-1;
+                }
+
+		/* I'm sure the JFFS2 code has done me permanent damage.
+		 * I now think the following is _normal_
+		 */
+		prev = &fl;
+		while(*prev && (*prev)->img->flash_base < new_fl->img->flash_base)
+			prev = &(*prev)->next;
+		new_fl->next = *prev;
+		*prev = new_fl;
+
+		nrparts++;
+	}
+#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
+	if (fl->img->flash_base) {
+		nrparts++;
+		nulllen = sizeof(nullstring);
+	}
+
+	for (tmp_fl = fl; tmp_fl->next; tmp_fl = tmp_fl->next) {
+		if (tmp_fl->img->flash_base + tmp_fl->img->size + master->erasesize <= tmp_fl->next->img->flash_base) {
+			nrparts++;
+			nulllen = sizeof(nullstring);
+		}
+	}
+#endif
+	parts = kmalloc(sizeof(*parts)*nrparts + nulllen + namelen, GFP_KERNEL);
+
+	if (!parts) {
+		ret = -ENOMEM;
+		goto out;
+	}
+
+	memset(parts, 0, sizeof(*parts)*nrparts + nulllen + namelen);
+
+	nullname = (char *)&parts[nrparts];
+#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
+	if (nulllen > 0) {
+		strcpy(nullname, nullstring);
+	}
+#endif
+	names = nullname + nulllen;
+
+	i=0;
+
+#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
+	if (fl->img->flash_base) {
+	       parts[0].name = nullname;
+	       parts[0].size = fl->img->flash_base;
+	       parts[0].offset = 0;
+		i++;
+	}
+#endif
+	for ( ; i<nrparts; i++) {
+		parts[i].size = fl->img->size;
+		parts[i].offset = fl->img->flash_base;
+		parts[i].name = names;
+
+		strcpy(names, fl->img->name);
+#ifdef CONFIG_MTD_REDBOOT_PARTS_READONLY
+		if (!memcmp(names, "RedBoot", 8) ||
+				!memcmp(names, "RedBoot config", 15) ||
+				!memcmp(names, "FIS directory", 14)) {
+			parts[i].mask_flags = MTD_WRITEABLE;
+		}
+#endif
+		names += strlen(names)+1;
+
+#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
+		if(fl->next && fl->img->flash_base + fl->img->size + master->erasesize <= fl->next->img->flash_base) {
+			i++;
+			parts[i].offset = parts[i-1].size + parts[i-1].offset;
+			parts[i].size = fl->next->img->flash_base - parts[i].offset;
+			parts[i].name = nullname;
+		}
+#endif
+		tmp_fl = fl;
+		fl = fl->next;
+		kfree(tmp_fl);
+	}
+	ret = nrparts;
+	*pparts = parts;
+ out:
+	while (fl) {
+		struct fis_list *old = fl;
+		fl = fl->next;
+		kfree(old);
+	}
+	vfree(buf);
+	return ret;
+}
+
+static struct mtd_part_parser redboot_parser = {
+	.owner = THIS_MODULE,
+	.parse_fn = parse_redboot_partitions,
+	.name = "RedBoot",
+};
+
+static int __init redboot_parser_init(void)
+{
+	return register_mtd_parser(&redboot_parser);
+}
+
+static void __exit redboot_parser_exit(void)
+{
+	deregister_mtd_parser(&redboot_parser);
+}
+
+module_init(redboot_parser_init);
+module_exit(redboot_parser_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Red Hat, Inc. - David Woodhouse <dwmw2@cambridge.redhat.com>");
+MODULE_DESCRIPTION("Parsing code for RedBoot Flash Image System (FIS) tables");
diff --git a/code/train/C/0130612_telldir.c b/code/train/C/0130612_telldir.c
new file mode 100644
index 0000000000000000000000000000000000000000..10c5eeaf3f5fcb9f1da2c9014dca0b20a7f0ccf6
--- /dev/null
+++ b/code/train/C/0130612_telldir.c
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 1983, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)telldir.c	8.1 (Berkeley) 6/4/93";
+#endif /* LIBC_SCCS and not lint */
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD: soc2013/dpl/head/lib/libc/gen/telldir.c 235983 2012-05-19 12:44:27Z gleb $");
+
+#include "namespace.h"
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <dirent.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "un-namespace.h"
+
+#include "libc_private.h"
+#include "gen-private.h"
+#include "telldir.h"
+
+/*
+ * The option SINGLEUSE may be defined to say that a telldir
+ * cookie may be used only once before it is freed. This option
+ * is used to avoid having memory usage grow without bound.
+ */
+#define SINGLEUSE
+
+/*
+ * return a pointer into a directory
+ */
+long
+telldir(dirp)
+	DIR *dirp;
+{
+	struct ddloc *lp;
+
+	if ((lp = (struct ddloc *)malloc(sizeof(struct ddloc))) == NULL)
+		return (-1);
+	if (__isthreaded)
+		_pthread_mutex_lock(&dirp->dd_lock);
+	lp->loc_index = dirp->dd_td->td_loccnt++;
+	lp->loc_seek = dirp->dd_seek;
+	lp->loc_loc = dirp->dd_loc;
+	LIST_INSERT_HEAD(&dirp->dd_td->td_locq, lp, loc_lqe);
+	if (__isthreaded)
+		_pthread_mutex_unlock(&dirp->dd_lock);
+	return (lp->loc_index);
+}
+
+/*
+ * seek to an entry in a directory.
+ * Only values returned by "telldir" should be passed to seekdir.
+ */
+void
+_seekdir(dirp, loc)
+	DIR *dirp;
+	long loc;
+{
+	struct ddloc *lp;
+	struct dirent *dp;
+
+	LIST_FOREACH(lp, &dirp->dd_td->td_locq, loc_lqe) {
+		if (lp->loc_index == loc)
+			break;
+	}
+	if (lp == NULL)
+		return;
+	if (lp->loc_loc == dirp->dd_loc && lp->loc_seek == dirp->dd_seek)
+		goto found;
+	(void) lseek(dirp->dd_fd, (off_t)lp->loc_seek, SEEK_SET);
+	dirp->dd_seek = lp->loc_seek;
+	dirp->dd_loc = 0;
+	while (dirp->dd_loc < lp->loc_loc) {
+		dp = _readdir_unlocked(dirp, 0);
+		if (dp == NULL)
+			break;
+	}
+found:
+#ifdef SINGLEUSE
+	LIST_REMOVE(lp, loc_lqe);
+	free((caddr_t)lp);
+#endif
+}
+
+/*
+ * Reclaim memory for telldir cookies which weren't used.
+ */
+void
+_reclaim_telldir(dirp)
+	DIR *dirp;
+{
+	struct ddloc *lp;
+	struct ddloc *templp;
+
+	lp = LIST_FIRST(&dirp->dd_td->td_locq);
+	while (lp != NULL) {
+		templp = lp;
+		lp = LIST_NEXT(lp, loc_lqe);
+		free(templp);
+	}
+	LIST_INIT(&dirp->dd_td->td_locq);
+}
diff --git a/code/train/C/0131283_GeneticAlgorithm.c b/code/train/C/0131283_GeneticAlgorithm.c
new file mode 100644
index 0000000000000000000000000000000000000000..2b209699cdb0e6f552c3cfdc242f1aeac2a58092
--- /dev/null
+++ b/code/train/C/0131283_GeneticAlgorithm.c
@@ -0,0 +1,229 @@
+#include "GeneticAlgorithm.h"
+
+#include <math.h>
+#include <time.h>
+#include <float.h>
+
+#include "World.h"
+#include "GAParameters.h"
+#include "GAOperators.h"
+
+#include "Logging/Logging.h"
+#include "Journal/Journal.h"
+
+static _Thread_local int last_error = 0;
+static _Thread_local bool stop_evolution = false;
+
+static double Iteration(World* world, size_t generation_number);
+static double GetMaxFitness(World* world);
+static void CountDiedSpecies(World* world);
+
+static void SetError(int error_code);
+static int GetLastError();
+static int ResetLastError();
+
+GAResult RunEvolution(const GAParameters* parameters,
+                      const GAOperators* operators,
+                      const Journal* journal) {
+    LOG_FUNC_START;
+
+    GAResult result = { 0 };
+
+    World* world = CreateWorld(parameters, operators, journal);
+    if (!world) {
+        Log(ERROR, "Error creating world");
+        goto error;
+    }
+
+    clock_t begin, end;
+    double time_spent = 0.0;
+
+    /*
+     * NOTE: sometimes the fitness of this randomly-generated entities
+     * is the best one we can achieve during the whole epoch.
+     *
+     * In this case the GA is absolutely useless, because
+     * random picking gives betters results.
+     *
+     * In this case GUI will show different max fitness,
+     * because GUI does not take into accout the max fitness
+     * of the randomly-generated entities.
+     */
+    double max_fitness = GetMaxFitness(world);
+    for (size_t i = 0;
+            i != parameters->max_generations_count
+            && !stop_evolution
+            && !EvolutionStopRequested(world->journal);
+            ++i) {
+        begin = clock();
+
+        double cur_fitness = Iteration(world, i + 1);
+        if (GetLastError()) {
+            goto destroy_world;
+        }
+
+        end = clock();
+        time_spent += (double)(end - begin) / CLOCKS_PER_SEC;
+
+        if (cur_fitness > max_fitness) {
+            max_fitness = cur_fitness;
+        }
+    }
+
+    result.optimum = max_fitness;
+    result.iterations_made = parameters->max_generations_count;
+    result.time_spent_per_iteration = time_spent
+                                      / parameters->max_generations_count;
+
+    DestroyWorld(world);
+    LOG_FUNC_SUCCESS;
+    return result;
+
+destroy_world:
+    DestroyWorld(world);
+error:
+    result.error = true;
+    LOG_FUNC_ERROR;
+    return result;
+}
+
+// Static methods section -----------
+
+double Iteration(World* world, size_t generation_number) {
+    LOG_FUNC_START;
+
+    ResetLastError();
+    RecordIterationStart(world->journal, world->population, generation_number);
+
+    if (world->operators->mutation) {
+        if (!world->operators->mutation(world, generation_number)) {
+            goto error;
+        }
+    }
+
+    LIST_TYPE(EntityPtr) new_entities = NULL;
+    LIST_TYPE(SpeciesPtr) clustered_species = NULL;
+    if (world->operators->crossover) {
+        new_entities = world->operators->crossover(world, generation_number);
+        if (!new_entities) {
+            goto error;
+        }
+        RecordCrossover(world->journal, world->population, new_entities);
+
+        if (world->operators->children_selection) {
+            if (!world->operators->children_selection(world, &new_entities)) {
+                goto destroy_new_entities;
+            }
+            RecordChildrenSelection(world->journal,
+                                    world->population,
+                                    new_entities);
+        }
+
+        if (world->operators->clustering) {
+            clustered_species =
+                    world->operators->clustering(world, new_entities,
+                                                 world->parameters->eps,
+                                                 world->parameters->min_pts);
+            if (!clustered_species) {
+                goto destroy_new_entities;
+            }
+            RecordClustering(world->journal,
+                             world->population,
+                             clustered_species);
+
+            if (!ClearPopulation(world->population)) {
+                goto destroy_clustered_species;
+            }
+            if (!list_move(SpeciesPtr, clustered_species, world->population)) {
+                goto destroy_clustered_species;
+            }
+            LOG_ASSERT(list_len(clustered_species) == 0);
+            list_destroy(SpeciesPtr, clustered_species);
+            clustered_species = NULL;
+        }
+        else {
+            if (!list_move(EntityPtr, new_entities,
+                           list_first(world->population)->entities)) {
+                goto destroy_new_entities;
+            }
+        }
+        DestroyEntitiesList(new_entities);
+        new_entities = NULL;
+
+        world->size = 0;
+        list_for_each(SpeciesPtr, world->population, var) {
+            world->size += list_len(list_var_value(var)->entities);
+        }
+
+        if (world->operators->selection && world->size) {
+            RecordBeforeSelection(world->journal,
+                                  world->population, world->size);
+            if (!world->operators->selection(world)) {
+                goto error;
+            }
+            RecordSelection(world->journal, world->population, world->size);
+        }
+    }
+
+    CountDiedSpecies(world);
+    RecordIterationEnd(world->journal, world->population, world->chr_size);
+
+    double max_fitness = GetMaxFitness(world);
+    if (world->operators->iteration_info_hook) {
+        stop_evolution = world->operators->iteration_info_hook(world, generation_number, max_fitness);
+    }
+    LogMaxFitness(max_fitness);
+    LOG_FUNC_SUCCESS;
+    return max_fitness;
+
+destroy_clustered_species:
+    DestroyPopulation(clustered_species);
+destroy_new_entities:
+    DestroyEntitiesList(new_entities);
+error:
+    SetError(1);
+    LOG_FUNC_ERROR;
+    return 0.0;
+}
+
+double GetMaxFitness(World* world) {
+    double max_fitness = -DBL_MAX;
+    list_for_each(SpeciesPtr, world->population, species_var) {
+        list_for_each(EntityPtr,
+                      list_var_value(species_var)->entities,
+                      entity_var) {
+            if (list_var_value(entity_var)->fitness > max_fitness) {
+                max_fitness = list_var_value(entity_var)->fitness;
+            }
+        }
+    }
+    return max_fitness;
+}
+
+static void CountDiedSpecies(World* world) {
+    list_for_each(SpeciesPtr, world->population, species_var) {
+        Species* species = list_var_value(species_var);
+        LOG_RELEASE_ASSERT(species->initial_size != 0);
+        if (species->died / (double)species->initial_size > EXTINCTION_BIAS) {
+            RecordSpeciesDeath(world->journal, species->initial_size);
+            species->died = 0;
+            species->initial_size = list_len(species->entities);
+            SetEntitiesStatus(species->entities, true);
+        }
+    }
+}
+
+static void SetError(int error_code) {
+    last_error = error_code;
+    Log(ERROR, "Error set: %d", last_error);
+}
+
+int GetLastError() {
+    return last_error;
+}
+
+int ResetLastError() {
+    int temp = last_error;
+    last_error = 0;
+    return temp;
+}
\ No newline at end of file
diff --git a/code/train/C/0131720_bspc.c b/code/train/C/0131720_bspc.c
new file mode 100644
index 0000000000000000000000000000000000000000..416edd727a7595991a33eb28c09d24da4ef29721
--- /dev/null
+++ b/code/train/C/0131720_bspc.c
@@ -0,0 +1,94 @@
+/* Copyright (c) 2012, Bastien Dejean
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. 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.
+ *
+ * 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.
+ */
+
+#include <stdlib.h>
+#ifdef __OpenBSD__
+#include <sys/types.h>
+#endif
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <ctype.h>
+#include "helpers.h"
+#include "common.h"
+
+int main(int argc, char *argv[])
+{
+	int fd;
+	struct sockaddr_un sock_address;
+	char msg[BUFSIZ], rsp[BUFSIZ];
+
+	if (argc < 2)
+		err("No arguments given.\n");
+
+	sock_address.sun_family = AF_UNIX;
+	char *sp;
+
+	if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
+		err("Failed to create the socket.\n");
+
+	sp = getenv(SOCKET_ENV_VAR);
+	if (sp != NULL) {
+		snprintf(sock_address.sun_path, sizeof(sock_address.sun_path), "%s", sp);
+	} else {
+		char *host = NULL;
+		int dn = 0, sn = 0;
+		if (xcb_parse_display(NULL, &host, &dn, &sn) != 0)
+			snprintf(sock_address.sun_path, sizeof(sock_address.sun_path), SOCKET_PATH_TPL, host, dn, sn);
+		free(host);
+	}
+
+	if (connect(fd, (struct sockaddr *) &sock_address, sizeof(sock_address)) == -1)
+		err("Failed to connect to the socket.\n");
+
+	argc--, argv++;
+	int msg_len = 0;
+
+	for (int offset = 0, rem = sizeof(msg), n = 0; argc > 0 && rem > 0; offset += n, rem -= n, argc--, argv++) {
+		n = snprintf(msg + offset, rem, "%s%c", *argv, 0);
+		msg_len += n;
+	}
+
+	if (send(fd, msg, msg_len, 0) == -1)
+		err("Failed to send the data.\n");
+
+	int ret = 0, nb;
+	while ((nb = recv(fd, rsp, sizeof(rsp)-1, 0)) > 0) {
+		if (nb == 1 && rsp[0] < MSG_LENGTH) {
+			ret = rsp[0];
+			if (ret == MSG_UNKNOWN) {
+				warn("Unknown command.\n");
+			} else if (ret == MSG_SYNTAX) {
+				warn("Invalid syntax.\n");
+			}
+		} else {
+			rsp[nb] = '\0';
+			printf("%s", rsp);
+			fflush(stdout);
+		}
+	}
+
+	close(fd);
+	return ret;
+}
diff --git a/code/train/C/0131767_bag.c b/code/train/C/0131767_bag.c
new file mode 100644
index 0000000000000000000000000000000000000000..f4b9661be3d0b23ea282ebca9c1fff706971bacc
--- /dev/null
+++ b/code/train/C/0131767_bag.c
@@ -0,0 +1,141 @@
+/*  bag.c -- ARMulator support code:  ARM6 Instruction Emulator.
+    Copyright (C) 1994 Advanced RISC Machines Ltd.
+ 
+    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. */
+
+/********************************************************************/
+/* bag.c:                                                           */
+/* Offers a data structure for storing and getting pairs of number. */
+/* The numbers are stored together, put one can be looked up by     */
+/* quoting the other.  If a new pair is entered and one of the      */
+/* numbers is a repeat of a previous pair, then the previos pair    */
+/* is deleted.                                                      */
+/********************************************************************/
+
+#include "bag.h"
+
+#define HASH_TABLE_SIZE 256
+#define hash(x) (((x)&0xff)^(((x)>>8)&0xff)^(((x)>>16)&0xff)^(((x)>>24)&0xff))
+
+typedef struct hashentry {
+  struct hashentry *next;
+  int first;
+  int second;
+} Hashentry;
+
+Hashentry *lookupbyfirst[HASH_TABLE_SIZE];
+Hashentry *lookupbysecond[HASH_TABLE_SIZE];
+
+void addtolist(Hashentry **add, long first, long second) {
+  while (*add) add = &((*add)->next);
+  /* Malloc will never fail? :o( */
+  (*add) = (Hashentry *) malloc(sizeof(Hashentry));
+  (*add)->next = (Hashentry *) 0;
+  (*add)->first = first;
+  (*add)->second = second;
+}
+
+void killwholelist(Hashentry *p) {
+  Hashentry *q;
+
+  while (p) {
+    q = p;
+    p = p->next;
+    free(q);
+  }
+}
+
+void removefromlist(Hashentry **p, long first, long second) {
+  Hashentry *q;
+
+  while (*p) {
+    if ((*p)->first == first) {
+      q = (*p)->next;
+      free(*p);
+      *p = q;
+      return;
+    }
+    p = &((*p)->next);
+  }
+}
+
+void BAG_putpair(long first, long second) {
+  long junk;
+
+  if (BAG_getfirst(&junk, second) != NO_SUCH_PAIR)
+    BAG_killpair_bysecond(second);
+  addtolist(&lookupbyfirst[hash(first)], first, second);
+  addtolist(&lookupbysecond[hash(second)], first, second);
+}
+
+Bag_error BAG_getfirst(long *first, long second) {
+  Hashentry *look;
+
+  look = lookupbysecond[hash(second)];
+  while(look) if (look->second == second) {
+    *first = look->first;
+    return NO_ERROR;
+  }
+  return NO_SUCH_PAIR;
+}
+
+Bag_error BAG_getsecond(long first, long *second) {
+  Hashentry *look;
+
+  look = lookupbyfirst[hash(first)];
+  while(look) {
+    if (look->first == first) {
+      *second = look->second;
+      return NO_ERROR;
+    }
+    look = look->next;
+  }
+  return NO_SUCH_PAIR;
+}
+
+Bag_error BAG_killpair_byfirst(long first) {
+  long second;
+
+  if (BAG_getsecond(first, &second) == NO_SUCH_PAIR)
+    return NO_SUCH_PAIR;
+  removefromlist(&lookupbyfirst[hash(first)], first, second);
+  removefromlist(&lookupbysecond[hash(second)], first, second);
+  return NO_ERROR;
+}
+
+Bag_error BAG_killpair_bysecond(long second) {
+  long first;
+  
+  if (BAG_getfirst(&first, second) == NO_SUCH_PAIR)
+    return NO_SUCH_PAIR;
+  removefromlist(&lookupbyfirst[hash(first)], first, second);
+  removefromlist(&lookupbysecond[hash(second)], first, second);
+  return NO_ERROR;
+}
+
+void BAG_newbag() {
+  int i;
+
+  for (i = 0; i < 256; i++) {
+    killwholelist(lookupbyfirst[i]);
+    killwholelist(lookupbysecond[i]);
+    lookupbyfirst[i] = lookupbysecond[i] = (Hashentry *) 0;
+  }
+}
+  
+
+
+
+
diff --git a/code/train/C/0132052_read_POMC_stack.c b/code/train/C/0132052_read_POMC_stack.c
new file mode 100644
index 0000000000000000000000000000000000000000..447480c79cb3a3914d856f4516fce9c254ea670f
--- /dev/null
+++ b/code/train/C/0132052_read_POMC_stack.c
@@ -0,0 +1,64 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <hdf5.h>
+#include <hdf5_hl.h>
+#define FILE "Data_POMC.hdf5"
+#define DSET "stack"
+
+int main(int argc, char *argv[])
+{
+  if (argc != 5) {
+    fprintf(stderr,"Expecting four arguments\n");
+    return -1;
+  }
+  size_t first_row = atoi(argv[1]);
+  size_t last_row = atoi(argv[2]);
+  size_t first_col = atoi(argv[3]);
+  size_t last_col = atoi(argv[4]);
+  // Open FILE
+  hid_t file_id = H5Fopen (FILE, H5F_ACC_RDONLY, H5P_DEFAULT);
+  // Get dimensions of 3D object contained in DSET
+  hsize_t dims[3];
+  H5LTget_dataset_info(file_id,DSET,dims,NULL,NULL);
+  size_t nrow = (size_t) dims[0];
+  size_t ncol = (size_t) dims[1];
+  size_t nsamp = (size_t) dims[2];
+  // Read DSET in DATA
+  int data[nrow][ncol][nsamp];
+  H5LTread_dataset_int(file_id,"/stack",data);
+  // Find out the smallest and largest observations
+  // in the selected part of DSET
+  int adu_max=0;
+  int adu_min=10000;
+  for (size_t i=first_row; i<last_row; i++) {
+    for (size_t j=first_col; j<last_col; j++)  {
+      for (size_t k=0; k<nsamp; k++) {
+        double adu = data[i][j][k];
+        if (adu < adu_min) adu_min=adu;
+        if (adu > adu_max) adu_max=adu;
+      }
+    }
+  }
+  // Print some info to STDOUT
+  printf("# Data set stack from file: %s\n",FILE);
+  printf("# Data set dimensions: (%d,%d,%d)\n",nrow,ncol,nsamp);
+  printf("# Using rows from %d (inclusive) to %d (exclusive)\n",first_row,last_row);
+  printf("# Using columns from %d (inclusive) to %d (exclusive)\n",first_col,last_col);
+  printf("# Minimal ADU in this range: %d; maximal value: %d\n",adu_min,adu_max);
+  double adu_delta = (double) (adu_max-adu_min);
+  // Write the DATA in a 2 columns format with time in the first and normalized
+  // ADU in the second
+  for (size_t i=first_row; i<last_row; i++) {
+    double y_min = i-first_row;
+    for (size_t j=first_col; j<last_col; j++)  {
+      for (size_t k=0; k<nsamp; k++) {
+        double adu = (data[i][j][k]-adu_min)/adu_delta+y_min;
+        printf("%g %g\n",((double) k/nsamp+j-first_col),adu);
+      }
+      printf("\n");
+    }
+  }
+  H5Fclose (file_id);
+  return 0;
+
+}
diff --git a/code/train/C/0132360_QSort_test.c b/code/train/C/0132360_QSort_test.c
new file mode 100644
index 0000000000000000000000000000000000000000..e0cff9630a8ee763870f5143c64b60ac2b1ba03d
--- /dev/null
+++ b/code/train/C/0132360_QSort_test.c
@@ -0,0 +1,39 @@
+/* vim: set expandtab ts=4 sw=4: */
+/*
+ * You may redistribute this program 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 <https://www.gnu.org/licenses/>.
+ */
+
+#include "util/Assert.h"
+#include "util/QSort.h"
+
+static int compare(const void* a, const void* b)
+{
+    return (*(int *) a - *(int *) b);
+}
+
+int main()
+{
+    int values[] = { 40, 10, 100, 90, 20, 25, -15, 30, -225};
+
+    QSort(values, sizeof(values) / sizeof(int), sizeof(int), compare);
+
+    int last = values[0];
+    for (size_t i = 1; i < sizeof(values) / sizeof(int); i++) {
+        Assert_true(last <= values[i]);
+        last = values[i];
+    }
+    // Should not crash
+    QSort(values, 0, sizeof(int), compare);
+
+    return 0;
+}
diff --git a/code/train/C/0132412_7-performance.c b/code/train/C/0132412_7-performance.c
new file mode 100644
index 0000000000000000000000000000000000000000..7ad141c0f796c1c38dbeed10a23a4590a543b5cf
--- /dev/null
+++ b/code/train/C/0132412_7-performance.c
@@ -0,0 +1,203 @@
+/*
+* Copyright (c) Bull S.A.  2007 All Rights Reserved.
+*
+* This program is free software; you can redistribute it and/or modify it
+* under the terms of version 2 of the GNU General Public License as
+* published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it would be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+*
+* Further, this software is distributed without any warranty that it is
+* free of the rightful claim of any third person regarding infringement
+* or the like.  Any license provided herein, whether implied or
+* otherwise, applies only to this software file.  Patent licenses, if
+* any, provided herein do not apply to combinations of this program with
+* other software, or any other product whatsoever.
+*
+* You should have received a copy of the GNU General Public License along
+* with this program; if not, write the Free Software Foundation, Inc.,
+* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*
+* History:
+* Created by: Cyril Lacabanne (Cyril.Lacabanne@bull.net)
+*
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <tirpc/rpc/rpc.h>
+
+//Standard define
+#define PROCNUM 1
+#define VERSNUM 1
+
+//Set number of test call
+int maxIter;
+
+//Sys define
+#define ADDRBUFSIZE 100
+
+double average(double *tbl)
+{
+	//Return average of values in tbl
+	int i;
+	double rslt = 0;
+
+	for (i = 0; i < maxIter; i++)
+	{
+		rslt += tbl[i];
+	}
+	rslt = rslt / maxIter;
+	return rslt;
+}
+
+double mini(double *tbl)
+{
+	//Return minimal of values in tbl
+	int i;
+	double rslt = tbl[0];
+
+	for (i = 0; i < maxIter; i++)
+	{
+		if (rslt > tbl[i])
+			rslt = tbl[i];
+	}
+	return rslt;
+}
+
+double maxi(double *tbl)
+{
+	//Return maximal of values in tbl
+	int i;
+	double rslt = tbl[0];
+
+	for (i = 0; i < maxIter; i++)
+	{
+		if (rslt < tbl[i])
+			rslt = tbl[i];
+	}
+	return rslt;
+}
+
+int main(int argn, char *argc[])
+{
+	//Program parameters : argc[1] : HostName or Host IP
+	//					   argc[2] : Server Program Number
+	//					   argc[3] : Number of test call
+	//					   other arguments depend on test case
+
+	//run_mode can switch into stand alone program or program launch by shell script
+	//1 : stand alone, debug mode, more screen information
+	//0 : launch by shell script as test case, only one printf -> result status
+	int run_mode = 0;
+	int test_status = 0; //Default test result set to FAILED
+	int i;
+	double *resultTbl;
+	struct timeval tv1,tv2;
+    struct timezone tz;
+    long long diff;
+    double rslt;
+	int progNum = atoi(argc[2]);
+    CLIENT *client = NULL;
+	struct netconfig *nconf = NULL;
+	struct netbuf svcaddr;
+    char addrbuf[ADDRBUFSIZE];
+	enum clnt_stat cs;
+	int var_snd = 0;
+	int var_rec = -1;
+	struct timeval tv;
+
+	//Test initialisation
+    maxIter = atoi(argc[3]);
+    resultTbl = (double *)malloc(maxIter * sizeof(double));
+
+    tv.tv_sec = 0;
+	tv.tv_usec = 100;
+
+	nconf = getnetconfigent("udp");
+	if (nconf == (struct netconfig *) NULL)
+	{
+		//syslog(LOG_ERR, "getnetconfigent for udp failed");
+		fprintf(stderr, "err nconf\n");
+		printf("5\n");
+		exit(1);
+	}
+
+	svcaddr.len = 0;
+	svcaddr.maxlen = ADDRBUFSIZE;
+	svcaddr.buf = addrbuf;
+
+	if (svcaddr.buf == NULL)
+	{
+    	/* if malloc() failed, print error messages and exit */
+		printf("5\n");
+  		exit(1);
+    }
+
+    //printf("svcaddr reserved (%s)\n", argc[1]);
+
+	if (!rpcb_getaddr(progNum, VERSNUM, nconf,
+                               &svcaddr, argc[1]))
+    {
+    	fprintf(stderr, "rpcb_getaddr failed!!\n");
+		printf("5\n");
+    	exit(1);
+    }
+    //printf("svc get\n");
+
+	client = clnt_dg_create(RPC_ANYFD, &svcaddr,
+			 				progNum, VERSNUM, 1024, 1024);
+
+	if (client == NULL)
+	{
+		clnt_pcreateerror("ERR");
+		exit(1);
+	}
+
+	//Call tested function several times
+	for (i = 0; i < maxIter; i++)
+	{
+		//Tic
+		gettimeofday(&tv1, &tz);
+
+		//Call function
+		cs = clnt_call(client, PROCNUM,
+	               		(xdrproc_t)xdr_int, (char *)&var_snd,
+	               		(xdrproc_t)xdr_int, (char *)&var_rec,
+	               		tv);
+
+		//Toc
+		gettimeofday(&tv2, &tz);
+
+		//Add function execution time (toc-tic)
+		diff = (tv2.tv_sec-tv1.tv_sec) * 1000000L + (tv2.tv_usec-tv1.tv_usec);
+		rslt = (double)diff / 1000;
+
+    	if (cs == RPC_SUCCESS)
+    	{
+    		resultTbl[i] = rslt;
+    	}
+    	else
+    	{
+    		test_status = 1;
+    		break;
+    	}
+
+    	if (run_mode)
+    	{
+    		fprintf(stderr, "lf time  = %lf usecn\n", resultTbl[i]);
+    	}
+	}
+
+	//This last printf gives the result status to the tests suite
+	//normally should be 0: test has passed or 1: test has failed
+	printf("%d\n", test_status);
+	printf("%lf %d\n", average(resultTbl), maxIter);
+	printf("%lf\n", mini(resultTbl));
+	printf("%lf\n", maxi(resultTbl));
+
+	return test_status;
+}
diff --git a/code/train/C/0132727_bitmap.c b/code/train/C/0132727_bitmap.c
new file mode 100644
index 0000000000000000000000000000000000000000..38748b0e342f76f9010f927659884859e823a3b5
--- /dev/null
+++ b/code/train/C/0132727_bitmap.c
@@ -0,0 +1,75 @@
+/*
+ * From lib/bitmap.c
+ * Helper functions for bitmap.h.
+ *
+ * This source code is licensed under the GNU General Public License,
+ * Version 2.  See the file COPYING for more details.
+ */
+#include <linux/bitmap.h>
+
+int __bitmap_weight(const unsigned long *bitmap, int bits)
+{
+	int k, w = 0, lim = bits/BITS_PER_LONG;
+
+	for (k = 0; k < lim; k++)
+		w += hweight_long(bitmap[k]);
+
+	if (bits % BITS_PER_LONG)
+		w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits));
+
+	return w;
+}
+
+void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
+		 const unsigned long *bitmap2, int bits)
+{
+	int k;
+	int nr = BITS_TO_LONGS(bits);
+
+	for (k = 0; k < nr; k++)
+		dst[k] = bitmap1[k] | bitmap2[k];
+}
+
+size_t bitmap_scnprintf(unsigned long *bitmap, int nbits,
+			char *buf, size_t size)
+{
+	/* current bit is 'cur', most recently seen range is [rbot, rtop] */
+	int cur, rbot, rtop;
+	bool first = true;
+	size_t ret = 0;
+
+	rbot = cur = find_first_bit(bitmap, nbits);
+	while (cur < nbits) {
+		rtop = cur;
+		cur = find_next_bit(bitmap, nbits, cur + 1);
+		if (cur < nbits && cur <= rtop + 1)
+			continue;
+
+		if (!first)
+			ret += scnprintf(buf + ret, size - ret, ",");
+
+		first = false;
+
+		ret += scnprintf(buf + ret, size - ret, "%d", rbot);
+		if (rbot < rtop)
+			ret += scnprintf(buf + ret, size - ret, "-%d", rtop);
+
+		rbot = cur;
+	}
+	return ret;
+}
+
+int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
+		 const unsigned long *bitmap2, unsigned int bits)
+{
+	unsigned int k;
+	unsigned int lim = bits/BITS_PER_LONG;
+	unsigned long result = 0;
+
+	for (k = 0; k < lim; k++)
+		result |= (dst[k] = bitmap1[k] & bitmap2[k]);
+	if (bits % BITS_PER_LONG)
+		result |= (dst[k] = bitmap1[k] & bitmap2[k] &
+			   BITMAP_LAST_WORD_MASK(bits));
+	return result != 0;
+}
diff --git a/code/train/C/0133452_lwt_len_hist_user.c b/code/train/C/0133452_lwt_len_hist_user.c
new file mode 100644
index 0000000000000000000000000000000000000000..587b68b1f8dde6f4758dd16f8bb68a88f1816c84
--- /dev/null
+++ b/code/train/C/0133452_lwt_len_hist_user.c
@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <linux/unistd.h>
+#include <linux/bpf.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <arpa/inet.h>
+
+#include <bpf/bpf.h>
+#include "bpf_util.h"
+
+#define MAX_INDEX 64
+#define MAX_STARS 38
+
+char bpf_log_buf[BPF_LOG_BUF_SIZE];
+
+static void stars(char *str, long val, long max, int width)
+{
+	int i;
+
+	for (i = 0; i < (width * val / max) - 1 && i < width - 1; i++)
+		str[i] = '*';
+	if (val > max)
+		str[i - 1] = '+';
+	str[i] = '\0';
+}
+
+int main(int argc, char **argv)
+{
+	unsigned int nr_cpus = bpf_num_possible_cpus();
+	const char *map_filename = "/sys/fs/bpf/tc/globals/lwt_len_hist_map";
+	uint64_t values[nr_cpus], sum, max_value = 0, data[MAX_INDEX] = {};
+	uint64_t key = 0, next_key, max_key = 0;
+	char starstr[MAX_STARS];
+	int i, map_fd;
+
+	map_fd = bpf_obj_get(map_filename);
+	if (map_fd < 0) {
+		fprintf(stderr, "bpf_obj_get(%s): %s(%d)\n",
+			map_filename, strerror(errno), errno);
+		return -1;
+	}
+
+	while (bpf_map_get_next_key(map_fd, &key, &next_key) == 0) {
+		if (next_key >= MAX_INDEX) {
+			fprintf(stderr, "Key %lu out of bounds\n", next_key);
+			continue;
+		}
+
+		bpf_map_lookup_elem(map_fd, &next_key, values);
+
+		sum = 0;
+		for (i = 0; i < nr_cpus; i++)
+			sum += values[i];
+
+		data[next_key] = sum;
+		if (sum && next_key > max_key)
+			max_key = next_key;
+
+		if (sum > max_value)
+			max_value = sum;
+
+		key = next_key;
+	}
+
+	for (i = 1; i <= max_key + 1; i++) {
+		stars(starstr, data[i - 1], max_value, MAX_STARS);
+		printf("%8ld -> %-8ld : %-8ld |%-*s|\n",
+		       (1l << i) >> 1, (1l << i) - 1, data[i - 1],
+		       MAX_STARS, starstr);
+	}
+
+	close(map_fd);
+
+	return 0;
+}
diff --git a/code/train/C/0134108_tcp_helper.c b/code/train/C/0134108_tcp_helper.c
new file mode 100644
index 0000000000000000000000000000000000000000..01bdf9581af28814cb2fa574aa8166b554fd73bf
--- /dev/null
+++ b/code/train/C/0134108_tcp_helper.c
@@ -0,0 +1,249 @@
+#include "tcp_helper.h"
+
+#include "lwip/tcp_impl.h"
+#include "lwip/stats.h"
+#include "lwip/pbuf.h"
+#include "lwip/inet_chksum.h"
+
+#if !LWIP_STATS || !TCP_STATS || !MEMP_STATS
+#error "This tests needs TCP- and MEMP-statistics enabled"
+#endif
+
+/** Remove all pcbs on the given list. */
+static void
+tcp_remove(struct tcp_pcb* pcb_list)
+{
+  struct tcp_pcb *pcb = pcb_list;
+  struct tcp_pcb *pcb2;
+
+  while(pcb != NULL) {
+    pcb2 = pcb;
+    pcb = pcb->next;
+    tcp_abort(pcb2);
+  }
+}
+
+/** Remove all pcbs on listen-, active- and time-wait-list (bound- isn't exported). */
+void
+tcp_remove_all(void)
+{
+  tcp_remove(tcp_listen_pcbs.pcbs);
+  tcp_remove(tcp_active_pcbs);
+  tcp_remove(tcp_tw_pcbs);
+  fail_unless(lwip_stats.memp[MEMP_TCP_PCB].used == 0);
+  fail_unless(lwip_stats.memp[MEMP_TCP_PCB_LISTEN].used == 0);
+  fail_unless(lwip_stats.memp[MEMP_TCP_SEG].used == 0);
+  fail_unless(lwip_stats.memp[MEMP_PBUF_POOL].used == 0);
+}
+
+/** Create a TCP segment usable for passing to tcp_input
+ * - IP-addresses, ports, seqno and ackno are taken from pcb
+ * - seqno and ackno can be altered with an offset
+ */
+struct pbuf*
+tcp_create_rx_segment(struct tcp_pcb* pcb, void* data, size_t data_len, u32_t seqno_offset,
+                      u32_t ackno_offset, u8_t headerflags)
+{
+  return tcp_create_segment(&pcb->remote_ip, &pcb->local_ip, pcb->remote_port, pcb->local_port,
+    data, data_len, pcb->rcv_nxt + seqno_offset, pcb->lastack + ackno_offset, headerflags);
+}
+
+/** Create a TCP segment usable for passing to tcp_input */
+struct pbuf*
+tcp_create_segment(ip_addr_t* src_ip, ip_addr_t* dst_ip,
+                   u16_t src_port, u16_t dst_port, void* data, size_t data_len,
+                   u32_t seqno, u32_t ackno, u8_t headerflags)
+{
+  struct pbuf* p;
+  struct ip_hdr* iphdr;
+  struct tcp_hdr* tcphdr;
+  u16_t pbuf_len = (u16_t)(sizeof(struct ip_hdr) + sizeof(struct tcp_hdr) + data_len);
+
+  p = pbuf_alloc(PBUF_RAW, pbuf_len, PBUF_POOL);
+  EXPECT_RETNULL(p != NULL);
+  EXPECT_RETNULL(p->next == NULL);
+
+  memset(p->payload, 0, p->len);
+
+  iphdr = p->payload;
+  /* fill IP header */
+  iphdr->dest.addr = dst_ip->addr;
+  iphdr->src.addr = src_ip->addr;
+  IPH_VHLTOS_SET(iphdr, 4, IP_HLEN / 4, 0);
+  IPH_LEN_SET(iphdr, htons(p->tot_len));
+  IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, IP_HLEN));
+
+  pbuf_header(p, -(s16_t)sizeof(struct ip_hdr));
+
+  tcphdr = p->payload;
+  tcphdr->src   = htons(src_port);
+  tcphdr->dest  = htons(dst_port);
+  tcphdr->seqno = htonl(seqno);
+  tcphdr->ackno = htonl(ackno);
+  TCPH_HDRLEN_SET(tcphdr, sizeof(struct tcp_hdr)/4);
+  TCPH_FLAGS_SET(tcphdr, headerflags);
+  tcphdr->wnd   = htons(TCP_WND);
+
+  /* copy data */
+  memcpy((char*)tcphdr + sizeof(struct tcp_hdr), data, data_len);
+
+  /* calculate checksum */
+
+  tcphdr->chksum = inet_chksum_pseudo(p, src_ip, dst_ip,
+          IP_PROTO_TCP, p->tot_len);
+
+  pbuf_header(p, sizeof(struct ip_hdr));
+
+  return p;
+}
+
+/** Safely bring a tcp_pcb into the requested state */
+void
+tcp_set_state(struct tcp_pcb* pcb, enum tcp_state state, ip_addr_t* local_ip,
+                   ip_addr_t* remote_ip, u16_t local_port, u16_t remote_port)
+{
+  /* @todo: are these all states? */
+  /* @todo: remove from previous list */
+  pcb->state = state;
+  if (state == ESTABLISHED) {
+    TCP_REG(&tcp_active_pcbs, pcb);
+    pcb->local_ip.addr = local_ip->addr;
+    pcb->local_port = local_port;
+    pcb->remote_ip.addr = remote_ip->addr;
+    pcb->remote_port = remote_port;
+  } else if(state == LISTEN) {
+    TCP_REG(&tcp_listen_pcbs.pcbs, pcb);
+    pcb->local_ip.addr = local_ip->addr;
+    pcb->local_port = local_port;
+  } else if(state == TIME_WAIT) {
+    TCP_REG(&tcp_tw_pcbs, pcb);
+    pcb->local_ip.addr = local_ip->addr;
+    pcb->local_port = local_port;
+    pcb->remote_ip.addr = remote_ip->addr;
+    pcb->remote_port = remote_port;
+  } else {
+    fail();
+  }
+}
+
+void
+test_tcp_counters_err(void* arg, err_t err)
+{
+  struct test_tcp_counters* counters = arg;
+  EXPECT_RET(arg != NULL);
+  counters->err_calls++;
+  counters->last_err = err;
+}
+
+static void
+test_tcp_counters_check_rxdata(struct test_tcp_counters* counters, struct pbuf* p)
+{
+  struct pbuf* q;
+  u32_t i, received;
+  if(counters->expected_data == NULL) {
+    /* no data to compare */
+    return;
+  }
+  EXPECT_RET(counters->recved_bytes + p->tot_len <= counters->expected_data_len);
+  received = counters->recved_bytes;
+  for(q = p; q != NULL; q = q->next) {
+    char *data = q->payload;
+    for(i = 0; i < q->len; i++) {
+      EXPECT_RET(data[i] == counters->expected_data[received]);
+      received++;
+    }
+  }
+  EXPECT(received == counters->recved_bytes + p->tot_len);
+}
+
+err_t
+test_tcp_counters_recv(void* arg, struct tcp_pcb* pcb, struct pbuf* p, err_t err)
+{
+  struct test_tcp_counters* counters = arg;
+  EXPECT_RETX(arg != NULL, ERR_OK);
+  EXPECT_RETX(pcb != NULL, ERR_OK);
+  EXPECT_RETX(err == ERR_OK, ERR_OK);
+
+  if (p != NULL) {
+    if (counters->close_calls == 0) {
+      counters->recv_calls++;
+      test_tcp_counters_check_rxdata(counters, p);
+      counters->recved_bytes += p->tot_len;
+    } else {
+      counters->recv_calls_after_close++;
+      counters->recved_bytes_after_close += p->tot_len;
+    }
+    pbuf_free(p);
+  } else {
+    counters->close_calls++;
+  }
+  EXPECT(counters->recv_calls_after_close == 0 && counters->recved_bytes_after_close == 0);
+  return ERR_OK;
+}
+
+/** Allocate a pcb and set up the test_tcp_counters_* callbacks */
+struct tcp_pcb*
+test_tcp_new_counters_pcb(struct test_tcp_counters* counters)
+{
+  struct tcp_pcb* pcb = tcp_new();
+  if (pcb != NULL) {
+    /* set up args and callbacks */
+    tcp_arg(pcb, counters);
+    tcp_recv(pcb, test_tcp_counters_recv);
+    tcp_err(pcb, test_tcp_counters_err);
+    pcb->snd_wnd = TCP_WND;
+  }
+  return pcb;
+}
+
+/** Calls tcp_input() after adjusting current_iphdr_dest */
+void test_tcp_input(struct pbuf *p, struct netif *inp)
+{
+  struct ip_hdr *iphdr = (struct ip_hdr*)p->payload;
+  ip_addr_copy(current_iphdr_dest, iphdr->dest);
+  ip_addr_copy(current_iphdr_src, iphdr->src);
+  current_netif = inp;
+  current_header = iphdr;
+
+  tcp_input(p, inp);
+
+  current_iphdr_dest.addr = 0;
+  current_iphdr_src.addr = 0;
+  current_netif = NULL;
+  current_header = NULL;
+}
+
+static err_t test_tcp_netif_output(struct netif *netif, struct pbuf *p,
+       ip_addr_t *ipaddr)
+{
+  struct test_tcp_txcounters *txcounters = (struct test_tcp_txcounters*)netif->state;
+  LWIP_UNUSED_ARG(ipaddr);
+  txcounters->num_tx_calls++;
+  txcounters->num_tx_bytes += p->tot_len;
+  /*if (txcounters->tx_packets == NULL) {
+    txcounters->tx_packets = p;
+  } else {
+    pbuf_cat(txcounters->tx_packets, p);
+  }*/
+  return ERR_OK;
+}
+
+void test_tcp_init_netif(struct netif *netif, struct test_tcp_txcounters *txcounters,
+                         ip_addr_t *ip_addr, ip_addr_t *netmask)
+{
+  struct netif *n;
+  memset(netif, 0, sizeof(struct netif));
+  memset(txcounters, 0, sizeof(struct test_tcp_txcounters));
+  netif->output = test_tcp_netif_output;
+  netif->state = txcounters;
+  netif->flags |= NETIF_FLAG_UP;
+  ip_addr_copy(netif->netmask, *netmask);
+  ip_addr_copy(netif->ip_addr, *ip_addr);
+  for (n = netif_list; n != NULL; n = n->next) {
+    if (n == netif) {
+      return;
+    }
+  }
+  netif->next = NULL;
+  netif_list = netif;
+}
diff --git a/code/train/C/0134126_ipaugenblick_main_tcp_listener_with_select.c b/code/train/C/0134126_ipaugenblick_main_tcp_listener_with_select.c
new file mode 100644
index 0000000000000000000000000000000000000000..ae72b93d3ffb1a6bf95b3d27271736aa5c2a09aa
--- /dev/null
+++ b/code/train/C/0134126_ipaugenblick_main_tcp_listener_with_select.c
@@ -0,0 +1,155 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/errno.h>
+#include <sys/types.h>          /* See NOTES */
+#include <sys/socket.h>
+#include <ipaugenblick_api.h>
+#include <string.h>
+
+#define USE_TX 1
+#define LISTENERS_COUNT 2
+#define LISTENERS_BASE 7777
+
+static inline int is_listener(int sock, int *listeners)
+{
+    int i;
+
+    for(i = 0;i < LISTENERS_COUNT;i++)
+        if(listeners[i] == sock)
+	    return 1;
+    return 0;
+}
+
+int main(int argc,char **argv)
+{
+    void *txbuff,*rxbuff,*pdesc;
+    int sock,newsock,len,listeners[LISTENERS_COUNT];
+    int listeners_idx;
+    char *p;
+    int size = 0,ringset_idx;
+    int sockets_connected = 0;
+    int selector;
+    int ready_socket;
+    int i,tx_space = 0;
+    int max_total_length = 0;
+    unsigned short mask;
+    unsigned long received_count = 0;
+
+    if(ipaugenblick_app_init(argc,argv,"tcp_listener") != 0) {
+        printf("cannot initialize memory\n");
+        return 0;
+    } 
+    printf("memory initialized\n");
+    selector = ipaugenblick_open_select();
+    if(selector != -1) {
+        printf("selector opened\n");
+    }
+    for(listeners_idx = 0;listeners_idx < LISTENERS_COUNT;listeners_idx++) {
+	    if((sock = ipaugenblick_open_socket(AF_INET,SOCK_STREAM,selector)) < 0) {
+        	printf("cannot open tcp client socket\n");
+	        return 0;
+    	}
+    	ipaugenblick_v4_connect_bind_socket(sock,inet_addr("192.168.150.63"),LISTENERS_BASE + listeners_idx,0);
+
+    	ipaugenblick_listen_socket(sock);
+    	listeners[listeners_idx] = sock;
+        int bufsize = 1024*1024*1000;
+	ipaugenblick_setsockopt(sock, SOL_SOCKET,SO_SNDBUFFORCE,(char *)&bufsize,sizeof(bufsize));
+        ipaugenblick_setsockopt(sock, SOL_SOCKET,SO_RCVBUFFORCE,(char *)&bufsize,sizeof(bufsize));
+    }
+    
+    //    ipaugenblick_set_socket_select(sock,selector);
+    while(1) {
+	mask = 0;
+        ready_socket = ipaugenblick_select(selector,&mask, NULL);
+        if(ready_socket == -1) {
+            continue;
+        }
+        if(is_listener(ready_socket,listeners)) {
+	    unsigned int ipaddr;
+	    unsigned short port;
+            while((newsock = ipaugenblick_accept(ready_socket,&ipaddr,&port)) != -1) {
+                printf("socket accepted %d %d %x %d\n",newsock,selector,ipaddr,port);
+                ipaugenblick_set_socket_select(newsock,selector);
+                sockets_connected++;
+            }
+            continue;
+        }
+        if(sockets_connected == 0) {
+            continue;
+        }
+	
+        if(mask & /*SOCKET_READABLE_BIT*/0x1) {
+	    int first_seg_len = 0;
+	    len = /*1024*/0;
+            while(ipaugenblick_receive(ready_socket,&rxbuff,&len,&first_seg_len,&pdesc) == 0) {
+                received_count++;
+                if(len > max_total_length)
+                    max_total_length = len;
+                void *porigdesc = pdesc;
+#if 0
+                while(rxbuff) {
+                    
+                    rxbuff = ipaugenblick_get_next_buffer_segment(&pdesc,&len);
+                    if((rxbuff)&&(len > 0)) {
+                        /* do something */
+                        /* don't release buf, release rxbuff */
+                    }
+                }
+#endif
+                if(!(received_count%10000000)) {
+                    printf("received %u max_total_len %u\n",received_count,max_total_length);
+                }
+                ipaugenblick_release_rx_buffer(porigdesc,ready_socket);
+            }
+        }
+#if USE_TX
+        if(mask & /*SOCKET_WRITABLE_BIT*/0x2) {
+            tx_space = ipaugenblick_get_socket_tx_space(ready_socket);
+#if 0
+            for(i = 0;i < tx_space;i++) {
+                buff = ipaugenblick_get_buffer(1448,ready_socket,&pdesc);
+                if(!buff) {
+                    break;
+                }
+                if(ipaugenblick_send(ready_socket,pdesc,0,1448)) { 
+                    ipaugenblick_release_tx_buffer(pdesc);
+                    break;
+                }
+            }
+	    if(tx_space == 0)
+		continue;
+#else
+	    if(tx_space == 0)
+		continue;
+	    struct data_and_descriptor bulk_bufs[tx_space];
+            int offsets[tx_space];
+            int lengths[tx_space];
+	    if(!ipaugenblick_get_buffers_bulk(1448,ready_socket,tx_space,bulk_bufs)) {
+                    for(i = 0;i < tx_space;i++) {
+                        offsets[i] = 0;
+                        lengths[i] = 1448;
+                    }
+                    if(ipaugenblick_send_bulk(ready_socket,bulk_bufs,offsets,lengths,tx_space)) {
+			for(i = 0;i < tx_space;i++)
+                        	ipaugenblick_release_tx_buffer(bulk_bufs[i].pdesc);
+                        printf("%s %d\n",__FILE__,__LINE__);
+                    }
+                    else {
+//                        printf("%s %d %d\n",__FILE__,__LINE__,tx_space);
+//                        sent = 1;
+                    }
+            }
+#endif
+            ipaugenblick_socket_kick(ready_socket);
+        }  
+//        ipaugenblick_socket_kick(ready_socket);
+#endif
+    }
+    return 0;
+}
diff --git a/code/train/C/0134346_MulTimeTest.c b/code/train/C/0134346_MulTimeTest.c
new file mode 100644
index 0000000000000000000000000000000000000000..f20e106d3977f8d01c023e0e5df3c43366611ed3
--- /dev/null
+++ b/code/train/C/0134346_MulTimeTest.c
@@ -0,0 +1,159 @@
+
+#include <NTL/ZZ_pX.h>
+
+#include <stdio.h>
+
+NTL_CLIENT
+
+
+double clean_data(double *t)
+{
+   double x, y, z;
+   long i, ix, iy, n;
+
+   x = t[0]; ix = 0;
+   y = t[0]; iy = 0;
+
+   for (i = 1; i < 5; i++) {
+      if (t[i] < x) {
+         x = t[i];
+         ix = i;
+      }
+      if (t[i] > y) {
+         y = t[i];
+         iy = i;
+      }
+   }
+
+   z = 0; n = 0;
+   for (i = 0; i < 5; i++) {
+      if (i != ix && i != iy) z+= t[i], n++;
+   }
+
+   z = z/n;  
+
+   return z;
+}
+
+void print_flag()
+{
+
+#if defined(NTL_LONG_LONG)
+printf("LONG_LONG\n");
+#elif defined(NTL_AVOID_FLOAT)
+printf("AVOID_FLOAT\n");
+#else
+printf("DEFAULT\n");
+#endif
+
+}
+
+
+int main()
+{
+
+#ifdef NTL_LONG_LONG
+
+
+   if (sizeof(NTL_LL_TYPE) < 2*sizeof(long)) {
+      printf("999999999999999 ");
+      print_flag();
+      return 0;
+   }
+
+#endif
+
+   long i, k;
+
+   
+   k = 10*NTL_ZZ_NBITS;
+
+   for (i = 0; i < 10000; i++) {
+      ZZ a, b, c, d;
+      long da = RandomBnd(k);
+      long db = RandomBnd(k);
+      long dc = RandomBnd(k);
+      long dd = RandomBnd(k);
+      RandomLen(a, da);  RandomLen(b, db);  RandomLen(c, dc);  RandomLen(d, dd);
+
+      if ((a + b)*(c + d) != c*a + d*a + c*b + d*b) {
+	 printf("999999999999999 ");
+	 print_flag();
+	 return 0;
+      }
+   }
+
+   
+
+   for (i = 0; i < 10000; i++) {
+      ZZ a, b, c;
+      
+      long da = RandomBnd(k);
+      long db = RandomBnd(k);
+      long dc = RandomBnd(k) + 2;
+      
+      RandomLen(a, da);  RandomLen(b, db);  RandomLen(c, dc); 
+
+      if ( ( a * b ) % c != ((a % c) * (b % c)) % c ) {
+	 printf("999999999999999 ");
+	 print_flag();
+	 return 0;
+      }
+   }
+
+   k = 1024;
+
+   ZZ x1, x2, x3;
+   double t;
+   long j;
+
+   RandomLen(x1, k);
+   RandomLen(x2, k);
+   
+
+   long iter;
+
+   mul(x3, x1, x2);
+
+   iter = 1;
+
+   do {
+     t = GetTime();
+     for (i = 0; i < iter; i++) {
+        for (j = 0; j < 500; j++) mul(x3, x1, x2);
+      }
+     t = GetTime() - t;
+     iter = 2*iter;
+   } while(t < 1);
+
+
+   iter = iter/2;
+   iter = long((2/t)*iter) + 1;
+
+   double tvec[5];
+   long w;
+
+   for (w = 0; w < 5; w++) {
+     t = GetTime();
+     for (i = 0; i < iter; i++) {
+        for (j = 0; j < 500; j++) mul(x3, x1, x2);
+      }
+     t = GetTime() - t;
+     tvec[w] = t;
+   }
+
+   t = clean_data(tvec);
+
+   t = floor((t/iter)*1e14);
+
+   if (t < 0 || t >= 1e15)
+      printf("999999999999999 ");
+   else
+      printf("%015.0f ", t);
+
+   printf(" [%ld] ", iter);
+
+   print_flag();
+
+   return 0;
+}
diff --git a/code/train/C/0134508_iptaccount.c b/code/train/C/0134508_iptaccount.c
new file mode 100644
index 0000000000000000000000000000000000000000..b60a0996badeee29d7e2f67e54219952b11053bd
--- /dev/null
+++ b/code/train/C/0134508_iptaccount.c
@@ -0,0 +1,230 @@
+/***************************************************************************
+ *   Copyright (C) 2004-2006 by Intra2net AG                               *
+ *   opensource@intra2net.com                                              *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU Lesser General Public License           *
+ *   version 2.1 as published by the Free Software Foundation;             *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <getopt.h>
+#include <signal.h>
+
+#include <arpa/inet.h>
+#include <linux/types.h>
+#include <libxt_ACCOUNT_cl.h>
+
+bool exit_now;
+static void sig_term(int signr)
+{
+	signal(SIGINT, SIG_IGN);
+	signal(SIGQUIT, SIG_IGN);
+	signal(SIGTERM, SIG_IGN);
+
+	exit_now = true;
+}
+
+static char *addr_to_dotted(unsigned int addr)
+{
+	static char buf[16];
+	const unsigned char *bytep;
+
+	addr = htonl(addr);
+	bytep = (const unsigned char *)&addr;
+	snprintf(buf, sizeof(buf), "%u.%u.%u.%u", bytep[0], bytep[1], bytep[2], bytep[3]);
+	return buf;
+}
+
+static void show_usage(void)
+{
+	printf("Unknown command line option. Try: [-u] [-h] [-a] [-f] [-c] [-s] [-l name]\n");
+	printf("[-u] show kernel handle usage\n");
+	printf("[-h] free all kernel handles (experts only!)\n\n");
+	printf("[-a] list all table names\n");
+	printf("[-l name] show data in table <name>\n");
+	printf("[-f] flush data after showing\n");
+	printf("[-c] loop every second (abort with CTRL+C)\n");
+	printf("[-s] CSV output (for spreadsheet import)\n");
+	printf("\n");
+}
+
+int main(int argc, char *argv[])
+{
+	struct ipt_ACCOUNT_context ctx;
+	struct ipt_acc_handle_ip *entry;
+	int i;
+	int optchar;
+	bool doHandleUsage = false, doHandleFree = false, doTableNames = false;
+	bool doFlush = false, doContinue = false, doCSV = false;
+
+	char *table_name = NULL;
+	const char *name;
+
+	printf("\nlibxt_ACCOUNT_cl userspace accounting tool v%s\n\n",
+	LIBXT_ACCOUNT_VERSION);
+
+	if (argc == 1)
+	{
+		show_usage();
+		exit(0);
+	}
+
+	while ((optchar = getopt(argc, argv, "uhacfsl:")) != -1)
+	{
+		switch (optchar)
+		{
+		case 'u':
+			doHandleUsage = true;
+			break;
+		case 'h':
+			doHandleFree = true;
+			break;
+		case 'a':
+			doTableNames = true;
+			break;
+		case 'f':
+			doFlush = true;
+			break;
+		case 'c':
+			doContinue = true;
+			break;
+		case 's':
+			doCSV = true;
+			break;
+		case 'l':
+			table_name = strdup(optarg);
+			break;
+		case '?':
+		default:
+			show_usage();
+			exit(0);
+			break;
+		}
+	}
+
+	// install exit handler
+	if (signal(SIGTERM, sig_term) == SIG_ERR)
+	{
+		printf("can't install signal handler for SIGTERM\n");
+		exit(-1);
+	}
+	if (signal(SIGINT, sig_term) == SIG_ERR)
+	{
+		printf("can't install signal handler for SIGINT\n");
+		exit(-1);
+	}
+	if (signal(SIGQUIT, sig_term) == SIG_ERR)
+	{
+		printf("can't install signal handler for SIGQUIT\n");
+		exit(-1);
+	}
+
+	if (ipt_ACCOUNT_init(&ctx))
+	{
+		printf("Init failed: %s\n", ctx.error_str);
+		exit(-1);
+	}
+
+	// Get handle usage?
+	if (doHandleUsage)
+	{
+		int rtn = ipt_ACCOUNT_get_handle_usage(&ctx);
+		if (rtn < 0)
+		{
+			printf("get_handle_usage failed: %s\n", ctx.error_str);
+			exit(-1);
+		}
+
+		printf("Current kernel handle usage: %d\n", ctx.handle.itemcount);
+	}
+
+	if (doHandleFree)
+	{
+		int rtn = ipt_ACCOUNT_free_all_handles(&ctx);
+		if (rtn < 0)
+		{
+			printf("handle_free_all failed: %s\n", ctx.error_str);
+			exit(-1);
+		}
+
+		printf("Freed all handles in kernel space\n");
+	}
+
+	if (doTableNames)
+	{
+		int rtn = ipt_ACCOUNT_get_table_names(&ctx);
+		if (rtn < 0)
+		{
+			printf("get_table_names failed: %s\n", ctx.error_str);
+			exit(-1);
+		}
+		while ((name = ipt_ACCOUNT_get_next_name(&ctx)) != 0)
+			printf("Found table: %s\n", name);
+	}
+
+	if (table_name)
+	{
+		// Read out data
+		if (doCSV)
+			printf("IP;SRC packets;SRC bytes;DST packets;DST bytes\n");
+		else
+			printf("Showing table: %s\n", table_name);
+
+		i = 0;
+		while (!exit_now)
+		{
+			// Get entries from table test
+			if (ipt_ACCOUNT_read_entries(&ctx, table_name, !doFlush))
+			{
+				printf("Read failed: %s\n", ctx.error_str);
+				ipt_ACCOUNT_deinit(&ctx);
+				return EXIT_FAILURE;
+			}
+
+			if (!doCSV)
+				printf("Run #%d - %u %s found\n", i, ctx.handle.itemcount,
+				       ctx.handle.itemcount == 1 ? "item" : "items");
+
+			// Output and free entries
+			while ((entry = ipt_ACCOUNT_get_next_entry(&ctx)) != NULL)
+			{
+				if (doCSV)
+					printf("%s;%llu;%llu;%llu;%llu\n",
+					       addr_to_dotted(entry->ip),
+					       (unsigned long long)entry->src_packets,
+					       (unsigned long long)entry->src_bytes,
+					       (unsigned long long)entry->dst_packets,
+					       (unsigned long long)entry->dst_bytes);
+				else
+					printf("IP: %s SRC packets: %llu bytes: %llu DST packets: %llu bytes: %llu\n",
+					       addr_to_dotted(entry->ip),
+					       (unsigned long long)entry->src_packets,
+					       (unsigned long long)entry->src_bytes,
+					       (unsigned long long)entry->dst_packets,
+					       (unsigned long long)entry->dst_bytes);
+			}
+
+			if (doContinue)
+			{
+				sleep(1);
+				i++;
+			} else
+				exit_now = true;
+		}
+	}
+
+	printf("Finished.\n");
+	ipt_ACCOUNT_deinit(&ctx);
+	return EXIT_SUCCESS;
+}
diff --git a/code/train/C/0134517_rx.c b/code/train/C/0134517_rx.c
new file mode 100644
index 0000000000000000000000000000000000000000..cff5a627bacf45b05324a9a3b5144b1a3d705d90
--- /dev/null
+++ b/code/train/C/0134517_rx.c
@@ -0,0 +1,303 @@
+/* vi: set sw=4 ts=4: */
+/*-------------------------------------------------------------------------
+ * Filename:      xmodem.c
+ * Version:       $Id: rx.c,v 1.2 2004/03/15 08:28:46 andersen Exp $
+ * Copyright:     Copyright (C) 2001, Hewlett-Packard Company
+ * Author:        Christopher Hoover <ch@hpl.hp.com>
+ * Description:   xmodem functionality for uploading of kernels
+ *                and the like
+ * Created at:    Thu Dec 20 01:58:08 PST 2001
+ *-----------------------------------------------------------------------*/
+/*
+ * xmodem.c: xmodem functionality for uploading of kernels and
+ *            the like
+ *
+ * Copyright (C) 2001 Hewlett-Packard Laboratories
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ *
+ * This was originally written for blob and then adapted for busybox.
+ *
+ */
+
+#include "busybox.h"
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <termios.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+
+
+#define SOH 0x01
+#define STX 0x02
+#define EOT 0x04
+#define ACK 0x06
+#define NAK 0x15
+#define BS  0x08
+
+/*
+
+Cf:
+
+  http://www.textfiles.com/apple/xmodem
+  http://www.phys.washington.edu/~belonis/xmodem/docxmodem.txt
+  http://www.phys.washington.edu/~belonis/xmodem/docymodem.txt
+  http://www.phys.washington.edu/~belonis/xmodem/modmprot.col
+
+*/
+
+#define TIMEOUT 1
+#define TIMEOUT_LONG 10
+#define MAXERRORS 10
+
+static int read_byte(int fd, unsigned int timeout) {
+	char buf[1];
+	int n;
+
+	alarm(timeout);
+
+	n = read(fd, &buf, 1);
+
+	alarm(0);
+
+	if (n == 1)
+		return buf[0] & 0xff;
+	else
+		return -1;
+}
+
+static int receive(char *error_buf, size_t error_buf_size,
+				   int ttyfd, int filefd)
+{
+	char blockBuf[1024];
+	unsigned int errors = 0;
+	unsigned int wantBlockNo = 1;
+	unsigned int length = 0;
+	int docrc = 1;
+	char nak = 'C';
+	unsigned int timeout = TIMEOUT_LONG;
+
+#define note_error(fmt,args...) \
+	snprintf(error_buf, error_buf_size, fmt,##args)
+
+	/* Flush pending input */
+	tcflush(ttyfd, TCIFLUSH);
+
+	/* Ask for CRC; if we get errors, we will go with checksum */
+	write(ttyfd, &nak, 1);
+
+	for (;;) {
+		int blockBegin;
+		int blockNo, blockNoOnesCompl;
+		int blockLength;
+		int cksum = 0;
+		int crcHi = 0;
+		int crcLo = 0;
+
+		blockBegin = read_byte(ttyfd, timeout);
+		if (blockBegin < 0)
+			goto timeout;
+
+		timeout = TIMEOUT;
+		nak = NAK;
+
+		switch (blockBegin) {
+		case SOH:
+		case STX:
+			break;
+
+		case EOT:
+			nak = ACK;
+			write(ttyfd, &nak, 1);
+			goto done;
+
+		default:
+			goto error;
+		}
+
+		/* block no */
+		blockNo = read_byte(ttyfd, TIMEOUT);
+		if (blockNo < 0)
+			goto timeout;
+
+		/* block no one's compliment */
+		blockNoOnesCompl = read_byte(ttyfd, TIMEOUT);
+		if (blockNoOnesCompl < 0)
+			goto timeout;
+
+		if (blockNo != (255 - blockNoOnesCompl)) {
+			note_error("bad block ones compl");
+			goto error;
+		}
+
+		blockLength = (blockBegin == SOH) ? 128 : 1024;
+
+		{
+			int i;
+
+			for (i = 0; i < blockLength; i++) {
+				int cc = read_byte(ttyfd, TIMEOUT);
+				if (cc < 0)
+					goto timeout;
+				blockBuf[i] = cc;
+			}
+		}
+
+		if (docrc) {
+			crcHi = read_byte(ttyfd, TIMEOUT);
+			if (crcHi < 0)
+				goto timeout;
+
+			crcLo = read_byte(ttyfd, TIMEOUT);
+			if (crcLo < 0)
+				goto timeout;
+		} else {
+			cksum = read_byte(ttyfd, TIMEOUT);
+			if (cksum < 0)
+				goto timeout;
+		}
+
+		if (blockNo == ((wantBlockNo - 1) & 0xff)) {
+			/* a repeat of the last block is ok, just ignore it. */
+			/* this also ignores the initial block 0 which is */
+			/* meta data. */
+			goto next;
+		} else if (blockNo != (wantBlockNo & 0xff)) {
+			note_error("unexpected block no, 0x%08x, expecting 0x%08x", blockNo, wantBlockNo);
+			goto error;
+		}
+
+		if (docrc) {
+			int crc = 0;
+			int i, j;
+			int expectedCrcHi;
+			int expectedCrcLo;
+
+			for (i = 0; i < blockLength; i++) {
+				crc = crc ^ (int) blockBuf[i] << 8;
+				for (j = 0; j < 8; j++)
+					if (crc & 0x8000)
+						crc = crc << 1 ^ 0x1021;
+					else
+						crc = crc << 1;
+			}
+
+			expectedCrcHi = (crc >> 8) & 0xff;
+			expectedCrcLo = crc & 0xff;
+
+			if ((crcHi != expectedCrcHi) ||
+			    (crcLo != expectedCrcLo)) {
+				note_error("crc error, expected 0x%02x 0x%02x, got 0x%02x 0x%02x", expectedCrcHi, expectedCrcLo, crcHi, crcLo);
+				goto error;
+			}
+		} else {
+			unsigned char expectedCksum = 0;
+			int i;
+
+			for (i = 0; i < blockLength; i++)
+				expectedCksum += blockBuf[i];
+
+			if (cksum != expectedCksum) {
+				note_error("checksum error, expected 0x%02x, got 0x%02x", expectedCksum, cksum);
+				goto error;
+			}
+		}
+
+		wantBlockNo++;
+		length += blockLength;
+
+		if (bb_full_write(filefd, blockBuf, blockLength) < 0) {
+			note_error("write to file failed: %m");
+			goto fatal;
+		}
+
+	next:
+		errors = 0;
+		nak = ACK;
+		write(ttyfd, &nak, 1);
+		continue;
+
+	error:
+	timeout:
+		errors++;
+		if (errors == MAXERRORS) {
+			/* Abort */
+
+			// if using crc, try again w/o crc
+			if (nak == 'C') {
+				nak = NAK;
+				errors = 0;
+				docrc = 0;
+				goto timeout;
+			}
+
+			note_error("too many errors; giving up");
+
+		fatal:
+			/* 5 CAN followed by 5 BS */
+			write(ttyfd, "\030\030\030\030\030\010\010\010\010\010", 10);
+			return -1;
+		}
+
+		/* Flush pending input */
+		tcflush(ttyfd, TCIFLUSH);
+
+		write(ttyfd, &nak, 1);
+	}
+
+ done:
+	return length;
+
+#undef note_error
+}
+
+static void sigalrm_handler(int ATTRIBUTE_UNUSED signum)
+{
+}
+
+int rx_main(int argc, char **argv)
+{
+	char *fn;
+	int ttyfd, filefd;
+	struct termios tty, orig_tty;
+	struct sigaction act;
+	int n;
+	char error_buf[256];
+
+	if (argc != 2)
+			bb_show_usage();
+
+	fn = argv[1];
+	ttyfd = bb_xopen3(CURRENT_TTY, O_RDWR, 0);
+	filefd = bb_xopen3(fn, O_RDWR|O_CREAT|O_TRUNC, 0666);
+
+	if (tcgetattr(ttyfd, &tty) < 0)
+			bb_error_msg_and_die("%s: tcgetattr failed: %m\n", argv[0]);
+
+	orig_tty = tty;
+
+	cfmakeraw(&tty);
+	tcsetattr(ttyfd, TCSAFLUSH, &tty);
+
+	memset(&act, 0, sizeof(act));
+	act.sa_handler = sigalrm_handler;
+	sigaction(SIGALRM, &act, 0);
+
+	n = receive(error_buf, sizeof(error_buf), ttyfd, filefd);
+
+	close(filefd);
+
+	tcsetattr(ttyfd, TCSAFLUSH, &orig_tty);
+
+	if (n < 0)
+			bb_error_msg_and_die("\n%s: receive failed:\n  %s\n",
+							   argv[0], error_buf);
+
+	bb_fflush_stdout_and_exit(EXIT_SUCCESS);
+}
diff --git a/code/train/C/0134563_trampoline.c b/code/train/C/0134563_trampoline.c
new file mode 100644
index 0000000000000000000000000000000000000000..8e59c3f30b19cbd8a558c497510884505fb3aa01
--- /dev/null
+++ b/code/train/C/0134563_trampoline.c
@@ -0,0 +1,305 @@
+/*
+ *  MinHook - The Minimalistic API Hooking Library for x64/x86
+ *  Copyright (C) 2009-2015 Tsuda Kageyu.
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *   2. 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.
+ *
+ *  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 HOLDER
+ *  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.
+ */
+
+#include <Windows.h>
+#include <intrin.h>
+
+#ifdef _M_X64
+    #include "./hde/hde64.h"
+    typedef hde64s HDE;
+    #define HDE_DISASM(code, hs) hde64_disasm(code, hs)
+#else
+    #include "./hde/hde32.h"
+    typedef hde32s HDE;
+    #define HDE_DISASM(code, hs) hde32_disasm(code, hs)
+#endif
+
+#include "trampoline.h"
+#include "buffer.h"
+
+// Maximum size of a trampoline function.
+#ifdef _M_X64
+    #define TRAMPOLINE_MAX_SIZE (MEMORY_SLOT_SIZE - sizeof(JMP_ABS))
+#else
+    #define TRAMPOLINE_MAX_SIZE MEMORY_SLOT_SIZE
+#endif
+
+//-------------------------------------------------------------------------
+static BOOL IsCodePadding(LPBYTE pInst, UINT size)
+{
+    UINT i;
+
+    if (pInst[0] != 0x00 && pInst[0] != 0x90 && pInst[0] != 0xCC)
+        return FALSE;
+
+    for (i = 1; i < size; ++i)
+    {
+        if (pInst[i] != pInst[0])
+            return FALSE;
+    }
+    return TRUE;
+}
+
+//-------------------------------------------------------------------------
+BOOL CreateTrampolineFunction(PTRAMPOLINE ct)
+{
+#ifdef _M_X64
+    CALL_ABS call = {
+        0xFF, 0x15, 0x00000002, // FF15 00000002: CALL [RIP+8]
+        0xEB, 0x08,             // EB 08:         JMP +10
+        0x0000000000000000ULL   // Absolute destination address
+    };
+    JMP_ABS jmp = {
+        0xFF, 0x25, 0x00000000, // FF25 00000000: JMP [RIP+6]
+        0x0000000000000000ULL   // Absolute destination address
+    };
+    JCC_ABS jcc = {
+        0x70, 0x0E,             // 7* 0E:         J** +16
+        0xFF, 0x25, 0x00000000, // FF25 00000000: JMP [RIP+6]
+        0x0000000000000000ULL   // Absolute destination address
+    };
+#else
+    CALL_REL call = {
+        0xE8,                   // E8 xxxxxxxx: CALL +5+xxxxxxxx
+        0x00000000              // Relative destination address
+    };
+    JMP_REL jmp = {
+        0xE9,                   // E9 xxxxxxxx: JMP +5+xxxxxxxx
+        0x00000000              // Relative destination address
+    };
+    JCC_REL jcc = {
+        0x0F, 0x80,             // 0F8* xxxxxxxx: J** +6+xxxxxxxx
+        0x00000000              // Relative destination address
+    };
+#endif
+
+    UINT8     oldPos   = 0;
+    UINT8     newPos   = 0;
+    ULONG_PTR jmpDest  = 0;     // Destination address of an internal jump.
+    BOOL      finished = FALSE; // Is the function completed?
+#ifdef _M_X64
+    UINT8     instBuf[16];
+#endif
+
+    ct->patchAbove = FALSE;
+    ct->nIP        = 0;
+
+    do
+    {
+        HDE       hs;
+        UINT      copySize;
+        LPVOID    pCopySrc;
+        ULONG_PTR pOldInst = (ULONG_PTR)ct->pTarget     + oldPos;
+        ULONG_PTR pNewInst = (ULONG_PTR)ct->pTrampoline + newPos;
+
+        copySize = HDE_DISASM((LPVOID)pOldInst, &hs);
+        if (hs.flags & F_ERROR)
+            return FALSE;
+
+        pCopySrc = (LPVOID)pOldInst;
+        if (oldPos >= sizeof(JMP_REL))
+        {
+            // The trampoline function is long enough.
+            // Complete the function with the jump to the target function.
+#ifdef _M_X64
+            jmp.address = pOldInst;
+#else
+            jmp.operand = (UINT32)(pOldInst - (pNewInst + sizeof(jmp)));
+#endif
+            pCopySrc = &jmp;
+            copySize = sizeof(jmp);
+
+            finished = TRUE;
+        }
+#ifdef _M_X64
+        else if ((hs.modrm & 0xC7) == 0x05)
+        {
+            // Instructions using RIP relative addressing. (ModR/M = 00???101B)
+
+            // Modify the RIP relative address.
+            PUINT32 pRelAddr;
+
+            // Avoid using memcpy to reduce the footprint.
+            __movsb(instBuf, (LPBYTE)pOldInst, copySize);
+            pCopySrc = instBuf;
+
+            // Relative address is stored at (instruction length - immediate value length - 4).
+            pRelAddr = (PUINT32)(instBuf + hs.len - ((hs.flags & 0x3C) >> 2) - 4);
+            *pRelAddr
+                = (UINT32)((pOldInst + hs.len + (INT32)hs.disp.disp32) - (pNewInst + hs.len));
+
+            // Complete the function if JMP (FF /4).
+            if (hs.opcode == 0xFF && hs.modrm_reg == 4)
+                finished = TRUE;
+        }
+#endif
+        else if (hs.opcode == 0xE8)
+        {
+            // Direct relative CALL
+            ULONG_PTR dest = pOldInst + hs.len + (INT32)hs.imm.imm32;
+#ifdef _M_X64
+            call.address = dest;
+#else
+            call.operand = (UINT32)(dest - (pNewInst + sizeof(call)));
+#endif
+            pCopySrc = &call;
+            copySize = sizeof(call);
+        }
+        else if ((hs.opcode & 0xFD) == 0xE9)
+        {
+            // Direct relative JMP (EB or E9)
+            ULONG_PTR dest = pOldInst + hs.len;
+
+            if (hs.opcode == 0xEB) // isShort jmp
+                dest += (INT8)hs.imm.imm8;
+            else
+                dest += (INT32)hs.imm.imm32;
+
+            // Simply copy an internal jump.
+            if ((ULONG_PTR)ct->pTarget <= dest
+                && dest < ((ULONG_PTR)ct->pTarget + sizeof(JMP_REL)))
+            {
+                if (jmpDest < dest)
+                    jmpDest = dest;
+            }
+            else
+            {
+#ifdef _M_X64
+                jmp.address = dest;
+#else
+                jmp.operand = (UINT32)(dest - (pNewInst + sizeof(jmp)));
+#endif
+                pCopySrc = &jmp;
+                copySize = sizeof(jmp);
+
+                // Exit the function If it is not in the branch
+                finished = (pOldInst >= jmpDest);
+            }
+        }
+        else if ((hs.opcode & 0xF0) == 0x70
+            || (hs.opcode & 0xFC) == 0xE0
+            || (hs.opcode2 & 0xF0) == 0x80)
+        {
+            // Direct relative Jcc
+            ULONG_PTR dest = pOldInst + hs.len;
+
+            if ((hs.opcode & 0xF0) == 0x70      // Jcc
+                || (hs.opcode & 0xFC) == 0xE0)  // LOOPNZ/LOOPZ/LOOP/JECXZ
+                dest += (INT8)hs.imm.imm8;
+            else
+                dest += (INT32)hs.imm.imm32;
+
+            // Simply copy an internal jump.
+            if ((ULONG_PTR)ct->pTarget <= dest
+                && dest < ((ULONG_PTR)ct->pTarget + sizeof(JMP_REL)))
+            {
+                if (jmpDest < dest)
+                    jmpDest = dest;
+            }
+            else if ((hs.opcode & 0xFC) == 0xE0)
+            {
+                // LOOPNZ/LOOPZ/LOOP/JCXZ/JECXZ to the outside are not supported.
+                return FALSE;
+            }
+            else
+            {
+                UINT8 cond = ((hs.opcode != 0x0F ? hs.opcode : hs.opcode2) & 0x0F);
+#ifdef _M_X64
+                // Invert the condition in x64 mode to simplify the conditional jump logic.
+                jcc.opcode  = 0x71 ^ cond;
+                jcc.address = dest;
+#else
+                jcc.opcode1 = 0x80 | cond;
+                jcc.operand = (UINT32)(dest - (pNewInst + sizeof(jcc)));
+#endif
+                pCopySrc = &jcc;
+                copySize = sizeof(jcc);
+            }
+        }
+        else if ((hs.opcode & 0xFE) == 0xC2)
+        {
+            // RET (C2 or C3)
+
+            // Complete the function if not in a branch.
+            finished = (pOldInst >= jmpDest);
+        }
+
+        // Can't alter the instruction length in a branch.
+        if (pOldInst < jmpDest && copySize != hs.len)
+            return FALSE;
+
+        // Trampoline function is too large.
+        if ((newPos + copySize) > TRAMPOLINE_MAX_SIZE)
+            return FALSE;
+
+        // Trampoline function has too many instructions.
+        if (ct->nIP >= ARRAYSIZE(ct->oldIPs))
+            return FALSE;
+
+        ct->oldIPs[ct->nIP] = oldPos;
+        ct->newIPs[ct->nIP] = newPos;
+        ct->nIP++;
+
+        // Avoid using memcpy to reduce the footprint.
+        __movsb((LPBYTE)ct->pTrampoline + newPos, pCopySrc, copySize);
+        newPos += copySize;
+        oldPos += hs.len;
+    }
+    while (!finished);
+
+    // Is there enough place for a long jump?
+    if (oldPos < sizeof(JMP_REL)
+        && !IsCodePadding((LPBYTE)ct->pTarget + oldPos, sizeof(JMP_REL) - oldPos))
+    {
+        // Is there enough place for a short jump?
+        if (oldPos < sizeof(JMP_REL_SHORT)
+            && !IsCodePadding((LPBYTE)ct->pTarget + oldPos, sizeof(JMP_REL_SHORT) - oldPos))
+        {
+            return FALSE;
+        }
+
+        // Can we place the long jump above the function?
+        if (!IsExecutableAddress((LPBYTE)ct->pTarget - sizeof(JMP_REL)))
+            return FALSE;
+
+        if (!IsCodePadding((LPBYTE)ct->pTarget - sizeof(JMP_REL), sizeof(JMP_REL)))
+            return FALSE;
+
+        ct->patchAbove = TRUE;
+    }
+
+#ifdef _M_X64
+    // Create a relay function.
+    jmp.address = (ULONG_PTR)ct->pDetour;
+
+    ct->pRelay = (LPBYTE)ct->pTrampoline + newPos;
+    memcpy(ct->pRelay, &jmp, sizeof(jmp));
+#endif
+
+    return TRUE;
+}
diff --git a/code/train/C/0134778_crypto.c b/code/train/C/0134778_crypto.c
new file mode 100644
index 0000000000000000000000000000000000000000..e40f56e474118befc34aedd284ef6f21a89d11e8
--- /dev/null
+++ b/code/train/C/0134778_crypto.c
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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/>.
+ */
+
+/*
+ * crypto.c - Cryptography support
+ */
+#include "crypto.h"
+#include "parse.h"
+#include "nvaes_ref.h"
+#include <stdio.h>
+
+/* Local function declarations */
+static void
+apply_cbc_chain_data(u_int8_t *cbc_chain_data,
+			u_int8_t *src,
+			u_int8_t *dst);
+
+static void
+generate_key_schedule(u_int8_t *key, u_int8_t *key_schedule);
+
+static void
+encrypt_object( u_int8_t	*key_schedule,
+		u_int8_t	*src,
+		u_int8_t	*dst,
+		u_int32_t	num_aes_blocks);
+
+static int
+encrypt_and_sign(u_int8_t		*key,
+		 u_int8_t		*src,
+		 u_int32_t		length,
+		 u_int8_t		*sig_dst);
+
+u_int8_t enable_debug_crypto = 0;
+
+/* Implementation */
+static u_int8_t zero_key[16] = { 0, 0, 0, 0, 0, 0, 0, 0,
+				0, 0, 0, 0, 0, 0, 0, 0 };
+
+static void
+print_vector(char *name, u_int32_t num_bytes, u_int8_t *data)
+{
+	u_int32_t i;
+
+	printf("%s [%d] @%p", name, num_bytes, data);
+	for (i=0; i<num_bytes; i++) {
+		if ( i % 16 == 0 )
+			printf(" = ");
+		printf("%02x", data[i]);
+		if ( (i+1) % 16 != 0 )
+			printf(" ");
+	}
+	printf("\n");
+}
+
+
+static void
+apply_cbc_chain_data(u_int8_t *cbc_chain_data,
+			u_int8_t *src,
+			u_int8_t *dst)
+{
+	int i;
+
+	for (i = 0; i < 16; i++) {
+		*dst++ = *src++ ^ *cbc_chain_data++;
+	}
+}
+
+static void
+generate_key_schedule(u_int8_t *key, u_int8_t *key_schedule)
+{
+	/*
+	 * The only need for a key is for signing/checksum purposes, so
+	 * expand a key of 0's.
+	 */
+	nv_aes_expand_key(zero_key, key_schedule);
+}
+
+static void
+encrypt_object(u_int8_t	*key_schedule,
+		u_int8_t	*src,
+		u_int8_t	*dst,
+		u_int32_t	num_aes_blocks)
+{
+	u_int32_t i;
+	u_int8_t *cbc_chain_data;
+	u_int8_t  tmp_data[KEY_LENGTH];
+
+	cbc_chain_data = zero_key; /* Convenient array of 0's for IV */
+
+	for (i = 0; i < num_aes_blocks; i++) {
+		if (enable_debug_crypto) {
+			printf("encrypt_object: block %d of %d\n", i,
+							num_aes_blocks);
+			print_vector("AES Src", KEY_LENGTH, src);
+		}
+
+		/* Apply the chain data */
+		apply_cbc_chain_data(cbc_chain_data, src, tmp_data);
+
+		if (enable_debug_crypto)
+			print_vector("AES Xor", KEY_LENGTH,
+							tmp_data);
+
+		/* encrypt the AES block */
+		nv_aes_encrypt(tmp_data, key_schedule, dst);
+
+		if (enable_debug_crypto)
+			print_vector("AES Dst", KEY_LENGTH, dst);
+		/* Update pointers for next loop. */
+		cbc_chain_data = dst;
+		src += KEY_LENGTH;
+		dst += KEY_LENGTH;
+	}
+}
+
+static void
+left_shift_vector(u_int8_t *in,
+		  u_int8_t	*out,
+		  u_int32_t size)
+{
+	u_int32_t i;
+	u_int8_t carry = 0;
+
+	for (i=0; i<size; i++) {
+		u_int32_t j = size-1-i;
+
+		out[j] = (in[j] << 1) | carry;
+		carry = in[j] >> 7; /* get most significant bit */
+	}
+}
+
+static void
+sign_objext(
+	u_int8_t	*key,
+	u_int8_t	*key_schedule,
+	u_int8_t	*src,
+	u_int8_t	*dst,
+	u_int32_t	num_aes_blocks)
+{
+	u_int32_t i;
+	u_int8_t *cbc_chain_data;
+
+	u_int8_t	l[KEY_LENGTH];
+	u_int8_t	k1[KEY_LENGTH];
+	u_int8_t	tmp_data[KEY_LENGTH];
+
+	cbc_chain_data = zero_key; /* Convenient array of 0's for IV */
+
+	/* compute k1 constant needed by AES-CMAC calculation */
+
+	for (i=0; i<KEY_LENGTH; i++)
+		tmp_data[i] = 0;
+
+	encrypt_object(key_schedule, tmp_data, l, 1);
+
+	if (enable_debug_crypto)
+		print_vector("AES(key, nonce)", KEY_LENGTH, l);
+
+	left_shift_vector(l, k1, sizeof(l));
+
+	if (enable_debug_crypto)
+		print_vector("L", KEY_LENGTH, l);
+
+	if ( (l[0] >> 7) != 0 ) /* get MSB of L */
+		k1[KEY_LENGTH-1] ^= AES_CMAC_CONST_RB;
+
+	if (enable_debug_crypto)
+		print_vector("K1", KEY_LENGTH, k1);
+
+	/* compute the AES-CMAC value */
+	for (i = 0; i < num_aes_blocks; i++) {
+		/* Apply the chain data */
+		apply_cbc_chain_data(cbc_chain_data, src, tmp_data);
+
+		/* for the final block, XOR k1 into the IV */
+		if ( i == num_aes_blocks-1 )
+			apply_cbc_chain_data(tmp_data, k1, tmp_data);
+
+		/* encrypt the AES block */
+		nv_aes_encrypt(tmp_data, key_schedule, (u_int8_t*)dst);
+
+		if (enable_debug_crypto) {
+			printf("sign_objext: block %d of %d\n", i,
+							num_aes_blocks);
+			print_vector("AES-CMAC Src", KEY_LENGTH, src);
+			print_vector("AES-CMAC Xor", KEY_LENGTH, tmp_data);
+			print_vector("AES-CMAC Dst",
+				KEY_LENGTH,
+				(u_int8_t*)dst);
+		}
+
+		/* Update pointers for next loop. */
+		cbc_chain_data = (u_int8_t*)dst;
+		src += KEY_LENGTH;
+	}
+
+	if (enable_debug_crypto)
+		print_vector("AES-CMAC Hash", KEY_LENGTH, (u_int8_t*)dst);
+}
+
+static int
+encrypt_and_sign(u_int8_t		*key,
+		u_int8_t		*src,
+		u_int32_t		length,
+		u_int8_t		*sig_dst)
+{
+	u_int32_t	num_aes_blocks;
+	u_int8_t	key_schedule[4*NVAES_STATECOLS*(NVAES_ROUNDS+1)];
+
+	if (enable_debug_crypto) {
+		printf("encrypt_and_sign: length = %d\n", length);
+		print_vector("AES key", KEY_LENGTH, key);
+	}
+
+	generate_key_schedule(key, key_schedule);
+
+	num_aes_blocks = ICEIL(length, KEY_LENGTH);
+
+	if (enable_debug_crypto)
+		printf("encrypt_and_sign: begin signing\n");
+
+	/* encrypt the data, overwriting the result in signature. */
+	sign_objext(key, key_schedule, src, sig_dst, num_aes_blocks);
+
+	if (enable_debug_crypto)
+		printf("encrypt_and_sign: end signing\n");
+
+	return 0;
+}
+
+int
+sign_data_block(u_int8_t *source,
+		u_int32_t length,
+		u_int8_t *signature)
+{
+	return encrypt_and_sign(zero_key,
+				source,
+				length,
+				signature);
+}
+
+int
+sign_bct(build_image_context *context,
+		u_int8_t *bct)
+{
+	u_int32_t Offset;
+	u_int32_t length;
+	u_int32_t hash_size;
+	u_int8_t *hash_buffer = NULL;
+	int e = 0;
+
+	assert(bct != NULL);
+
+	if (g_soc_config->get_value(token_hash_size,
+					&hash_size,
+					bct) != 0)
+		return -ENODATA;
+	if (g_soc_config->get_value(token_crypto_offset,
+					&Offset,
+					bct) != 0)
+		return -ENODATA;
+	if (g_soc_config->get_value(token_crypto_length,
+					&length,
+					bct) != 0)
+		return -ENODATA;
+
+	hash_buffer = calloc(1, hash_size);
+	if (hash_buffer == NULL)
+		return -ENOMEM;
+	e = sign_data_block(bct + Offset, length, hash_buffer);
+	if (e != 0)
+		goto fail;
+	e = g_soc_config->set_data(token_crypto_hash,
+						hash_buffer,
+						hash_size,
+						bct);
+	if (e != 0)
+		goto fail;
+
+ fail:
+	free(hash_buffer);
+	return e;
+}
diff --git a/code/train/C/0134809_quicksort.c b/code/train/C/0134809_quicksort.c
new file mode 100644
index 0000000000000000000000000000000000000000..8567c3cae6ea229fdf5a921d5ee08e39cab391e1
--- /dev/null
+++ b/code/train/C/0134809_quicksort.c
@@ -0,0 +1,187 @@
+
+#include <inc/lib.h>
+uint32 ws_size_first=0;
+
+//Functions Declarations
+void Swap(int *Elements, int First, int Second);
+void InitializeAscending(int *Elements, int NumOfElements);
+void InitializeDescending(int *Elements, int NumOfElements);
+void InitializeSemiRandom(int *Elements, int NumOfElements);
+void PrintElements(int *Elements, int NumOfElements);
+
+void QuickSort(int *Elements, int NumOfElements);
+void QSort(int *Elements,int NumOfElements, int startIndex, int finalIndex);
+uint32 CheckSorted(int *Elements, int NumOfElements);
+
+void _main(void)
+{
+	char Chose ;
+	char Line[255] ;
+	int Iteration = 0 ;
+
+	do
+	{
+		int InitFreeFrames = sys_calculate_free_frames() + sys_calculate_modified_frames();
+
+		Iteration++ ;
+		//		cprintf("Free Frames Before Allocation = %d\n", sys_calculate_free_frames()) ;
+
+//	sys_disable_interrupt();
+
+			readline("Enter the number of elements: ", Line);
+			int NumOfElements = strtol(Line, NULL, 10) ;
+			int *Elements = malloc(sizeof(int) * NumOfElements) ;
+			cprintf("Choose the initialization method:\n") ;
+			cprintf("a) Ascending\n") ;
+			cprintf("b) Descending\n") ;
+			cprintf("c) Semi random\nSelect: ") ;
+			Chose = getchar() ;
+			cputchar(Chose);
+			cputchar('\n');
+		//sys_enable_interrupt();
+		int  i ;
+		switch (Chose)
+		{
+		case 'a':
+			InitializeAscending(Elements, NumOfElements);
+			break ;
+		case 'b':
+			InitializeDescending(Elements, NumOfElements);
+			break ;
+		case 'c':
+			InitializeSemiRandom(Elements, NumOfElements);
+			break ;
+		default:
+			InitializeSemiRandom(Elements, NumOfElements);
+		}
+
+		QuickSort(Elements, NumOfElements);
+
+		//		PrintElements(Elements, NumOfElements);
+
+		uint32 Sorted = CheckSorted(Elements, NumOfElements);
+
+		if(Sorted == 0) panic("The array is NOT sorted correctly") ;
+		else
+		{ 
+				cprintf("\n===============================================\n") ;
+				cprintf("Congratulations!! The array is sorted correctly\n") ;
+				cprintf("===============================================\n\n") ;
+		}
+
+		//		cprintf("Free Frames After Calculation = %d\n", sys_calculate_free_frames()) ;
+
+			cprintf("Freeing the Heap...\n\n") ;
+
+		//freeHeap() ;
+
+		///========================================================================
+	//sys_disable_interrupt();
+			cprintf("Do you want to repeat (y/n): ") ;
+			Chose = getchar() ;
+			cputchar(Chose);
+			cputchar('\n');
+			cputchar('\n');
+	//sys_enable_interrupt();
+
+	} while (Chose == 'y');
+}
+
+///Quick sort 
+void QuickSort(int *Elements, int NumOfElements)
+{
+	QSort(Elements, NumOfElements, 0, NumOfElements-1) ;
+}
+
+
+void QSort(int *Elements,int NumOfElements, int startIndex, int finalIndex)
+{
+	if (startIndex >= finalIndex) return;
+
+	int i = startIndex+1, j = finalIndex;
+
+	while (i <= j)
+	{
+		while (i <= finalIndex && Elements[startIndex] >= Elements[i]) i++;
+		while (j > startIndex && Elements[startIndex] <= Elements[j]) j--;
+
+		if (i <= j)
+		{
+			Swap(Elements, i, j);
+		}
+	}
+
+	Swap( Elements, startIndex, j);
+
+	QSort(Elements, NumOfElements, startIndex, j - 1);
+	QSort(Elements, NumOfElements, i, finalIndex);
+}
+
+uint32 CheckSorted(int *Elements, int NumOfElements)
+{
+	uint32 Sorted = 1 ;
+	int i ;
+	for (i = 0 ; i < NumOfElements - 1; i++)
+	{
+		if (Elements[i] > Elements[i+1])
+		{
+			Sorted = 0 ;
+			break;
+		}
+	}
+	return Sorted ;
+}
+
+///Private Functions
+
+
+void Swap(int *Elements, int First, int Second)
+{
+	int Tmp = Elements[First] ;
+	Elements[First] = Elements[Second] ;
+	Elements[Second] = Tmp ;
+}
+
+void InitializeAscending(int *Elements, int NumOfElements)
+{
+	int i ;
+	for (i = 0 ; i < NumOfElements ; i++)
+	{
+		(Elements)[i] = i ;
+	}
+
+}
+
+void InitializeDescending(int *Elements, int NumOfElements)
+{
+	int i ;
+	for (i = 0 ; i < NumOfElements ; i++)
+	{
+		Elements[i] = NumOfElements - i - 1 ;
+	}
+
+}
+
+void InitializeSemiRandom(int *Elements, int NumOfElements)
+{
+	int i ;
+	int Repetition = NumOfElements / 3 ;
+	for (i = 0 ; i < NumOfElements ; i++)
+	{
+		Elements[i] = i % Repetition ;
+	}
+
+}
+
+void PrintElements(int *Elements, int NumOfElements)
+{
+		int i ;
+		int NumsPerLine = 20 ;
+		for (i = 0 ; i < NumOfElements-1 ; i++)
+		{
+			if (i%NumsPerLine == 0)
+				cprintf("\n");
+			cprintf("%d, ",Elements[i]);
+		}
+		cprintf("%d\n",Elements[i]);
+}
diff --git a/code/train/C/0135036_SortingUtils.c b/code/train/C/0135036_SortingUtils.c
new file mode 100644
index 0000000000000000000000000000000000000000..e244d4f91a035ed3d327982e14a2b8d2baffa9ad
--- /dev/null
+++ b/code/train/C/0135036_SortingUtils.c
@@ -0,0 +1,177 @@
+#include "SortingUtils.h"
+
+// Just for code comprehension
+// This is a functional macro so it's undef'd at the end of this file
+// Last semicolon has been removed intentionally
+#define SU_SWAP(a, b) temp = a; a = b; b = temp
+
+/**
+ * Sorting a vector of pointers using bubble sort algorithm
+ *
+ * @param void **vector
+ * @param size_t length
+ * @param SortingComparison cmp
+ * @param void *data
+ *
+ * @return void ** the same vector
+ */
+void ** SortingUtils__bubbleSort(void **vector, size_t length, SortingComparison cmp, void *data) {
+	size_t i = 0,
+		j;
+	void *temp;
+
+	length--;
+
+	for ( ; i < length; i++ ) {
+		for ( j = 0; j < length - i; j++ ) {
+			if ( cmp(vector[j], vector[j + 1], data) > 0 ) {
+				SU_SWAP(vector[j], vector[j + 1]);
+			}
+		}
+	}
+
+	return vector;
+}
+
+/**
+ * Sorting a vector of pointers using select sort algorithm
+ *
+ * @param void **vector
+ * @param size_t length
+ * @param SortingComparison cmp
+ * @param void *data
+ *
+ * @return void ** the same vector
+ */
+void ** SortingUtils__selectSort(void **vector, size_t length, SortingComparison cmp, void *data) {
+	size_t i, j;
+	size_t lower_index;
+	void *temp;
+
+	for ( i = 1; i < length; i++) {
+		lower_index = i - 1;
+		for ( j = i; j < length; j++) {
+			if ( cmp(vector[j], vector[lower_index], data) < 0 ) {
+				lower_index = j;
+			}
+		}
+		SU_SWAP(vector[i - 1], vector[lower_index]);
+	}
+
+	return vector;
+}
+
+/**
+ * Sorting a vector of pointers using insert sort algorithm
+ *
+ * @param void **vector
+ * @param size_t length
+ * @param SortingComparison cmp
+ * @param void *data
+ *
+ * @return void ** the same vector
+ */
+void ** SortingUtils__insertSort(void **vector, size_t length, SortingComparison cmp, void *data) {
+	void *temp;
+	void *unsorted;
+	size_t i;
+	size_t j;
+
+	// Assume the first element is sorted, we'll swap later
+	for ( i = 1; i < length; i++ ) {
+		unsorted = vector[i];
+		j = i;
+		// We go to the left
+		while ( j-- ) {
+			// If the current element is smaller than the left one
+			// Move left element one position to the rigth
+			if ( cmp(unsorted, vector[j], data) < 0 ) {
+				SU_SWAP(vector[j], vector[j + 1]);
+			} else {
+				// Else we stop, we have to insert element on j + 1
+				break;
+			}
+		}
+
+		// insert the element in the last position where it 
+		vector[j + 1] = unsorted;
+	}
+
+	return vector;
+}
+
+/**
+ * Sorting a vector of pointers using quick sort algorithm
+ *
+ * @param void **vector
+ * @param size_t length
+ * @param SortingComparison cmp
+ * @param void *data
+ *
+ * @return void ** the same vector
+ */
+void ** SortingUtils__quickSort(void **vector, size_t length, SortingComparison cmp, void *data) {
+	void *temp;
+	size_t pivot_index = 0;
+	size_t store_index = 1; // store_index is the index of the first element which is greater than the pivot
+	size_t i;
+
+	if ( length == 1 ) {
+		return;
+	}
+
+	for ( i = 1; i < length; i++) {
+		if ( cmp(vector[i], vector[pivot_index], data) < 0 ) {
+			// if element is smaller than the pivot
+			// swap it with the first element greater than it
+			// So the first element greater than it is potencially the next one
+			if ( store_index != i ) { // Just avoid unnecessary swaps
+				SU_SWAP(vector[store_index], vector[i]);
+			}
+			store_index++;
+		}
+	}
+
+	// Move the pivot to a location where all the left elements are smaller than it
+	// and all the right elements are greater than it
+	SU_SWAP(vector[pivot_index], vector[store_index - 1]);
+
+	// Sort the smaller elements
+	SortingUtils__quickSort(vector, store_index, cmp, data);
+
+	// And sort the greater ones
+	SortingUtils__quickSort(vector + store_index, length - store_index, cmp, data);
+	
+	return vector;
+}
+
+/**
+ * Sorting comparisong for descending order of ints
+ *
+ * @param void *v1
+ * @param void *v2
+ * @param void *data
+ *
+ * @return int
+ */
+int SortingUtils__INT_DESCENDING(const void *v1, const void *v2, void *data) {
+	int *i1 = (int *) v1;
+	int *i2 = (int *) v2;
+
+	return *i2 - *i1;
+}
+
+/**
+ * Sorting comparisong for ascending order of ints
+ *
+ * @param void *v1
+ * @param void *v2
+ * @param void *data
+ *
+ * @return int
+ */
+int SortingUtils__INT_ASCENDING(const void *v1, const void *v2, void *data) {
+	return -SortingUtils__INT_DESCENDING(v1, v2, data);
+}
+
+#undef SU_SWAP
diff --git a/code/train/C/0135111_sigma.c b/code/train/C/0135111_sigma.c
new file mode 100644
index 0000000000000000000000000000000000000000..aaa4ddc791be3333586abb70676cbbf0682cb4ad
--- /dev/null
+++ b/code/train/C/0135111_sigma.c
@@ -0,0 +1,185 @@
+//this function calculates sum of all divisors of a number n known as sigma(n)
+//can be computed in O(sqrt(n))
+#include<stdio.h>
+long long int power[100000000];
+long long int pf[100000000];
+long long int isprime(long long int n)
+{
+    long long int i,j,k;
+
+
+    j=0;
+    for(i=2;i*i<=n;i++)
+    {
+        if(n%i==0)
+        {
+            j=1;
+            break;
+        }
+
+    }
+
+    if(j==0)
+        return 1;
+    else return 0;
+}
+long long int expo(long long int a,long long int b)
+{
+    long long int res = 1;
+    if(b==0)
+        return 1;
+    else if(b==1)
+        return a;
+    else{
+
+        while(b>0)
+        {
+            if(b&1)
+            {
+                res = res*a;
+            }
+
+            a = a*a;
+            b = b/2;
+        }
+        return res;
+    }
+}
+
+long long int ans[100000000];
+
+
+
+
+long long int freq(long long int n)
+{
+    long long int i,j,k;
+    long long int count ,res;
+    long long int x,y,z;
+    long long int flag=0;
+    count = 0;
+    x =0;
+    y=0;
+    if(n%2==0)
+    {
+        if((n&(n-1))==0)
+            flag=1;
+
+
+        y++;
+        pf[y] = 2;
+
+        while(n%2==0)
+        {
+            count++;
+            n = n/2;
+        }
+        x++;
+        power[x] = count + 1;
+    }
+
+    if(n%2==1 && flag==0)
+    {
+
+
+        for(i=3;i*i<=n;i=i+2)
+        {
+            count = 0;
+            if(n%i==0)
+            {
+                y++;
+                pf[y] = i;
+                while(n%i==0)
+
+                {
+                    count++;
+                    n = n/i;
+                }
+                x++;
+                power[x] = count + 1;
+
+            }
+        }
+        count=0;
+        if(n!=1 && isprime(n)==1)
+        {
+            y++;
+            pf[y] = n;
+            count++;
+            x++;
+            power[x] = count + 1;
+        }
+    }
+
+    return x;
+}
+
+long long int sigma(long long int n)
+{
+    long long int i,j,k;
+    long long int temp,x,y,z;
+    x=0;
+
+    j = freq(n);
+
+    for(i=1;i<=j;i++)
+    {
+        if(power[i]==-1)
+            break;
+        else{
+            if(pf[i]!=n)
+            {
+                k = power[i];
+                temp = pf[i];
+                x++;
+                ans[x] = (expo(temp,k) - 1)/(temp-1);
+            }
+        }
+
+    }
+
+
+    return x;
+}
+
+long long int final_ans(long long int n)
+{
+    long long int i,j,k;
+    j =1;
+
+    if(isprime(n))
+        return n+1;
+    else{
+
+
+        k =  sigma(n);
+
+        for(i=1;i<=k;i++)
+        {
+            j = j*ans[i];
+        }
+        return j;
+    }
+
+}
+int main()
+{
+    long long int i,j,k;
+    long long int t,n;
+    scanf("%lld",&t);
+    for(i=1;i<=100000000;i++)
+        power[i] = -1;
+    while(t--)
+    {
+        scanf("%lld",&n);
+        if(n==1)
+            printf("1\n");
+        else{
+
+            j = final_ans(n);
+            printf("%lld\n",j);
+        }
+    }
+
+    return 0;
+}
diff --git a/code/train/C/0135217_echo-server.c b/code/train/C/0135217_echo-server.c
new file mode 100644
index 0000000000000000000000000000000000000000..8067d81dedadde8560366b585f55e1e567b46581
--- /dev/null
+++ b/code/train/C/0135217_echo-server.c
@@ -0,0 +1,213 @@
+/*
+ *  chiTCP - A simple, testable TCP stack
+ *
+ *  Echo server using chisockets.
+ *
+ *  Not complete yet: can accept connections, but can't send/receive yet.
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "chitcp/socket.h"
+#include "chitcp/types.h"
+#include "chitcp/addr.h"
+
+const char* USAGE = "echo-server [-p PORT] [-s] [-v]";
+
+int sockSend(int socket, char *buffer, int length)
+{
+  int nbytes, nleft, nwritten = 0;
+
+  nleft = length;
+
+  while ( nleft > 0 )
+  {
+      if ( (nbytes = chisocket_send(socket, buffer, nleft, 0)) == -1 )
+      {
+          perror("Could not send message");
+          return -1;
+      }
+      nleft  -= nbytes;
+      buffer += nbytes;
+      nwritten += nbytes;
+  }
+  return nwritten;
+}
+
+int main(int argc, char *argv[])
+{
+    int serverSocket;
+    int clientSocket;
+    int opt;
+    char *port = NULL;
+    uint16_t iport;
+    bool_t step = FALSE;
+    bool_t verbose = FALSE;
+
+    struct sockaddr_in serverAddr, clientAddr;
+    socklen_t sinSize = sizeof(struct sockaddr_in);
+    memset(&serverAddr, 0, sizeof(serverAddr));
+    char addr_str[100];
+
+    /* Use getopt to fetch the host and port */
+    while ((opt = getopt(argc, argv, "p:sv")) != -1)
+        switch (opt)
+        {
+        case 'p':
+            port = strdup(optarg);
+            break;
+        case 's':
+            step = TRUE;
+            break;
+        case 'v':
+            verbose = TRUE;
+            break;
+        default:
+            printf("Unknown option: -%c\n", opt);
+            printf("%s\n", USAGE);
+            exit(1);
+        }
+
+    if(!port)
+        iport = 7;
+    else
+        sscanf(port, "%u", &iport);
+
+    serverAddr.sin_family = AF_INET;
+    serverAddr.sin_port = htons(iport); // The echo protocol
+    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
+
+    if(step)
+    {
+        printf("Press any key to create the socket...");
+        getchar();
+    }
+
+    serverSocket = chisocket_socket(PF_INET,       // Family: IPv4
+                                    SOCK_STREAM,   // Type: Full-duplex stream (reliable)
+                                    IPPROTO_TCP);  // Protocol: TCP;
+
+    if(serverSocket == -1)
+    {
+        perror("Could not create socket");
+        exit(-1);
+    }
+
+    if(step)
+    {
+        printf("Press any key to bind the socket...");
+        getchar();
+    }
+
+    if(chisocket_bind(serverSocket, (struct sockaddr *) &serverAddr, sizeof(serverAddr)) == -1)
+    {
+        perror("Socket bind() failed");
+        chisocket_close(serverSocket);
+        exit(-1);
+    }
+
+    if(step)
+    {
+        printf("Press any key to make the socket listen...");
+        getchar();
+    }
+
+    if(chisocket_listen(serverSocket, 5) == -1)
+    {
+        perror("Socket listen() failed");
+        chisocket_close(serverSocket);
+        exit(-1);
+    }
+
+    if(step)
+    {
+        printf("Press any key to accept a connection...");
+        getchar();
+    }
+    else
+    {
+        printf("Waiting for a connection on port %u ...\n", ntohs(serverAddr.sin_port));
+    }
+
+
+    sinSize = sizeof(struct sockaddr_in);
+    if( (clientSocket = chisocket_accept(serverSocket, (struct sockaddr *) &clientAddr, &sinSize)) == -1)
+    {
+        perror("Socket accept() failed");
+        chisocket_close(serverSocket);
+        exit(-1);
+    }
+
+    chitcp_addr_str((struct sockaddr *) &clientAddr, addr_str, sizeof(addr_str));
+    printf("Got a connection from %s\n", addr_str);
+
+    char buf[257];
+
+    while(1)
+    {
+        int nbytes = chisocket_recv(clientSocket, buf, 256, 0);
+        if(nbytes == 0)
+        {
+            break;
+        }
+        else if (nbytes == -1)
+        {
+            perror("Socket recv() failed");
+            chisocket_close(clientSocket);
+            chisocket_close(serverSocket);
+            exit(-1);
+        }
+        else
+        {
+            if(verbose)
+            {
+                printf("Received: %.*s\n", nbytes, buf);
+            }
+            if (sockSend(clientSocket, buf, nbytes) == -1)
+            {
+                chisocket_close(clientSocket);
+                chisocket_close(serverSocket);
+                exit(-1);
+            }
+        }
+    }
+
+    printf("Peer has closed connection.\n");
+    if(step)
+    {
+        printf("Press any key to close active socket...");
+        getchar();
+    }
+
+    if (chisocket_close(clientSocket) == -1)
+    {
+        perror("Could not close socket");
+        exit(-1);
+    }
+
+    printf("Active socket closed.\n");
+
+    if(step)
+    {
+        printf("Press any key to close passive socket...");
+        getchar();
+    }
+
+    if (chisocket_close(serverSocket) == -1)
+    {
+        perror("Could not close passive socket");
+        exit(-1);
+    }
+
+    printf("Passive socket closed.\n");
+
+    if (step)
+    {
+        printf("Press any key to exit...");
+        getchar();
+    }
+
+    return 0;
+}
diff --git a/code/train/C/0135428_trace-hooks.c b/code/train/C/0135428_trace-hooks.c
new file mode 100644
index 0000000000000000000000000000000000000000..5b8a4d4e3014aad35a9561755b914d1d68ea2ad2
--- /dev/null
+++ b/code/train/C/0135428_trace-hooks.c
@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2015 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * This program 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;
+ * version 2.1 of the License (not later!)
+ *
+ * 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 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 <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include "trace-cmd.h"
+#include "event-utils.h"
+
+struct hook_list *tracecmd_create_event_hook(const char *arg)
+{
+	struct hook_list *hook;
+	char *system = NULL;
+	char *event;
+	char *match;
+	char *flags = NULL;
+	char *pid = NULL;
+	char *str;
+	char *tok;
+	int index;
+	int ch;
+	int i;
+
+	hook = malloc(sizeof(*hook));
+	if (!hook)
+		return NULL;
+	memset(hook, 0, sizeof(*hook));
+
+	str = strdup(arg);
+	if (!str) {
+		free(hook);
+		return NULL;
+	}
+
+	hook->str = str;
+	hook->hook = arg;
+
+	/*
+	 * Hooks are in the form of:
+	 *  [<start_system>:]<start_event>,<start_match>[,<start_pid>]/
+	 *  [<end_system>:]<end_event>,<end_match>[,<flags>]
+	 *
+	 * Where start_system, start_pid, end_system, and flags are all
+	 * optional.
+	 *
+	 * Flags are (case insensitive):
+	 *  P - pinned to cpu (wont migrate)
+	 *  G - global, not hooked to task - currently ignored.
+	 *  S - save stacks for this event.
+	 */
+	tok = strtok(str, ":,");
+	if (!tok)
+		goto invalid_tok;
+
+	/* See what the token was from the original arg */
+	index = strlen(tok);
+	if (arg[index] == ':') {
+		/* this is a system, the next token must be ',' */
+		system = tok;
+		tok = strtok(NULL, ",");
+		if (!tok)
+			goto invalid_tok;
+	}
+	event = tok;
+
+	tok = strtok(NULL, ",/");
+	if (!tok)
+		goto invalid_tok;
+	match = tok;
+	index = strlen(tok) + tok - str;
+	if (arg[index] == ',') {
+		tok = strtok(NULL, "/");
+		if (!tok)
+			goto invalid_tok;
+		pid = tok;
+	}
+
+	hook->start_system = system;
+	hook->start_event = event;
+	hook->start_match = match;
+	hook->pid = pid;
+
+	/* Now process the end event */
+	system = NULL;
+
+	tok = strtok(NULL, ":,");
+	if (!tok)
+		goto invalid_tok;
+
+	/* See what the token was from the original arg */
+	index = tok - str + strlen(tok);
+	if (arg[index] == ':') {
+		/* this is a system, the next token must be ',' */
+		system = tok;
+		tok = strtok(NULL, ",");
+		if (!tok)
+			goto invalid_tok;
+	}
+	event = tok;
+
+	tok = strtok(NULL, ",");
+	if (!tok)
+		goto invalid_tok;
+	match = tok;
+	index = strlen(tok) + tok - str;
+	if (arg[index] == ',') {
+		tok = strtok(NULL, "");
+		if (!tok)
+			goto invalid_tok;
+		flags = tok;
+	}
+
+	hook->end_system = system;
+	hook->end_event = event;
+	hook->end_match = match;
+	hook->migrate = 1;
+	if (flags) {
+		for (i = 0; flags[i]; i++) {
+			ch = tolower(flags[i]);
+			switch (ch) {
+			case 'p':
+				hook->migrate = 0;
+				break;
+			case 'g':
+				hook->global = 1;
+				break;
+			case 's':
+				hook->stack = 1;
+				break;
+			default:
+				warning("unknown flag %c\n", flags[i]);
+			}
+		}
+	}
+
+	printf("start %s:%s:%s (%s) end %s:%s:%s (%s)\n",
+	       hook->start_system,
+	       hook->start_event,
+	       hook->start_match,
+	       hook->pid,
+	       hook->end_system,
+	       hook->end_event,
+	       hook->end_match,
+	       flags);
+	return hook;
+
+invalid_tok:
+	warning("Invalid hook format '%s'", arg);
+	return NULL;
+}
+
+void tracecmd_free_hooks(struct hook_list *hooks)
+{
+	struct hook_list *hook;
+
+	while (hooks) {
+		hook = hooks;
+		hooks = hooks->next;
+
+		free(hook->str);
+		free(hook);
+	}
+}
diff --git a/code/train/C/0135606_cidparse.c b/code/train/C/0135606_cidparse.c
new file mode 100644
index 0000000000000000000000000000000000000000..1fc098b448e3ee546d9c9488f7b02c144a537b17
--- /dev/null
+++ b/code/train/C/0135606_cidparse.c
@@ -0,0 +1,276 @@
+/****************************************************************************
+ *
+ * cidparse.c
+ *
+ *   CID-keyed Type1 parser (body).
+ *
+ * Copyright (C) 1996-2020 by
+ * David Turner, Robert Wilhelm, and Werner Lemberg.
+ *
+ * This file is part of the FreeType project, and may only be used,
+ * modified, and distributed under the terms of the FreeType project
+ * license, LICENSE.TXT.  By continuing to use, modify, or distribute
+ * this file you indicate that you have read the license and
+ * understand and accept it fully.
+ *
+ */
+
+
+#include <freetype/internal/ftdebug.h>
+#include <freetype/internal/ftobjs.h>
+#include <freetype/internal/ftstream.h>
+
+#include "cidparse.h"
+
+#include "ciderrs.h"
+
+
+  /**************************************************************************
+   *
+   * The macro FT_COMPONENT is used in trace mode.  It is an implicit
+   * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
+   * messages during execution.
+   */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  cidparse
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    INPUT STREAM PARSER                        *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+#define STARTDATA      "StartData"
+#define STARTDATA_LEN  ( sizeof ( STARTDATA ) - 1 )
+#define SFNTS          "/sfnts"
+#define SFNTS_LEN      ( sizeof ( SFNTS ) - 1 )
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cid_parser_new( CID_Parser*    parser,
+                  FT_Stream      stream,
+                  FT_Memory      memory,
+                  PSAux_Service  psaux )
+  {
+    FT_Error  error;
+    FT_ULong  base_offset, offset, ps_len;
+    FT_Byte   *cur, *limit;
+    FT_Byte   *arg1, *arg2;
+
+
+    FT_ZERO( parser );
+    psaux->ps_parser_funcs->init( &parser->root, 0, 0, memory );
+
+    parser->stream = stream;
+
+    base_offset = FT_STREAM_POS();
+
+    /* first of all, check the font format in the header */
+    if ( FT_FRAME_ENTER( 31 ) )
+      goto Exit;
+
+    if ( ft_strncmp( (char *)stream->cursor,
+                     "%!PS-Adobe-3.0 Resource-CIDFont", 31 ) )
+    {
+      FT_TRACE2(( "  not a CID-keyed font\n" ));
+      error = FT_THROW( Unknown_File_Format );
+    }
+
+    FT_FRAME_EXIT();
+    if ( error )
+      goto Exit;
+
+  Again:
+    /* now, read the rest of the file until we find */
+    /* `StartData' or `/sfnts'                      */
+    {
+      /*
+       * The algorithm is as follows (omitting the case with less than 256
+       * bytes to fill for simplicity).
+       *
+       * 1. Fill the buffer with 256 + STARTDATA_LEN bytes.
+       *
+       * 2. Search for the STARTDATA and SFNTS strings at positions
+       *    buffer[0], buffer[1], ...,
+       *    buffer[255 + STARTDATA_LEN - SFNTS_LEN].
+       *
+       * 3. Move the last STARTDATA_LEN bytes to buffer[0].
+       *
+       * 4. Fill the buffer with 256 bytes, starting at STARTDATA_LEN.
+       *
+       * 5. Repeat with step 2.
+       *
+       */
+      FT_Byte  buffer[256 + STARTDATA_LEN + 1];
+
+      /* values for the first loop */
+      FT_ULong  read_len    = 256 + STARTDATA_LEN;
+      FT_ULong  read_offset = 0;
+      FT_Byte*  p           = buffer;
+
+
+      for ( offset = FT_STREAM_POS(); ; offset += 256 )
+      {
+        FT_ULong  stream_len;
+
+
+        stream_len = stream->size - FT_STREAM_POS();
+
+        read_len = FT_MIN( read_len, stream_len );
+        if ( FT_STREAM_READ( p, read_len ) )
+          goto Exit;
+
+        /* ensure that we do not compare with data beyond the buffer */
+        p[read_len] = '\0';
+
+        limit = p + read_len - SFNTS_LEN;
+
+        for ( p = buffer; p < limit; p++ )
+        {
+          if ( p[0] == 'S'                                           &&
+               ft_strncmp( (char*)p, STARTDATA, STARTDATA_LEN ) == 0 )
+          {
+            /* save offset of binary data after `StartData' */
+            offset += (FT_ULong)( p - buffer ) + STARTDATA_LEN + 1;
+            goto Found;
+          }
+          else if ( p[1] == 's'                                   &&
+                    ft_strncmp( (char*)p, SFNTS, SFNTS_LEN ) == 0 )
+          {
+            offset += (FT_ULong)( p - buffer ) + SFNTS_LEN + 1;
+            goto Found;
+          }
+        }
+
+        if ( read_offset + read_len < STARTDATA_LEN )
+        {
+          FT_TRACE2(( "cid_parser_new: no `StartData' keyword found\n" ));
+          error = FT_THROW( Invalid_File_Format );
+          goto Exit;
+        }
+
+        FT_MEM_MOVE( buffer,
+                     buffer + read_offset + read_len - STARTDATA_LEN,
+                     STARTDATA_LEN );
+
+        /* values for the next loop */
+        read_len    = 256;
+        read_offset = STARTDATA_LEN;
+        p           = buffer + read_offset;
+      }
+    }
+
+  Found:
+    /* We have found the start of the binary data or the `/sfnts' token. */
+    /* Now rewind and extract the frame corresponding to this PostScript */
+    /* section.                                                          */
+
+    ps_len = offset - base_offset;
+    if ( FT_STREAM_SEEK( base_offset )                  ||
+         FT_FRAME_EXTRACT( ps_len, parser->postscript ) )
+      goto Exit;
+
+    parser->data_offset    = offset;
+    parser->postscript_len = ps_len;
+    parser->root.base      = parser->postscript;
+    parser->root.cursor    = parser->postscript;
+    parser->root.limit     = parser->root.cursor + ps_len;
+    parser->num_dict       = -1;
+
+    /* Finally, we check whether `StartData' or `/sfnts' was real --  */
+    /* it could be in a comment or string.  We also get the arguments */
+    /* of `StartData' to find out whether the data is represented in  */
+    /* binary or hex format.                                          */
+
+    arg1 = parser->root.cursor;
+    cid_parser_skip_PS_token( parser );
+    cid_parser_skip_spaces  ( parser );
+    arg2 = parser->root.cursor;
+    cid_parser_skip_PS_token( parser );
+    cid_parser_skip_spaces  ( parser );
+
+    limit = parser->root.limit;
+    cur   = parser->root.cursor;
+
+    while ( cur <= limit - SFNTS_LEN )
+    {
+      if ( parser->root.error )
+      {
+        error = parser->root.error;
+        goto Exit;
+      }
+
+      if ( cur[0] == 'S'                                           &&
+           cur <= limit - STARTDATA_LEN                            &&
+           ft_strncmp( (char*)cur, STARTDATA, STARTDATA_LEN ) == 0 )
+      {
+        if ( ft_strncmp( (char*)arg1, "(Hex)", 5 ) == 0 )
+        {
+          FT_Long  tmp = ft_strtol( (const char *)arg2, NULL, 10 );
+
+
+          if ( tmp < 0 )
+          {
+            FT_ERROR(( "cid_parser_new: invalid length of hex data\n" ));
+            error = FT_THROW( Invalid_File_Format );
+          }
+          else
+            parser->binary_length = (FT_ULong)tmp;
+        }
+
+        goto Exit;
+      }
+      else if ( cur[1] == 's'                                   &&
+                ft_strncmp( (char*)cur, SFNTS, SFNTS_LEN ) == 0 )
+      {
+        FT_TRACE2(( "cid_parser_new: cannot handle Type 11 fonts\n" ));
+        error = FT_THROW( Unknown_File_Format );
+        goto Exit;
+      }
+
+      cid_parser_skip_PS_token( parser );
+      cid_parser_skip_spaces  ( parser );
+      arg1 = arg2;
+      arg2 = cur;
+      cur  = parser->root.cursor;
+    }
+
+    /* we haven't found the correct `StartData'; go back and continue */
+    /* searching                                                      */
+    FT_FRAME_RELEASE( parser->postscript );
+    if ( !FT_STREAM_SEEK( offset ) )
+      goto Again;
+
+  Exit:
+    return error;
+  }
+
+
+#undef STARTDATA
+#undef STARTDATA_LEN
+#undef SFNTS
+#undef SFNTS_LEN
+
+
+  FT_LOCAL_DEF( void )
+  cid_parser_done( CID_Parser*  parser )
+  {
+    /* always free the private dictionary */
+    if ( parser->postscript )
+    {
+      FT_Stream  stream = parser->stream;
+
+
+      FT_FRAME_RELEASE( parser->postscript );
+    }
+    parser->root.funcs.done( &parser->root );
+  }
+
+
+/* END */
diff --git a/code/train/C/0135804_pack.c b/code/train/C/0135804_pack.c
new file mode 100644
index 0000000000000000000000000000000000000000..5d386148b9bdb6fc3334748b9658d625deadf512
--- /dev/null
+++ b/code/train/C/0135804_pack.c
@@ -0,0 +1,143 @@
+
+#include <emily/types.h>
+#include "node.h"
+#include "theme.h"
+#include "state.h"
+
+static void pack_verticaloff(emily_Node * first, int x0, int y0, int pad, int * w, int * h)
+{
+	// local "cursor" location
+	int locx = x0;
+	int locy = y0;
+	int maxw = 0;
+
+	emily_Node * sub = first;
+
+	while(sub)
+	{
+		sub->x = locx;
+		sub->y = locy;
+
+		if(locx + sub->w > maxw)
+			maxw = locx + sub->w;
+
+		locy += sub->h;
+
+		if(sub->next)
+			locy += pad;
+
+		sub = sub->next;
+	}
+
+	*w = maxw;
+	*h = locy;
+}
+static void pack_horizontaloff(emily_Node * first, int x0, int y0, int pad, int * w, int * h)
+{
+	// local "cursor" location
+	int locx = x0;
+	int locy = y0;
+	int maxh = 0;
+
+	emily_Node * sub = first;
+
+	while(sub)
+	{
+		sub->x = locx;
+		sub->y = locy;
+
+		if(locy + sub->h > maxh)
+			maxh = locy + sub->h;
+
+		locx += sub->w;
+
+		if(sub->next)
+			locx += pad;
+
+		sub = sub->next;
+	}
+
+	*w = locx;
+	*h = maxh;
+}
+static void pack_vertical(emily_Node * first, int pad, int * w, int * h)
+{
+	pack_verticaloff(first, 0, 0, pad, w, h);
+}
+static void pack_horizontal(emily_Node * first, int pad, int * w, int * h)
+{
+	pack_horizontaloff(first, 0, 0, pad, w, h);
+}
+
+void packnode(theme_t * theme, emily_Node * node)
+{
+	if( node->def.type == EMILY_WINDOW ||
+		node->def.type == EMILY_VBOX   ||
+		node->def.type == EMILY_HBOX )
+	{
+		emily_Node * sub = node->child;
+		while(sub)
+		{
+			packnode(theme, sub);
+
+			sub = sub->next;
+		}
+	}
+
+	if(node->def.type == EMILY_VBOX)
+	{
+		int w, h;
+		pack_vertical(node->child, node->def.spacing, &w, &h);
+
+		node->w = w;
+		node->h = h;
+	}
+	else if(node->def.type == EMILY_HBOX)
+	{
+		int w, h;
+		pack_horizontal(node->child, node->def.spacing, &w, &h);
+
+		node->w = w;
+		node->h = h;
+	}
+	else if(node->def.type == EMILY_WINDOW)
+	{
+		int w, h;
+
+		int bar_height = theme_getbarheight(theme);
+
+		pack_verticaloff(node->child, node->def.pad_l, node->def.pad_t + bar_height, node->def.spacing, &w, &h);
+
+		// size is given
+		node->w = node->def.w;
+		node->h = node->def.h;
+
+		// minimum size for contents
+		int minw = w + node->def.pad_r;
+		int minh = h + node->def.pad_b;
+
+		// make sure it's bigger
+		if(node->w < minw)
+			node->w = minw;
+		if(node->h < minh)
+			node->h = minh;
+	}
+	else
+	{
+		theme_getsize(theme, node, &node->w, &node->h);
+	}
+}
+void pack(emily_UI * E)
+{
+	// all given positions are absolute in the list of roots
+	emily_Node * root = E->root;
+	while(root)
+	{
+		root->x = root->def.x;
+		root->y = root->def.y;
+
+		packnode(E->theme, root);
+
+		root = root->next;
+	}
+}
diff --git a/code/train/C/0136080_analyzer.c b/code/train/C/0136080_analyzer.c
new file mode 100644
index 0000000000000000000000000000000000000000..4630ea4ab2b914e3cfb85b395f21fda5701893af
--- /dev/null
+++ b/code/train/C/0136080_analyzer.c
@@ -0,0 +1,125 @@
+/*
+ * This file is a part of Pcompress, a chunked parallel multi-
+ * algorithm lossless compression and decompression program.
+ *
+ * Copyright (C) 2012-2014 Moinak Ghosh. All rights reserved.
+ * Use is subject to license terms.
+ *
+ * This program 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 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
+ * 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/>.
+ *
+ * moinakg@belenix.org, http://moinakg.wordpress.com/
+ */
+
+#include "utils.h"
+#include "analyzer.h"
+
+#define	FIFTY_PCT(x)	((((double)x)/10) * 5)
+#define	THIRTY_PCT(x)	((((double)x)/10) * 3)
+#define	TEN_PCT(x)	(((double)x)/10)
+
+void
+analyze_buffer(void *src, uint64_t srclen, analyzer_ctx_t *actx)
+{
+	uchar_t *src1 = (uchar_t *)src;
+	uint64_t i, tot8b, tot_8b, lbytes, spc;
+	uchar_t cur_byte, prev_byte;
+	uint64_t tag1, tag2, tag3;
+	double tagcnt, pct_tag;
+
+	/*
+	 * Count number of 8-bit binary bytes and XML tags in source.
+	 */
+	tot8b = 0;
+	tag1 = 0;
+	tag2 = 0;
+	tag3 = 0;
+	lbytes = 0;
+	spc = 0;
+	prev_byte = cur_byte = 0;
+	memset(actx, 0, sizeof (analyzer_ctx_t));
+	for (i = 0; i < srclen; i++) {
+		cur_byte = src1[i];
+		tot8b += (cur_byte > 127);
+		lbytes += (cur_byte < 32);
+		spc += (cur_byte == ' ');
+		tag1 += (cur_byte == '<');
+		tag2 += (cur_byte == '>');
+		tag3 += ((prev_byte == '<') & (cur_byte == '/'));
+		tag3 += ((prev_byte == '/') & (cur_byte == '>'));
+		if (cur_byte != ' ')
+			prev_byte = cur_byte;
+	}
+
+	/*
+	 * Heuristics for detecting BINARY vs generic TEXT vs XML data at various
+	 * significance levels.
+	 */
+	tot_8b = tot8b + lbytes;
+	tagcnt = tag1 + tag2;
+	pct_tag = tagcnt / (double)srclen;
+	if (tot_8b > THIRTY_PCT(srclen)) {
+		actx->thirty_pct.btype = TYPE_BINARY;
+	} else {
+		actx->thirty_pct.btype = TYPE_TEXT;
+	}
+
+	if (tot_8b > FIFTY_PCT(srclen)) {
+		actx->fifty_pct.btype = TYPE_BINARY;
+	} else {
+		actx->fifty_pct.btype = TYPE_TEXT;
+	}
+
+	/* This should be tot8b and not tot_8b. */
+	if (tot8b <= TEN_PCT((double)srclen) && lbytes < ((srclen>>1) + (srclen>>2) + (srclen>>3))) {
+		actx->ten_pct.btype = TYPE_TEXT;
+	} else {
+		actx->ten_pct.btype = TYPE_BINARY;
+	}
+
+	if (tag1 > tag2 - 4 && tag1 < tag2 + 4 && tag3 > (double)tag1 * 0.40 &&
+	    tagcnt > (double)spc * 0.06) {
+		actx->thirty_pct.btype |= TYPE_MARKUP;
+		actx->fifty_pct.btype |= TYPE_MARKUP;
+		actx->ten_pct.btype |= TYPE_MARKUP;
+	}
+}
+
+int
+analyze_buffer_simple(void *src, uint64_t srclen)
+{
+	uchar_t *src1 = (uchar_t *)src;
+	uint64_t i, tot8b, lbytes;
+	uchar_t cur_byte;
+	int btype = TYPE_UNKNOWN;
+	/*
+	 * Count number of 8-bit binary bytes in source
+	 */
+	tot8b = 0;
+	lbytes = 0;
+	for (i = 0; i < srclen; i++) {
+		cur_byte = src1[i];
+		tot8b += (cur_byte & 0x80); // This way for possible auto-vectorization
+		lbytes += (cur_byte < 32);
+	}
+	/*
+	 * Heuristics for detecting BINARY vs generic TEXT
+	 */
+	tot8b /= 0x80;
+	if (tot8b <= TEN_PCT((double)srclen) && lbytes < ((srclen>>1) + (srclen>>2) + (srclen>>3))) {
+		btype = TYPE_TEXT;
+	}
+	return (btype);
+}
+
diff --git a/code/train/C/0136132_nsecify.c b/code/train/C/0136132_nsecify.c
new file mode 100644
index 0000000000000000000000000000000000000000..c31b08aaaf24ce63de5e43b7be55e014fa3c9750
--- /dev/null
+++ b/code/train/C/0136132_nsecify.c
@@ -0,0 +1,217 @@
+/*
+ * Copyright (C) 2004, 2007-2009, 2011  Internet Systems Consortium, Inc. ("ISC")
+ * Copyright (C) 1999-2001, 2003  Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+ * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/* $Id: nsecify.c,v 1.12 2011/08/29 23:46:44 tbox Exp $ */
+
+#include <config.h>
+
+#include <stdlib.h>
+
+#include <isc/mem.h>
+#include <isc/print.h>
+#include <isc/string.h>
+
+#include <dns/db.h>
+#include <dns/dbiterator.h>
+#include <dns/fixedname.h>
+#include <dns/nsec.h>
+#include <dns/rdataset.h>
+#include <dns/rdatasetiter.h>
+#include <dns/result.h>
+
+static isc_mem_t *mctx = NULL;
+
+static inline void
+fatal(const char *message) {
+	fprintf(stderr, "%s\n", message);
+	exit(1);
+}
+
+static inline void
+check_result(isc_result_t result, const char *message) {
+	if (result != ISC_R_SUCCESS) {
+		fprintf(stderr, "%s: %s\n", message,
+			isc_result_totext(result));
+		exit(1);
+	}
+}
+
+static inline isc_boolean_t
+active_node(dns_db_t *db, dns_dbversion_t *version, dns_dbnode_t *node) {
+	dns_rdatasetiter_t *rdsiter;
+	isc_boolean_t active = ISC_FALSE;
+	isc_result_t result;
+	dns_rdataset_t rdataset;
+
+	dns_rdataset_init(&rdataset);
+	rdsiter = NULL;
+	result = dns_db_allrdatasets(db, node, version, 0, &rdsiter);
+	check_result(result, "dns_db_allrdatasets()");
+	result = dns_rdatasetiter_first(rdsiter);
+	while (result == ISC_R_SUCCESS) {
+		dns_rdatasetiter_current(rdsiter, &rdataset);
+		if (rdataset.type != dns_rdatatype_nsec)
+			active = ISC_TRUE;
+		dns_rdataset_disassociate(&rdataset);
+		if (!active)
+			result = dns_rdatasetiter_next(rdsiter);
+		else
+			result = ISC_R_NOMORE;
+	}
+	if (result != ISC_R_NOMORE)
+		fatal("rdataset iteration failed");
+	dns_rdatasetiter_destroy(&rdsiter);
+
+	if (!active) {
+		/*
+		 * Make sure there is no NSEC record for this node.
+		 */
+		result = dns_db_deleterdataset(db, node, version,
+					       dns_rdatatype_nsec, 0);
+		if (result == DNS_R_UNCHANGED)
+			result = ISC_R_SUCCESS;
+		check_result(result, "dns_db_deleterdataset");
+	}
+
+	return (active);
+}
+
+static inline isc_result_t
+next_active(dns_db_t *db, dns_dbversion_t *version, dns_dbiterator_t *dbiter,
+	    dns_name_t *name, dns_dbnode_t **nodep)
+{
+	isc_result_t result;
+	isc_boolean_t active;
+
+	do {
+		active = ISC_FALSE;
+		result = dns_dbiterator_current(dbiter, nodep, name);
+		if (result == ISC_R_SUCCESS) {
+			active = active_node(db, version, *nodep);
+			if (!active) {
+				dns_db_detachnode(db, nodep);
+				result = dns_dbiterator_next(dbiter);
+			}
+		}
+	} while (result == ISC_R_SUCCESS && !active);
+
+	return (result);
+}
+
+static void
+nsecify(char *filename) {
+	isc_result_t result;
+	dns_db_t *db;
+	dns_dbversion_t *wversion;
+	dns_dbnode_t *node, *nextnode;
+	char *origintext;
+	dns_fixedname_t fname, fnextname;
+	dns_name_t *name, *nextname, *target;
+	isc_buffer_t b;
+	size_t len;
+	dns_dbiterator_t *dbiter;
+	char newfilename[1024];
+
+	dns_fixedname_init(&fname);
+	name = dns_fixedname_name(&fname);
+	dns_fixedname_init(&fnextname);
+	nextname = dns_fixedname_name(&fnextname);
+
+	origintext = strrchr(filename, '/');
+	if (origintext == NULL)
+		origintext = filename;
+	else
+		origintext++;	/* Skip '/'. */
+	len = strlen(origintext);
+	isc_buffer_init(&b, origintext, len);
+	isc_buffer_add(&b, len);
+	result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
+	check_result(result, "dns_name_fromtext()");
+
+	db = NULL;
+	result = dns_db_create(mctx, "rbt", name, dns_dbtype_zone,
+			       dns_rdataclass_in, 0, NULL, &db);
+	check_result(result, "dns_db_create()");
+	result = dns_db_load(db, filename);
+	if (result == DNS_R_SEENINCLUDE)
+		result = ISC_R_SUCCESS;
+	check_result(result, "dns_db_load()");
+	wversion = NULL;
+	result = dns_db_newversion(db, &wversion);
+	check_result(result, "dns_db_newversion()");
+	dbiter = NULL;
+	result = dns_db_createiterator(db, 0, &dbiter);
+	check_result(result, "dns_db_createiterator()");
+	result = dns_dbiterator_first(dbiter);
+	check_result(result, "dns_dbiterator_first()");
+	node = NULL;
+	result = next_active(db, wversion, dbiter, name, &node);
+	while (result == ISC_R_SUCCESS) {
+		nextnode = NULL;
+		result = dns_dbiterator_next(dbiter);
+		if (result == ISC_R_SUCCESS)
+			result = next_active(db, wversion, dbiter, nextname,
+					     &nextnode);
+		if (result == ISC_R_SUCCESS)
+			target = nextname;
+		else if (result == ISC_R_NOMORE)
+			target = dns_db_origin(db);
+		else {
+			target = NULL;	/* Make compiler happy. */
+			fatal("db iteration failed");
+		}
+		dns_nsec_build(db, wversion, node, target, 3600); /* XXX BEW */
+		dns_db_detachnode(db, &node);
+		node = nextnode;
+	}
+	if (result != ISC_R_NOMORE)
+		fatal("db iteration failed");
+	dns_dbiterator_destroy(&dbiter);
+	/*
+	 * XXXRTH  For now, we don't increment the SOA serial.
+	 */
+	dns_db_closeversion(db, &wversion, ISC_TRUE);
+	len = strlen(filename);
+	if (len + 4 + 1 > sizeof(newfilename))
+		fatal("filename too long");
+	sprintf(newfilename, "%s.new", filename);
+	result = dns_db_dump(db, NULL, newfilename);
+	check_result(result, "dns_db_dump");
+	dns_db_detach(&db);
+}
+
+int
+main(int argc, char *argv[]) {
+	int i;
+	isc_result_t result;
+
+	dns_result_register();
+
+	result = isc_mem_create(0, 0, &mctx);
+	check_result(result, "isc_mem_create()");
+
+	argc--;
+	argv++;
+
+	for (i = 0; i < argc; i++)
+		nsecify(argv[i]);
+
+	/* isc_mem_stats(mctx, stdout); */
+	isc_mem_destroy(&mctx);
+
+	return (0);
+}
diff --git a/code/train/C/0136298_motion.c b/code/train/C/0136298_motion.c
new file mode 100644
index 0000000000000000000000000000000000000000..80196ad59e619186f3904a59099749e85642483a
--- /dev/null
+++ b/code/train/C/0136298_motion.c
@@ -0,0 +1,194 @@
+/*****************************************************************************
+ * motion.c: control VLC with laptop built-in motion sensors
+ *****************************************************************************
+ * Copyright (C) 2006 - 2007 the VideoLAN team
+ * $Id$
+ *
+ * Author: Sam Hocevar <sam@zoy.org>
+ *         Jérôme Decoodt <djc@videolan.org> (unimotion integration)
+ *
+ * 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.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <assert.h>
+#include <unistd.h>
+
+#include <vlc_common.h>
+#include <vlc_plugin.h>
+#include <vlc_interface.h>
+#include <vlc_playlist.h>
+#include <vlc_input.h>
+#include <vlc_vout.h>
+
+#include "motionlib.h"
+
+/*****************************************************************************
+ * intf_sys_t: description and status of interface
+ *****************************************************************************/
+struct intf_sys_t
+{
+    motion_sensors_t *p_motion;
+    vlc_thread_t thread;
+};
+
+/*****************************************************************************
+ * Local prototypes.
+ *****************************************************************************/
+static int  Open   ( vlc_object_t * );
+static void Close  ( vlc_object_t * );
+
+static void *RunIntf( void * );
+
+/*****************************************************************************
+ * Module descriptor
+ *****************************************************************************/
+vlc_module_begin ()
+    set_shortname( N_("motion"))
+    set_category( CAT_INTERFACE )
+    set_subcategory( SUBCAT_INTERFACE_CONTROL )
+    set_description( N_("motion control interface") )
+    set_help( N_("Use HDAPS, AMS, APPLESMC or UNIMOTION motion sensors " \
+                 "to rotate the video") )
+
+    add_obsolete_bool( "motion-use-rotate" ) /* since 2.1.0 */
+
+    set_capability( "interface", 0 )
+    set_callbacks( Open, Close )
+vlc_module_end ()
+
+/*****************************************************************************
+ * OpenIntf: initialise interface
+ *****************************************************************************/
+int Open ( vlc_object_t *p_this )
+{
+    intf_thread_t *p_intf = (intf_thread_t *)p_this;
+    intf_sys_t *p_sys = malloc( sizeof( *p_sys ) );
+    if( unlikely(p_sys == NULL) )
+        return VLC_ENOMEM;
+
+    p_sys->p_motion = motion_create( VLC_OBJECT( p_intf ) );
+    if( p_sys->p_motion == NULL )
+    {
+error:
+        free( p_sys );
+        return VLC_EGENERIC;
+    }
+
+    p_intf->p_sys = p_sys;
+
+    if( vlc_clone( &p_sys->thread, RunIntf, p_intf, VLC_THREAD_PRIORITY_LOW ) )
+    {
+        motion_destroy( p_sys->p_motion );
+        goto error;
+    }
+
+    return VLC_SUCCESS;
+}
+
+/*****************************************************************************
+ * CloseIntf: destroy interface
+ *****************************************************************************/
+void Close ( vlc_object_t *p_this )
+{
+    intf_thread_t *p_intf = (intf_thread_t *)p_this;
+    intf_sys_t *p_sys = p_intf->p_sys;
+
+    vlc_cancel( p_sys->thread );
+    vlc_join( p_sys->thread, NULL );
+    motion_destroy( p_sys->p_motion );
+    free( p_sys );
+}
+
+/*****************************************************************************
+ * RunIntf: main loop
+ *****************************************************************************/
+#define LOW_THRESHOLD 800
+#define HIGH_THRESHOLD 1000
+static void *RunIntf( void *data )
+{
+    intf_thread_t *p_intf = data;
+    int i_oldx = 0;
+
+    for( ;; )
+    {
+        const char *psz_type;
+        bool b_change = false;
+
+        /* Wait a bit, get orientation, change filter if necessary */
+#warning FIXME: check once (or less) per picture, not once per interval
+        msleep( INTF_IDLE_SLEEP );
+
+        int canc = vlc_savecancel();
+        int i_x = motion_get_angle( p_intf->p_sys->p_motion );
+
+        if( i_x < -HIGH_THRESHOLD && i_oldx > -LOW_THRESHOLD )
+        {
+            b_change = true;
+            psz_type = "90";
+        }
+        else if( ( i_x > -LOW_THRESHOLD && i_oldx < -HIGH_THRESHOLD )
+                 || ( i_x < LOW_THRESHOLD && i_oldx > HIGH_THRESHOLD ) )
+        {
+            b_change = true;
+            psz_type = NULL;
+        }
+        else if( i_x > HIGH_THRESHOLD && i_oldx < LOW_THRESHOLD )
+        {
+            b_change = true;
+            psz_type = "270";
+        }
+
+        if( b_change )
+        {
+#warning FIXME: refactor this plugin as a video filter!
+            input_thread_t *p_input = pl_CurrentInput( p_intf );
+            if( p_input )
+            {
+                vout_thread_t *p_vout;
+
+                p_vout = input_GetVout( p_input );
+                if( p_vout )
+                {
+                    if( psz_type != NULL )
+                    {
+                        var_Create( p_vout, "transform-type", VLC_VAR_STRING );
+                        var_SetString( p_vout, "transform-type", psz_type );
+                    }
+                    else
+                        var_Destroy( p_vout, "transform-type" );
+
+                    var_SetString( p_vout, "video-filter",
+                                   psz_type != NULL ? "transform" : "" );
+                    vlc_object_release( p_vout );
+                }
+                vlc_object_release( p_input );
+                i_oldx = i_x;
+            }
+        }
+
+        vlc_restorecancel( canc );
+    }
+    assert(0);
+}
+#undef LOW_THRESHOLD
+#undef HIGH_THRESHOLD
diff --git a/code/train/C/0136455_pdfpages.c b/code/train/C/0136455_pdfpages.c
new file mode 100644
index 0000000000000000000000000000000000000000..fa13e91ec7965fbfb20d33a26bbdb8b3b166f578
--- /dev/null
+++ b/code/train/C/0136455_pdfpages.c
@@ -0,0 +1,209 @@
+/*
+ * Information tool.
+ * Print information about pages of a pdf.
+ */
+
+#include "mupdf/fitz.h"
+#include "mupdf/pdf.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+
+static void
+infousage(void)
+{
+	fprintf(stderr,
+		"usage: mutool pages [options] file.pdf [pages]\n"
+		"\t-p -\tpassword for decryption\n"
+		"\tpages\tcomma separated list of page numbers and ranges\n"
+		);
+	exit(1);
+}
+
+static int
+showbox(fz_context *ctx, fz_output *out, pdf_obj *page, char *text, pdf_obj *name)
+{
+	fz_rect bbox;
+	pdf_obj *obj;
+	int failed = 0;
+
+	fz_try(ctx)
+	{
+		obj = pdf_dict_get(ctx, page, name);
+		if (!pdf_is_array(ctx, obj))
+			break;
+
+		bbox = pdf_to_rect(ctx, obj);
+
+		fz_write_printf(ctx, out, "<%s l=\"%g\" b=\"%g\" r=\"%g\" t=\"%g\" />\n", text, bbox.x0, bbox.y0, bbox.x1, bbox.y1);
+	}
+	fz_catch(ctx)
+	{
+		failed = 1;
+	}
+
+	return failed;
+}
+
+static int
+shownum(fz_context *ctx, fz_output *out, pdf_obj *page, char *text, pdf_obj *name)
+{
+	pdf_obj *obj;
+	int failed = 0;
+
+	fz_try(ctx)
+	{
+		obj = pdf_dict_get(ctx, page, name);
+		if (!pdf_is_number(ctx, obj))
+			break;
+
+		fz_write_printf(ctx, out, "<%s v=\"%g\" />\n", text, pdf_to_real(ctx, obj));
+	}
+	fz_catch(ctx)
+	{
+		failed = 1;
+	}
+
+	return failed;
+}
+
+static int
+showpage(fz_context *ctx, pdf_document *doc, fz_output *out, int page)
+{
+	pdf_obj *pageref;
+	int failed = 0;
+
+	fz_write_printf(ctx, out, "<page pagenum=\"%d\">\n", page);
+	fz_try(ctx)
+	{
+		pageref = pdf_lookup_page_obj(ctx, doc, page-1);
+		if (!pageref)
+			fz_throw(ctx, FZ_ERROR_GENERIC, "cannot retrieve info from page %d", page);
+	}
+	fz_catch(ctx)
+	{
+		fz_write_printf(ctx, out, "Failed to gather information for page %d\n", page);
+		failed = 1;
+	}
+
+	if (!failed)
+	{
+		failed |= showbox(ctx, out, pageref, "MediaBox", PDF_NAME(MediaBox));
+		failed |= showbox(ctx, out, pageref, "CropBox", PDF_NAME(CropBox));
+		failed |= showbox(ctx, out, pageref, "ArtBox", PDF_NAME(ArtBox));
+		failed |= showbox(ctx, out, pageref, "BleedBox", PDF_NAME(BleedBox));
+		failed |= showbox(ctx, out, pageref, "TrimBox", PDF_NAME(TrimBox));
+		failed |= shownum(ctx, out, pageref, "Rotate", PDF_NAME(Rotate));
+		failed |= shownum(ctx, out, pageref, "UserUnit", PDF_NAME(UserUnit));
+	}
+
+	fz_write_printf(ctx, out, "</page>\n");
+
+	return failed;
+}
+
+static int
+showpages(fz_context *ctx, pdf_document *doc, fz_output *out, const char *pagelist)
+{
+	int page, spage, epage;
+	int pagecount;
+	int ret = 0;
+
+	if (!doc)
+		infousage();
+
+	pagecount = pdf_count_pages(ctx, doc);
+	while ((pagelist = fz_parse_page_range(ctx, pagelist, &spage, &epage, pagecount)))
+	{
+		if (spage > epage)
+			page = spage, spage = epage, epage = page;
+		for (page = spage; page <= epage; page++)
+			ret |= showpage(ctx, doc, out, page);
+	}
+
+	return ret;
+}
+
+static int
+pdfpages_pages(fz_context *ctx, fz_output *out, char *filename, char *password, char *argv[], int argc)
+{
+	enum { NO_FILE_OPENED, NO_INFO_GATHERED, INFO_SHOWN } state;
+	int argidx = 0;
+	pdf_document *doc = NULL;
+	int ret = 0;
+
+	state = NO_FILE_OPENED;
+	while (argidx < argc)
+	{
+		if (state == NO_FILE_OPENED || !fz_is_page_range(ctx, argv[argidx]))
+		{
+			if (state == NO_INFO_GATHERED)
+			{
+				showpages(ctx, doc, out, "1-N");
+			}
+
+			pdf_drop_document(ctx, doc);
+
+			filename = argv[argidx];
+			fz_write_printf(ctx, out, "%s:\n", filename);
+			doc = pdf_open_document(ctx, filename);
+			if (pdf_needs_password(ctx, doc))
+				if (!pdf_authenticate_password(ctx, doc, password))
+					fz_throw(ctx, FZ_ERROR_GENERIC, "cannot authenticate password: %s", filename);
+
+			state = NO_INFO_GATHERED;
+		}
+		else
+		{
+			ret |= showpages(ctx, doc, out, argv[argidx]);
+			state = INFO_SHOWN;
+		}
+
+		argidx++;
+	}
+
+	if (state == NO_INFO_GATHERED)
+		showpages(ctx, doc, out, "1-N");
+
+	pdf_drop_document(ctx, doc);
+
+	return ret;
+}
+
+int pdfpages_main(int argc, char **argv)
+{
+	char *filename = "";
+	char *password = "";
+	int c;
+	int ret;
+	fz_context *ctx;
+
+	while ((c = fz_getopt(argc, argv, "p:")) != -1)
+	{
+		switch (c)
+		{
+		case 'p': password = fz_optarg; break;
+		default:
+			infousage();
+			break;
+		}
+	}
+
+	if (fz_optind == argc)
+		infousage();
+
+	ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
+	if (!ctx)
+	{
+		fprintf(stderr, "cannot initialise context\n");
+		exit(1);
+	}
+
+	ret = 0;
+	fz_try(ctx)
+		ret = pdfpages_pages(ctx, fz_stdout(ctx), filename, password, &argv[fz_optind], argc-fz_optind);
+	fz_catch(ctx)
+		ret = 1;
+	fz_drop_context(ctx);
+	return ret;
+}
diff --git a/code/train/C/0136458_main.c b/code/train/C/0136458_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..2a4d43895062dea6f95b43d9cffacfd3488ff1f1
--- /dev/null
+++ b/code/train/C/0136458_main.c
@@ -0,0 +1,107 @@
+/**
+ * maxcalc is a command line tool for multiple precision arithmetic
+ * calculations.
+ * Copyright © 2018 Max Wällstedt <max.wallstedt@gmail.com>
+ *
+ * This file is part of maxcalc.
+ *
+ * maxcalc 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.
+ *
+ * maxcalc 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 maxcalc.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <readline/readline.h>
+#include <readline/history.h>
+
+#include "maxcalc.h"
+
+static void maxcalc_from_tty()
+{
+	char *line = NULL, *prev = NULL;
+
+	using_history();
+
+	while ((line = readline("> ")) != NULL) {
+		if (line[0] != '\0') {
+			/* Perform maxcalc on non-empty line. */
+
+			maxcalc(line);
+
+			/* Add line to history if it is not identical
+			   to the previously entered line. */
+
+			if (prev == NULL || strcmp(line, prev) != 0) {
+				add_history(line);
+			}
+		}
+
+		free(prev);
+		prev = line;
+	}
+
+	free(prev);
+	clear_history();
+	rl_clear_history();
+	rl_set_prompt(NULL);
+	fputc('\n', stdout);
+}
+
+static void maxcalc_from_file(FILE *input)
+{
+	char *line = NULL;
+	size_t n = 0;
+	ssize_t nread;
+
+	while ((nread = getline(&line, &n, input)) != -1) {
+		/* Remove trailing newline character. */
+		if (nread > 0 && line[nread - 1] == '\n') {
+			line[nread - 1] = '\0';
+			--nread;
+		}
+
+		/* Perform maxcalc on non-empty line. */
+		if (line[0] != '\0') {
+			maxcalc(line);
+		}
+	}
+
+	free(line);
+}
+
+int main(int argc, char *argv[])
+{
+	FILE *input;
+
+	if (argc == 1) {
+		if (isatty(STDIN_FILENO)) {
+			maxcalc_from_tty();
+		} else {
+			maxcalc_from_file(stdin);
+		}
+	} else {
+		input = fopen(argv[1], "r");
+
+		if (input == NULL) {
+			perror(argv[1]);
+			exit(EXIT_FAILURE);
+		}
+
+		maxcalc_from_file(input);
+		fclose(input);
+	}
+
+	return 0;
+}
diff --git a/code/train/C/0136459_16.3sum-closest.c b/code/train/C/0136459_16.3sum-closest.c
new file mode 100644
index 0000000000000000000000000000000000000000..9271cc363902273891a67d9d236f0fea15d81567
--- /dev/null
+++ b/code/train/C/0136459_16.3sum-closest.c
@@ -0,0 +1,46 @@
+/*
+ * [16] 3Sum Closest
+ *
+ * https://leetcode.com/problems/3sum-closest/description/
+ *
+ * algorithms
+ * Medium (31.44%)
+ * Total Accepted:    155.3K
+ * Total Submissions: 494K
+ * Testcase Example:  '[0,0,0]\n1'
+ *
+ * Given an array S of n integers, find three integers in S such that the sum
+ * is closest to a given number, target. Return the sum of the three integers.
+ * You may assume that each input would have exactly one solution.
+ * 
+ * 
+ * ⁠   For example, given array S = {-1 2 1 -4}, and target = 1.
+ * 
+ * ⁠   The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
+ * 
+ */
+
+int compare(const void* x, const void* y) {
+    return *(const int*)x - *(const int*)y;
+}
+
+int threeSumClosest(int* nums, int numsSize, int target) {
+    qsort(nums, numsSize, sizeof(int), compare);
+    int current_closest = nums[0] + nums[1] + nums[2];
+    for (int i = 0; i < numsSize; ++i) {
+        int left  = i + 1;
+        int right = numsSize - 1;
+        while (left < right) {
+            int temp = nums[i] + nums[left] + nums[right];
+            if (temp == target)
+                return target;
+            if (abs(temp-target) < abs(current_closest-target))
+                current_closest = temp;
+            if (temp < target)
+                ++left;
+            else
+                --right;
+        }
+    }
+    return current_closest;
+}
diff --git a/code/train/C/0136478_util.c b/code/train/C/0136478_util.c
new file mode 100644
index 0000000000000000000000000000000000000000..9706d9d40279859321412b270c8ac3053141f4f9
--- /dev/null
+++ b/code/train/C/0136478_util.c
@@ -0,0 +1,112 @@
+#include <newt.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/ttydefaults.h>
+
+#include "../cache.h"
+#include "../debug.h"
+#include "browser.h"
+#include "helpline.h"
+#include "util.h"
+
+static void newt_form__set_exit_keys(newtComponent self)
+{
+	newtFormAddHotKey(self, NEWT_KEY_LEFT);
+	newtFormAddHotKey(self, NEWT_KEY_ESCAPE);
+	newtFormAddHotKey(self, 'Q');
+	newtFormAddHotKey(self, 'q');
+	newtFormAddHotKey(self, CTRL('c'));
+}
+
+static newtComponent newt_form__new(void)
+{
+	newtComponent self = newtForm(NULL, NULL, 0);
+	if (self)
+		newt_form__set_exit_keys(self);
+	return self;
+}
+
+int ui__popup_menu(int argc, char * const argv[])
+{
+	struct newtExitStruct es;
+	int i, rc = -1, max_len = 5;
+	newtComponent listbox, form = newt_form__new();
+
+	if (form == NULL)
+		return -1;
+
+	listbox = newtListbox(0, 0, argc, NEWT_FLAG_RETURNEXIT);
+	if (listbox == NULL)
+		goto out_destroy_form;
+
+	newtFormAddComponent(form, listbox);
+
+	for (i = 0; i < argc; ++i) {
+		int len = strlen(argv[i]);
+		if (len > max_len)
+			max_len = len;
+		if (newtListboxAddEntry(listbox, argv[i], (void *)(long)i))
+			goto out_destroy_form;
+	}
+
+	newtCenteredWindow(max_len, argc, NULL);
+	newtFormRun(form, &es);
+	rc = newtListboxGetCurrent(listbox) - NULL;
+	if (es.reason == NEWT_EXIT_HOTKEY)
+		rc = -1;
+	newtPopWindow();
+out_destroy_form:
+	newtFormDestroy(form);
+	return rc;
+}
+
+int ui__help_window(const char *text)
+{
+	struct newtExitStruct es;
+	newtComponent tb, form = newt_form__new();
+	int rc = -1;
+	int max_len = 0, nr_lines = 0;
+	const char *t;
+
+	if (form == NULL)
+		return -1;
+
+	t = text;
+	while (1) {
+		const char *sep = strchr(t, '\n');
+		int len;
+
+		if (sep == NULL)
+			sep = strchr(t, '\0');
+		len = sep - t;
+		if (max_len < len)
+			max_len = len;
+		++nr_lines;
+		if (*sep == '\0')
+			break;
+		t = sep + 1;
+	}
+
+	tb = newtTextbox(0, 0, max_len, nr_lines, 0);
+	if (tb == NULL)
+		goto out_destroy_form;
+
+	newtTextboxSetText(tb, text);
+	newtFormAddComponent(form, tb);
+	newtCenteredWindow(max_len, nr_lines, NULL);
+	newtFormRun(form, &es);
+	newtPopWindow();
+	rc = 0;
+out_destroy_form:
+	newtFormDestroy(form);
+	return rc;
+}
+
+bool ui__dialog_yesno(const char *msg)
+{
+	/* newtWinChoice should really be accepting const char pointers... */
+	char yes[] = "Yes", no[] = "No";
+	return newtWinChoice(NULL, yes, no, (char *)msg) == 1;
+}
diff --git a/code/train/C/0136518_main.c b/code/train/C/0136518_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..8f81aa9ec4c9125d9757ec457e57ba511b70c9c0
--- /dev/null
+++ b/code/train/C/0136518_main.c
@@ -0,0 +1,173 @@
+#include <GL/gl3w.h>
+#include <GLFW/glfw3.h>
+#include <stdlib.h>
+
+#include "gx_define.h"
+#include "gx_io.h"
+#include "gx_math.h"
+#include "gx_renderer.h"
+#include "gx.h"
+
+struct GameWindow
+{
+    GLFWwindow *glfw;
+    uint32 width;
+    uint32 height;
+};
+
+static void APIENTRY debug_message_callback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* user_param)
+{
+    // TODO: output severity?
+    fprintf(stderr, "[GL_ERROR] %s\n", message);
+}
+
+static struct GameWindow create_window(const char *title, uint32 width, uint32 height)
+{
+    glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+
+    const GLFWvidmode* video_mode = glfwGetVideoMode(glfwGetPrimaryMonitor());
+    glfwWindowHint(GLFW_RED_BITS, video_mode->redBits);
+    glfwWindowHint(GLFW_GREEN_BITS, video_mode->greenBits);
+    glfwWindowHint(GLFW_BLUE_BITS, video_mode->blueBits);
+    glfwWindowHint(GLFW_REFRESH_RATE, video_mode->refreshRate);
+
+    glfwWindowHint(GLFW_VISIBLE, GL_TRUE);
+    glfwWindowHint(GLFW_SRGB_CAPABLE, GL_TRUE);
+    glfwWindowHint(GLFW_DOUBLEBUFFER, GL_TRUE);
+    glfwWindowHint(GLFW_SAMPLES, 0);
+
+    GLFWwindow *glfw_window = glfwCreateWindow(width, height, title, NULL, NULL);
+    ASSERT_NOT_NULL(glfw_window);
+    glfwMakeContextCurrent(glfw_window);
+
+    glfwSetInputMode(glfw_window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+
+    struct GameWindow window = {0};
+    window.glfw = glfw_window;
+    window.width = width;
+    window.height = height;
+    return window;
+}
+
+int main(int argc, char *argv[])
+{
+    //
+    // glfw
+    //
+
+    if (!glfwInit())
+    {
+        fprintf(stderr, "[ERROR] Failed to initialize GLFW.\n");
+        return 1;
+    }
+
+    struct GameWindow window = create_window("floating", 1280, 720);
+
+
+    //
+    // gl3w
+    //
+
+    if (gl3wInit())
+    {
+        fprintf(stderr, "[ERROR] Failed to initialize GL3W.\n");
+        return 1;
+    }
+
+    if (!gl3wIsSupported(3, 3))
+    {
+        fprintf(stderr, "[ERROR] System does not support OpenGL 3.3.\n");
+        return 1;
+    }
+
+    if (GL_ARB_debug_output)
+    {
+        glEnable(GL_DEBUG_OUTPUT);
+        glDebugMessageCallbackARB((GLDEBUGPROC)&debug_message_callback, NULL);
+    }
+
+
+    //
+    // init
+    //
+
+    init_random(23932487);
+
+    struct Input input = {0};
+    struct Renderer renderer = init_renderer();
+
+    struct GameMemory game_memory = {0};
+    game_memory.game_memory_size = MEGABYTES(8);
+    game_memory.render_memory_size = MEGABYTES(1);
+    game_memory.game_memory = calloc(1, game_memory.game_memory_size);
+    game_memory.render_memory = calloc(1, game_memory.render_memory_size);
+
+    init_game(&game_memory);
+
+
+    //
+    // main loop
+    //
+
+    const double tick_dt = 1.0 / 60.0;
+    double time = glfwGetTime();
+    double tick_accumulator = 0.0;
+
+    while (!glfwWindowShouldClose(window.glfw))
+    {
+        //
+        // tick
+        //
+
+        glfwPollEvents();
+
+        double new_time = glfwGetTime();
+        double frame_time = new_time - time;
+        time = new_time;
+
+        frame_time = max_double(0.0, frame_time);
+        frame_time = min_double(0.2, frame_time);
+
+        tick_accumulator += frame_time;
+
+        while (tick_accumulator >= tick_dt)
+        {
+            process_input(window.glfw, &input);
+
+            tick_game(&game_memory, &input, window.width, window.height, tick_dt);
+            clear_input(&input);
+
+            tick_accumulator -= tick_dt;
+        }
+
+
+        //
+        // render
+        //
+
+        glViewport(0, 0, window.width, window.height);
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        render_game(&game_memory, &renderer, window.width, window.height);
+
+        glfwSwapBuffers(window.glfw);
+    }
+
+
+    //
+    // cleanup
+    //
+
+    free(game_memory.render_memory);
+    free(game_memory.game_memory);
+    clean_renderer(&renderer);
+
+    glfwDestroyWindow(window.glfw);
+    glfwTerminate();
+
+    return 0;
+}
diff --git a/code/train/C/0136563_aio-win32.c b/code/train/C/0136563_aio-win32.c
new file mode 100644
index 0000000000000000000000000000000000000000..23f4e5ba19755bd9c743d6eaa3e2200bebfa4bec
--- /dev/null
+++ b/code/train/C/0136563_aio-win32.c
@@ -0,0 +1,223 @@
+/*
+ * QEMU aio implementation
+ *
+ * Copyright IBM Corp., 2008
+ * Copyright Red Hat Inc., 2012
+ *
+ * Authors:
+ *  Anthony Liguori   <aliguori@us.ibm.com>
+ *  Paolo Bonzini     <pbonzini@redhat.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2.  See
+ * the COPYING file in the top-level directory.
+ *
+ * Contributions after 2012-01-13 are licensed under the terms of the
+ * GNU GPL, version 2 or (at your option) any later version.
+ */
+
+#include "qemu-common.h"
+#include "block/block.h"
+#include "qemu/queue.h"
+#include "qemu/sockets.h"
+
+struct AioHandler {
+    EventNotifier *e;
+    EventNotifierHandler *io_notify;
+    GPollFD pfd;
+    int deleted;
+    QLIST_ENTRY(AioHandler) node;
+};
+
+void aio_set_event_notifier(AioContext *ctx,
+                            EventNotifier *e,
+                            EventNotifierHandler *io_notify)
+{
+    AioHandler *node;
+
+    QLIST_FOREACH(node, &ctx->aio_handlers, node) {
+        if (node->e == e && !node->deleted) {
+            break;
+        }
+    }
+
+    /* Are we deleting the fd handler? */
+    if (!io_notify) {
+        if (node) {
+            g_source_remove_poll(&ctx->source, &node->pfd);
+
+            /* If the lock is held, just mark the node as deleted */
+            if (ctx->walking_handlers) {
+                node->deleted = 1;
+                node->pfd.revents = 0;
+            } else {
+                /* Otherwise, delete it for real.  We can't just mark it as
+                 * deleted because deleted nodes are only cleaned up after
+                 * releasing the walking_handlers lock.
+                 */
+                QLIST_REMOVE(node, node);
+                g_free(node);
+            }
+        }
+    } else {
+        if (node == NULL) {
+            /* Alloc and insert if it's not already there */
+            node = g_malloc0(sizeof(AioHandler));
+            node->e = e;
+            node->pfd.fd = (uintptr_t)event_notifier_get_handle(e);
+            node->pfd.events = G_IO_IN;
+            QLIST_INSERT_HEAD(&ctx->aio_handlers, node, node);
+
+            g_source_add_poll(&ctx->source, &node->pfd);
+        }
+        /* Update handler with latest information */
+        node->io_notify = io_notify;
+    }
+
+    aio_notify(ctx);
+}
+
+bool aio_pending(AioContext *ctx)
+{
+    AioHandler *node;
+
+    QLIST_FOREACH(node, &ctx->aio_handlers, node) {
+        if (node->pfd.revents && node->io_notify) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool aio_poll(AioContext *ctx, bool blocking)
+{
+    AioHandler *node;
+    HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
+    bool progress;
+    int count;
+    int timeout;
+
+    progress = false;
+
+    /*
+     * If there are callbacks left that have been queued, we need to call then.
+     * Do not call select in this case, because it is possible that the caller
+     * does not need a complete flush (as is the case for qemu_aio_wait loops).
+     */
+    if (aio_bh_poll(ctx)) {
+        blocking = false;
+        progress = true;
+    }
+
+    /* Run timers */
+    progress |= timerlistgroup_run_timers(&ctx->tlg);
+
+    /*
+     * Then dispatch any pending callbacks from the GSource.
+     *
+     * We have to walk very carefully in case qemu_aio_set_fd_handler is
+     * called while we're walking.
+     */
+    node = QLIST_FIRST(&ctx->aio_handlers);
+    while (node) {
+        AioHandler *tmp;
+
+        ctx->walking_handlers++;
+
+        if (node->pfd.revents && node->io_notify) {
+            node->pfd.revents = 0;
+            node->io_notify(node->e);
+
+            /* aio_notify() does not count as progress */
+            if (node->e != &ctx->notifier) {
+                progress = true;
+            }
+        }
+
+        tmp = node;
+        node = QLIST_NEXT(node, node);
+
+        ctx->walking_handlers--;
+
+        if (!ctx->walking_handlers && tmp->deleted) {
+            QLIST_REMOVE(tmp, node);
+            g_free(tmp);
+        }
+    }
+
+    if (progress && !blocking) {
+        return true;
+    }
+
+    ctx->walking_handlers++;
+
+    /* fill fd sets */
+    count = 0;
+    QLIST_FOREACH(node, &ctx->aio_handlers, node) {
+        if (!node->deleted && node->io_notify) {
+            events[count++] = event_notifier_get_handle(node->e);
+        }
+    }
+
+    ctx->walking_handlers--;
+
+    /* wait until next event */
+    while (count > 0) {
+        int ret;
+
+        timeout = blocking ?
+            qemu_timeout_ns_to_ms(timerlistgroup_deadline_ns(&ctx->tlg)) : 0;
+        ret = WaitForMultipleObjects(count, events, FALSE, timeout);
+
+        /* if we have any signaled events, dispatch event */
+        if ((DWORD) (ret - WAIT_OBJECT_0) >= count) {
+            break;
+        }
+
+        blocking = false;
+
+        /* we have to walk very carefully in case
+         * qemu_aio_set_fd_handler is called while we're walking */
+        node = QLIST_FIRST(&ctx->aio_handlers);
+        while (node) {
+            AioHandler *tmp;
+
+            ctx->walking_handlers++;
+
+            if (!node->deleted &&
+                event_notifier_get_handle(node->e) == events[ret - WAIT_OBJECT_0] &&
+                node->io_notify) {
+                node->io_notify(node->e);
+
+                /* aio_notify() does not count as progress */
+                if (node->e != &ctx->notifier) {
+                    progress = true;
+                }
+            }
+
+            tmp = node;
+            node = QLIST_NEXT(node, node);
+
+            ctx->walking_handlers--;
+
+            if (!ctx->walking_handlers && tmp->deleted) {
+                QLIST_REMOVE(tmp, node);
+                g_free(tmp);
+            }
+        }
+
+        /* Try again, but only call each handler once.  */
+        events[ret - WAIT_OBJECT_0] = events[--count];
+    }
+
+    if (blocking) {
+        /* Run the timers a second time. We do this because otherwise aio_wait
+         * will not note progress - and will stop a drain early - if we have
+         * a timer that was not ready to run entering g_poll but is ready
+         * after g_poll. This will only do anything if a timer has expired.
+         */
+        progress |= timerlistgroup_run_timers(&ctx->tlg);
+    }
+
+    return progress;
+}
diff --git a/code/train/C/0136582_gcd.c b/code/train/C/0136582_gcd.c
new file mode 100644
index 0000000000000000000000000000000000000000..6f75a3d8881c9cd04d37d11ddb7b2f2671337604
--- /dev/null
+++ b/code/train/C/0136582_gcd.c
@@ -0,0 +1,18 @@
+
+int gcd_rec (int a, int b) {
+  if (b == 0) {
+    return a;
+  } else {
+    return gcd_rec (b, a % b);
+  }
+}
+
+int gcd_loop (int a, int b) {
+  int temp_b;
+  while (b != 0) {
+    temp_b = b;
+    b = a % b;
+    a = temp_b;
+  }
+  return a;
+}
diff --git a/code/train/C/0136771_ezlist.c b/code/train/C/0136771_ezlist.c
new file mode 100644
index 0000000000000000000000000000000000000000..3b29fd484661736a237bc7df1edce2faeadc00a8
--- /dev/null
+++ b/code/train/C/0136771_ezlist.c
@@ -0,0 +1,218 @@
+/* EZLIB - Library of useful routines for C programming
+ * 
+ * Copyright (C) 2008 Florian Schäfer <florian.schaefer@gmail.com>
+ * 
+ * This library may contain copyrighted material by:
+ *
+ * Peter Mattis, Spencer Kimball and Josh MacDonald,
+ * David Crawshaw, the GLib Team and others.
+ *
+ * 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 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "ezlist.h"
+
+EZList* ez_list_alloc () {
+
+    EZList *new_list;
+    new_list = ez_new0 (EZList, 1);    
+    return new_list;
+}
+
+EZList* ez_list_append (EZList *list, ezpointer data) {
+  
+    EZList *new_list;
+    EZList *last;
+
+    new_list = ez_list_alloc ();
+    new_list->data = data;
+
+    if (list) {
+        last = ez_list_last (list);
+        last->next = new_list;
+        new_list->prev = last;
+
+        return list;
+    } else {
+        return new_list;
+    }
+}
+
+EZList* ez_list_last (EZList *list) {
+
+    if (list) {
+        while (list->next)
+            list = list->next;
+    }
+
+    return list;
+}
+
+EZList* ez_list_first (EZList *list) {
+
+    if (list) {
+        while (list->prev)
+            list = list->prev;
+    }
+
+    return list;
+}
+
+size_t ez_list_length (EZList *list) {
+
+    size_t length;
+    length = 0;
+    
+    while (list) {
+        length++;
+        list = list->next;
+    }
+
+    return length;
+}
+
+void ez_list_free (EZList *list) {
+
+    EZList *last;
+
+    while (list) {
+        last = list;
+        list = list->next;
+        ez_free (last);
+    }
+}
+
+void ez_list_free_with_data (EZList *list, ez_list_free_func func) {
+    EZList *last;
+
+    while (list) {
+        last = list;
+        list = list->next;
+        if (func != NULL) {
+            func (last->data);
+        }
+        ez_free (last);
+    }
+}
+
+void ez_list_free_1 (EZList *list) {
+    ez_free (list);
+}
+
+EZList* ez_list_prepend (EZList *list, ezpointer data) {
+
+    EZList *new_list;
+
+    new_list = ez_list_alloc ();
+    new_list->data = data;
+
+    if (list) {
+        if (list->prev) {
+            list->prev->next = new_list;
+            new_list->prev = list->prev;
+        }
+        list->prev = new_list;
+        new_list->next = list;
+    }
+
+    return new_list;
+}
+
+EZList* ez_list_insert (EZList *list, ezpointer data, int position) {
+
+    EZList *new_list;
+    EZList *tmp_list;
+  
+    if (position < 0) {
+        return ez_list_append (list, data);
+    } else if (position == 0) {
+        return ez_list_prepend (list, data);
+    }
+
+    tmp_list = ez_list_nth (list, position);
+    
+    if (!tmp_list)
+        return ez_list_append (list, data);
+
+    new_list = ez_list_alloc ();
+    new_list->data = data;
+
+    if (tmp_list->prev) {
+        tmp_list->prev->next = new_list;
+        new_list->prev = tmp_list->prev;
+    }
+    
+    new_list->next = tmp_list;
+    tmp_list->prev = new_list;
+
+    if (tmp_list == list) {
+        return new_list;
+    } else {
+        return list;
+    }
+}
+
+EZList* ez_list_nth (EZList *list, uint n) {
+
+    while ((n-- > 0) && list) {
+        list = list->next;
+    }
+
+    return list;
+}
+
+EZList* ez_list_remove (EZList *list, ezpointer data) {
+
+    EZList *tmp;
+    tmp = list;
+
+    while (tmp) {
+        if (tmp->data != data) {
+            tmp = tmp->next;
+        } else {
+            if (tmp->prev) {
+                tmp->prev->next = tmp->next;
+            }
+            
+            if (tmp->next) {
+                tmp->next->prev = tmp->prev;
+            }
+
+            if (list == tmp) {
+                list = list->next;
+            }
+
+            ez_list_free_1 (tmp);
+        
+            break;
+        }
+    }
+    
+    return list;
+}
+
+void ez_list_foreach (EZList *list, ez_list_func func, ezpointer user_data) {
+
+    ez_return_if_fail (func != NULL);
+    
+    while (list) {
+        EZList *next = list->next;
+        if ((*func) (list->data, user_data) == false){
+            break;
+        }
+        list = next;
+    }
+}
diff --git a/code/train/C/0136915_fff_routines.c b/code/train/C/0136915_fff_routines.c
new file mode 100644
index 0000000000000000000000000000000000000000..44393e2f90ad7e7b87661a260ddb456ba1708781
--- /dev/null
+++ b/code/train/C/0136915_fff_routines.c
@@ -0,0 +1,172 @@
+#include "fff_routines.h"
+#include "fff_base.h"
+
+#include <randomkit.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+
+/* Draw k different values in the range [0..N-1] */  
+extern  void fff_rng_draw_noreplace (size_t *list, long k, long N)
+{
+  int i; 
+  rk_state state; 
+  rk_seed(1, &state);
+  
+  for (i=0; i<k ; i++)
+	list[i] = floor(N*rk_double(&state));
+}
+
+typedef struct{
+  double x; 
+  long i; 
+} dummy_struct;
+
+static int _dummy_struct_geq(const void * x, const void * y)
+{
+  int ans = -1; 
+  dummy_struct xx = *((dummy_struct*)x);
+  dummy_struct yy = *((dummy_struct*)y);
+
+  if ( xx.x > yy.x ) { 
+    ans = 1; 
+    return ans; 
+  }
+  if ( xx.x == yy.x ) 
+    ans = 0; 
+
+  return ans;  
+}
+
+extern void sort_ascending_and_get_permutation( double* x, long* idx, long n )
+{
+  long i; 
+  double *bufx;
+  dummy_struct* xx = (dummy_struct*)calloc( n, sizeof(dummy_struct) );  
+  dummy_struct* buf_xx; 
+  long* buf_idx; 
+
+  bufx = x; 
+  buf_idx = idx; 
+  buf_xx = xx; 
+  for ( i=0; i<n; i++, bufx++, buf_xx++ ) {
+    (*buf_xx).x = *bufx;
+    (*buf_xx).i = i; 
+  }
+
+  qsort ( xx, n, sizeof(dummy_struct), &_dummy_struct_geq );
+
+  bufx = x; 
+  buf_idx = idx; 
+  buf_xx = xx; 
+  for ( i=0; i<n; i++, bufx++, buf_idx++, buf_xx++ ) {
+    *bufx = (*buf_xx).x;
+    *buf_idx = (*buf_xx).i;
+  }
+
+  free( xx ); 
+  return; 
+}
+
+extern void sort_ascending(double *x, int n)
+{
+  long *idx = (long *) calloc (n,sizeof(long));
+  sort_ascending_and_get_permutation( x, idx,n);
+  free(idx);
+}
+
+
+
+extern long fff_array_argmax1d(const fff_array *farray)
+{
+  /* returns the index of the max value on a supposedly 1D array */
+  /* quick and dirty implementation */
+  long i,n = farray->dimX;
+  long idx = 0;
+  double val,max = (double) fff_array_get1d(farray,idx);
+  
+  for (i=0 ; i<n ; i++){
+	val = (double) fff_array_get1d(farray,i);
+	if (val>max){
+	  max = val;
+	  idx = i;
+	}
+  }
+  return idx;
+}
+
+extern long fff_array_argmin1d(const fff_array *farray)
+{
+  /*
+	returns the index of the max value on a supposedly 1D array 
+	quick and dirty implementation 
+  */
+  long i,n = farray->dimX;
+  long idx = 0;
+  double val,min = (double) fff_array_get1d(farray,idx);
+  
+  for (i=0 ; i<n ; i++){
+	val = (double) fff_array_get1d(farray,i);
+	if (val<min){
+	  min = val;
+	  idx = i;
+	}
+  }
+  return idx;
+}
+
+
+extern double fff_array_min1d(const fff_array *farray)
+{
+  /*
+	returns the index of the max value on a supposedly 1D array
+	quick and dirty implementation 
+  */
+  long i,n = farray->dimX;
+  double val,min = (double) fff_array_get1d(farray,0);
+  
+  for (i=0 ; i<n ; i++){
+	val = (double) fff_array_get1d(farray,i);
+	if (val<min)
+	  min = val;
+  }
+  return min;
+}
+
+extern double fff_array_max1d(const fff_array *farray)
+{
+  /*
+	returns the index of the max value on a supposedly 1D array
+   quick and dirty implementation
+  */
+  long i,n = farray->dimX;
+  double val,max = (double) fff_array_get1d(farray,0);
+  
+  for (i=0 ; i<n ; i++){
+	val = (double) fff_array_get1d(farray,i);
+	if (val>max)
+	  max = val;
+  }
+  return max;
+}
+
+
+extern int generate_normals(fff_matrix* nvariate, const fff_matrix * means, const fff_matrix * precision)
+{
+  rk_state state; 
+  int i,j;
+  double x,s,m;
+
+  rk_seed(1, &state);
+  
+  for (i=0 ; i<nvariate->size1 ; i++)
+	for (j=0 ; j<nvariate->size2 ; j++){
+	  s =  1.0/sqrt(fff_matrix_get(precision,i,j));
+	  m = fff_matrix_get(means,i,j);
+	  x = m + s*rk_gauss(&state);
+	  fff_matrix_set(nvariate,i,j,x);
+	}
+  
+  return(0);
+}
diff --git a/code/train/C/0137014_predict.c b/code/train/C/0137014_predict.c
new file mode 100644
index 0000000000000000000000000000000000000000..85ed067c6c17f5cb9f08dc6280d0201dbfb4f085
--- /dev/null
+++ b/code/train/C/0137014_predict.c
@@ -0,0 +1,243 @@
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include "linear.h"
+
+int print_null(const char *s,...) {return 0;}
+
+static int (*info)(const char *fmt,...) = &printf;
+
+struct feature_node *x;
+int max_nr_attr = 64;
+
+struct model* model_;
+int flag_predict_probability=0;
+
+void exit_input_error(int line_num)
+{
+	fprintf(stderr,"Wrong input format at line %d\n", line_num);
+	exit(1);
+}
+
+static char *line = NULL;
+static int max_line_len;
+
+static char* readline(FILE *input)
+{
+	int len;
+
+	if(fgets(line,max_line_len,input) == NULL)
+		return NULL;
+
+	while(strrchr(line,'\n') == NULL)
+	{
+		max_line_len *= 2;
+		line = (char *) realloc(line,max_line_len);
+		len = (int) strlen(line);
+		if(fgets(line+len,max_line_len-len,input) == NULL)
+			break;
+	}
+	return line;
+}
+
+void do_predict(FILE *input, FILE *output)
+{
+	int correct = 0;
+	int total = 0;
+	double error = 0;
+	double sump = 0, sumt = 0, sumpp = 0, sumtt = 0, sumpt = 0;
+
+	int nr_class=get_nr_class(model_);
+	double *prob_estimates=NULL;
+	int j, n;
+	int nr_feature=get_nr_feature(model_);
+	if(model_->bias>=0)
+		n=nr_feature+1;
+	else
+		n=nr_feature;
+
+	if(flag_predict_probability)
+	{
+		int *labels;
+
+		if(!check_probability_model(model_))
+		{
+			fprintf(stderr, "probability output is only supported for logistic regression\n");
+			exit(1);
+		}
+
+		labels=(int *) malloc(nr_class*sizeof(int));
+		get_labels(model_,labels);
+		prob_estimates = (double *) malloc(nr_class*sizeof(double));
+		fprintf(output,"labels");
+		for(j=0;j<nr_class;j++)
+			fprintf(output," %d",labels[j]);
+		fprintf(output,"\n");
+		free(labels);
+	}
+
+	max_line_len = 1024;
+	line = (char *)malloc(max_line_len*sizeof(char));
+	while(readline(input) != NULL)
+	{
+		int i = 0;
+		double target_label, predict_label;
+		char *idx, *val, *label, *endptr;
+		int inst_max_index = 0; // strtol gives 0 if wrong format
+
+		label = strtok(line," \t\n");
+		if(label == NULL) // empty line
+			exit_input_error(total+1);
+
+		target_label = strtod(label,&endptr);
+		if(endptr == label || *endptr != '\0')
+			exit_input_error(total+1);
+
+		while(1)
+		{
+			if(i>=max_nr_attr-2)    // need one more for index = -1
+			{
+				max_nr_attr *= 2;
+				x = (struct feature_node *) realloc(x,max_nr_attr*sizeof(struct feature_node));
+			}
+
+			idx = strtok(NULL,":");
+			val = strtok(NULL," \t");
+
+			if(val == NULL)
+				break;
+			errno = 0;
+			x[i].index = (int) strtol(idx,&endptr,10);
+			if(endptr == idx || errno != 0 || *endptr != '\0' || x[i].index <= inst_max_index)
+				exit_input_error(total+1);
+			else
+				inst_max_index = x[i].index;
+
+			errno = 0;
+			x[i].value = strtod(val,&endptr);
+			if(endptr == val || errno != 0 || (*endptr != '\0' && !isspace(*endptr)))
+				exit_input_error(total+1);
+
+			// feature indices larger than those in training are not used
+			if(x[i].index <= nr_feature)
+				++i;
+		}
+
+		if(model_->bias>=0)
+		{
+			x[i].index = n;
+			x[i].value = model_->bias;
+			i++;
+		}
+		x[i].index = -1;
+
+		if(flag_predict_probability)
+		{
+			int j;
+			predict_label = predict_probability(model_,x,prob_estimates);
+			fprintf(output,"%g",predict_label);
+			for(j=0;j<model_->nr_class;j++)
+				fprintf(output," %g",prob_estimates[j]);
+			fprintf(output,"\n");
+		}
+		else
+		{
+			predict_label = predict(model_,x);
+			fprintf(output,"%.17g\n",predict_label);
+		}
+
+		if(predict_label == target_label)
+			++correct;
+		error += (predict_label-target_label)*(predict_label-target_label);
+		sump += predict_label;
+		sumt += target_label;
+		sumpp += predict_label*predict_label;
+		sumtt += target_label*target_label;
+		sumpt += predict_label*target_label;
+		++total;
+	}
+	if(check_regression_model(model_))
+	{
+		info("Mean squared error = %g (regression)\n",error/total);
+		info("Squared correlation coefficient = %g (regression)\n",
+			((total*sumpt-sump*sumt)*(total*sumpt-sump*sumt))/
+			((total*sumpp-sump*sump)*(total*sumtt-sumt*sumt))
+			);
+	}
+	else
+		info("Accuracy = %g%% (%d/%d)\n",(double) correct/total*100,correct,total);
+	if(flag_predict_probability)
+		free(prob_estimates);
+}
+
+void exit_with_help()
+{
+	printf(
+	"Usage: predict [options] test_file model_file output_file\n"
+	"options:\n"
+	"-b probability_estimates: whether to output probability estimates, 0 or 1 (default 0); currently for logistic regression only\n"
+	"-q : quiet mode (no outputs)\n"
+	);
+	exit(1);
+}
+
+int main(int argc, char **argv)
+{
+	FILE *input, *output;
+	int i;
+
+	// parse options
+	for(i=1;i<argc;i++)
+	{
+		if(argv[i][0] != '-') break;
+		++i;
+		switch(argv[i-1][1])
+		{
+			case 'b':
+				flag_predict_probability = atoi(argv[i]);
+				break;
+			case 'q':
+				info = &print_null;
+				i--;
+				break;
+			default:
+				fprintf(stderr,"unknown option: -%c\n", argv[i-1][1]);
+				exit_with_help();
+				break;
+		}
+	}
+	if(i>=argc)
+		exit_with_help();
+
+	input = fopen(argv[i],"r");
+	if(input == NULL)
+	{
+		fprintf(stderr,"can't open input file %s\n",argv[i]);
+		exit(1);
+	}
+
+	output = fopen(argv[i+2],"w");
+	if(output == NULL)
+	{
+		fprintf(stderr,"can't open output file %s\n",argv[i+2]);
+		exit(1);
+	}
+
+	if((model_=load_model(argv[i+1]))==0)
+	{
+		fprintf(stderr,"can't open model file %s\n",argv[i+1]);
+		exit(1);
+	}
+
+	x = (struct feature_node *) malloc(max_nr_attr*sizeof(struct feature_node));
+	do_predict(input, output);
+	free_and_destroy_model(&model_);
+	free(line);
+	free(x);
+	fclose(input);
+	fclose(output);
+	return 0;
+}
+
diff --git a/code/train/C/0137034_datapool.c b/code/train/C/0137034_datapool.c
new file mode 100644
index 0000000000000000000000000000000000000000..1eb7e9c2c30a18d4e583f06e7f395d623d93f557
--- /dev/null
+++ b/code/train/C/0137034_datapool.c
@@ -0,0 +1,295 @@
+/****************************************************************************
+ *   Copyright (c) 2014 - 2015 Frédéric Bourgeois <bourgeoislab@gmail.com>  *
+ *                                                                          *
+ *   This file is part of OSC-webgate.                                      *
+ *                                                                          *
+ *   OSC-webgate 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.                        *
+ *                                                                          *
+ *   OSC-webgate 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 OSC-webgate. If not, see <http://www.gnu.org/licenses/>.    *
+ ****************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "datapool.h"
+#include "utils.h"
+
+#if OSC_EN
+  #include "osc.h"
+#endif
+
+/****************************************************************************/
+
+/** @brief Structure for a entry in the data-pool */
+typedef struct t_DataPoolEntry
+{
+    char *pVariable;                /**< pointer to the variable */
+    char *pValue;                   /**< pointer to the value */
+    struct t_DataPoolEntry *pNext;  /**< pointer to the next list entry */
+} T_DataPoolEntry, *PT_DataPoolEntry;
+
+/****************************************************************************/
+
+/** Initialization state of the data-pool */
+static int initialized = 0;
+
+/** Data-pool variable */
+static PT_DataPoolEntry pDataPool = NULL;
+
+/** Specify if new variables should be added on the fly if not found */
+static int allocOnTheFly = 0;
+
+/****************************************************************************/
+
+/**
+ * @brief Add a new entry in the data-pool.
+ * @param pVariable Variable name of the new entry
+ * @param pValue Value of the new entry
+ * @return Pointer to the new entry or NULL if out of memory.
+ */
+static PT_DataPoolEntry addEntry(const char *pVariable, const char *pValue)
+{
+    PT_DataPoolEntry pParent = pDataPool;
+    PT_DataPoolEntry pNext;
+
+    // go up to last entry
+    while (pParent)
+    {
+        if (pParent->pNext == NULL)
+            break;
+        pParent = pParent->pNext;
+    }
+
+    // allocate a new entry
+    pNext = SYS_malloc(sizeof(T_DataPoolEntry));
+    if (pNext)
+    {
+        pNext->pNext = NULL;
+        pNext->pVariable = SYS_malloc(strlen(pVariable) + 1);
+        if (pNext->pVariable)
+        {
+            pNext->pValue = SYS_malloc(DP_VALUE_LENGTH_MAX);
+            if (pNext->pValue)
+            {
+                strcpy(pNext->pVariable, pVariable);
+                strncpy(pNext->pValue, pValue, DP_VALUE_LENGTH_MAX - 1);
+                if (pParent)
+                    pParent->pNext = pNext;
+                else
+                    pDataPool = pNext;
+                return pNext;
+            }
+        }
+    }
+    return NULL;
+}
+
+/**
+ * @brief Callback function when loading configuration file.
+ * @param pParameter Parameter
+ * @param pValue Value
+ * @return 1 if the line is valid else 0
+ */
+static int callback_initFromFile(char *pParameter, char* pValue)
+{
+    addEntry(pParameter, pValue);
+  #if OSC_EN
+    if (strncmp(app.osc_prefix, pParameter, strlen(app.osc_prefix)) == 0)
+    {
+        T_OSC_ArgType arg = OSC_getArgType(pValue);
+        OSC_appendMessage(pParameter, 1, &arg);
+    }
+  #endif
+    return 1;
+}
+
+/****************************************************************************/
+
+/**
+ */
+int DP_init(const char *pFileName, int onTheFlyAllocation)
+{
+    int ret = 0;
+
+    // check if already initialized
+    if (initialized)
+        return 0;
+
+    // initialize variables from a file
+    if (pFileName)
+    {
+
+      #if OSC_EN
+        OSC_initMessages(1);
+      #endif
+
+        ret = getConfigFromFile(pFileName, "["CONFIG_SECTION_DATAPOOL"]", callback_initFromFile);
+
+      #if OSC_EN
+        OSC_sendMessages(app.osc_host, app.osc_port);
+      #endif
+    }
+
+    // initialize system data-pool
+    DPSYSTEM_init();
+
+    // set on the fly allocation mode
+    allocOnTheFly = onTheFlyAllocation;
+
+    // set initialized flag
+    initialized = 1;
+
+    // initialize user data-pool
+    DPUSER_init();
+
+    return ret;
+}
+
+/**
+ */
+void DP_deinit(void)
+{
+    PT_DataPoolEntry pDel;
+    PT_DataPoolEntry pData = pDataPool;
+
+    // check if initialized
+    if (!initialized)
+        return;
+
+    // de-initialize user data-pool
+    DPUSER_deinit();
+
+    // de-initialize system data-pool
+    DPSYSTEM_deinit();
+
+    // clear initialized flag
+    initialized = 0;
+
+    // free all allocated memory
+    while (pData)
+    {
+        pDel = pData;
+        pData = pData->pNext;
+        SYS_free(pDel->pValue);
+        SYS_free(pDel->pVariable);
+        SYS_free(pDel);
+    }
+}
+
+/**
+ */
+void DP_refresh(void)
+{
+    // refresh system data-pool
+    DPSYSTEM_refresh();
+
+    // refresh user data-pool
+    DPUSER_refresh();
+}
+
+/**
+ */
+const char* DP_getValue(const char *pVariable)
+{
+    const char *pValue = "";
+    PT_DataPoolEntry pData = pDataPool;
+
+    // check if initialized
+    if (!initialized)
+        return pValue;
+
+    // look for entry in system data-pool
+    pValue = DPSYSTEM_getValue(pVariable);
+    if (pValue)
+    {
+        // Do nothing
+    }
+    else if (strncmp(app.user_prefix, pVariable, strlen(app.user_prefix)) == 0)
+    {
+        // look for entry in user data-pool
+        pValue = DPUSER_getValue(pVariable);
+    }
+    else
+    {
+        // look for entry in data-pool
+        while (pData)
+        {
+            if (strcmp(pData->pVariable, pVariable) == 0)
+            {
+                pValue = pData->pValue;
+                break;
+            }
+            pData = pData->pNext;
+        }
+
+        // add new entry
+        if (allocOnTheFly && pData == NULL)
+        {
+            pData = addEntry(pVariable, "");
+            pValue = pData->pValue;
+        }
+    }
+    return pValue;
+}
+
+/**
+ */
+void DP_setValue(const char *pVariable, const char *pValue)
+{
+    PT_DataPoolEntry pData = pDataPool;
+
+    // check if initialized
+    if (!initialized)
+        return;
+
+    // look for entry in system data-pool
+    if (DPSYSTEM_setValue(pVariable, pValue))
+    {
+        // Do nothing
+    }
+    else if (strncmp(app.user_prefix, pVariable, strlen(app.user_prefix)) == 0)
+    {
+        // look for entry in user data-pool
+        DPUSER_setValue(pVariable, pValue);
+    }
+    else
+    {
+        // look for entry in data-pool
+        while (pData)
+        {
+            if (strcmp(pData->pVariable, pVariable) == 0)
+            {
+                // update value
+                strncpy(pData->pValue, pValue, DP_VALUE_LENGTH_MAX - 1);
+                break;
+            }
+            pData = pData->pNext;
+        }
+
+        // add new entry
+        if (allocOnTheFly && pData == NULL)
+        {
+            pData = addEntry(pVariable, pValue);
+        }
+    }
+
+  #if OSC_EN
+    // route new value to OSC host
+    if (strncmp(app.osc_prefix, pVariable, strlen(app.osc_prefix)) == 0)
+    {
+        T_OSC_ArgType arg = OSC_getArgType(pValue);
+        OSC_initMessages(0);
+        OSC_appendMessage(pVariable, 1, &arg);
+        OSC_sendMessages(app.osc_host, app.osc_port);
+    }
+  #endif
+}
diff --git a/code/train/C/0137195_process_info.c b/code/train/C/0137195_process_info.c
new file mode 100644
index 0000000000000000000000000000000000000000..a165e03904aaf6a77635a8ed7d580236ffaf3b3c
--- /dev/null
+++ b/code/train/C/0137195_process_info.c
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * Helper functions related to fetching process information.
+ * Used by _psutil_osx module methods.
+ */
+
+
+#include <Python.h>
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>  // for INT_MAX
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/sysctl.h>
+#include <libproc.h>
+
+#include "process_info.h"
+#include "../../_psutil_common.h"
+
+
+/*
+ * Return 1 if PID exists in the current process list, else 0.
+ */
+int
+psutil_pid_exists(long pid) {
+    int kill_ret;
+
+    // save some time if it's an invalid PID
+    if (pid < 0)
+        return 0;
+    // if kill returns success of permission denied we know it's a valid PID
+    kill_ret = kill(pid , 0);
+    if ( (0 == kill_ret) || (EPERM == errno))
+        return 1;
+
+    // otherwise return 0 for PID not found
+    return 0;
+}
+
+
+/*
+ * Returns a list of all BSD processes on the system.  This routine
+ * allocates the list and puts it in *procList and a count of the
+ * number of entries in *procCount.  You are responsible for freeing
+ * this list (use "free" from System framework).
+ * On success, the function returns 0.
+ * On error, the function returns a BSD errno value.
+ */
+int
+psutil_get_proc_list(kinfo_proc **procList, size_t *procCount) {
+    // Declaring mib as const requires use of a cast since the
+    // sysctl prototype doesn't include the const modifier.
+    static const int mib3[3] = { CTL_KERN, KERN_PROC, KERN_PROC_ALL };
+    size_t           size, size2;
+    void            *ptr;
+    int              err, lim = 8;  // some limit
+
+    assert( procList != NULL);
+    assert(*procList == NULL);
+    assert(procCount != NULL);
+
+    *procCount = 0;
+
+    /*
+     * We start by calling sysctl with ptr == NULL and size == 0.
+     * That will succeed, and set size to the appropriate length.
+     * We then allocate a buffer of at least that size and call
+     * sysctl with that buffer.  If that succeeds, we're done.
+     * If that call fails with ENOMEM, we throw the buffer away
+     * and try again.
+     * Note that the loop calls sysctl with NULL again.  This is
+     * is necessary because the ENOMEM failure case sets size to
+     * the amount of data returned, not the amount of data that
+     * could have been returned.
+     */
+    while (lim-- > 0) {
+        size = 0;
+        if (sysctl((int *)mib3, 3, NULL, &size, NULL, 0) == -1)
+            return errno;
+        size2 = size + (size >> 3);  // add some
+        if (size2 > size) {
+            ptr = malloc(size2);
+            if (ptr == NULL)
+                ptr = malloc(size);
+            else
+                size = size2;
+        }
+        else {
+            ptr = malloc(size);
+        }
+        if (ptr == NULL)
+            return ENOMEM;
+
+        if (sysctl((int *)mib3, 3, ptr, &size, NULL, 0) == -1) {
+            err = errno;
+            free(ptr);
+            if (err != ENOMEM)
+                return err;
+        }
+        else {
+            *procList = (kinfo_proc *)ptr;
+            *procCount = size / sizeof(kinfo_proc);
+            return 0;
+        }
+    }
+    return ENOMEM;
+}
+
+
+// Read the maximum argument size for processes
+int
+psutil_get_argmax() {
+    int argmax;
+    int mib[] = { CTL_KERN, KERN_ARGMAX };
+    size_t size = sizeof(argmax);
+
+    if (sysctl(mib, 2, &argmax, &size, NULL, 0) == 0)
+        return argmax;
+    return 0;
+}
+
+
+// return process args as a python list
+PyObject *
+psutil_get_cmdline(long pid) {
+    int mib[3];
+    int nargs;
+    int len;
+    char *procargs = NULL;
+    char *arg_ptr;
+    char *arg_end;
+    char *curr_arg;
+    size_t argmax;
+
+    PyObject *py_arg = NULL;
+    PyObject *py_retlist = NULL;
+
+    // special case for PID 0 (kernel_task) where cmdline cannot be fetched
+    if (pid == 0)
+        return Py_BuildValue("[]");
+
+    // read argmax and allocate memory for argument space.
+    argmax = psutil_get_argmax();
+    if (! argmax) {
+        PyErr_SetFromErrno(PyExc_OSError);
+        goto error;
+    }
+
+    procargs = (char *)malloc(argmax);
+    if (NULL == procargs) {
+        PyErr_SetFromErrno(PyExc_OSError);
+        goto error;
+    }
+
+    // read argument space
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROCARGS2;
+    mib[2] = pid;
+    if (sysctl(mib, 3, procargs, &argmax, NULL, 0) < 0) {
+        if (EINVAL == errno) {
+            // EINVAL == access denied OR nonexistent PID
+            if (psutil_pid_exists(pid))
+                AccessDenied();
+            else
+                NoSuchProcess();
+        }
+        goto error;
+    }
+
+    arg_end = &procargs[argmax];
+    // copy the number of arguments to nargs
+    memcpy(&nargs, procargs, sizeof(nargs));
+
+    arg_ptr = procargs + sizeof(nargs);
+    len = strlen(arg_ptr);
+    arg_ptr += len + 1;
+
+    if (arg_ptr == arg_end) {
+        free(procargs);
+        return Py_BuildValue("[]");
+    }
+
+    // skip ahead to the first argument
+    for (; arg_ptr < arg_end; arg_ptr++) {
+        if (*arg_ptr != '\0')
+            break;
+    }
+
+    // iterate through arguments
+    curr_arg = arg_ptr;
+    py_retlist = Py_BuildValue("[]");
+    if (!py_retlist)
+        goto error;
+    while (arg_ptr < arg_end && nargs > 0) {
+        if (*arg_ptr++ == '\0') {
+            py_arg = Py_BuildValue("s", curr_arg);
+            if (!py_arg)
+                goto error;
+            if (PyList_Append(py_retlist, py_arg))
+                goto error;
+            Py_DECREF(py_arg);
+            // iterate to next arg and decrement # of args
+            curr_arg = arg_ptr;
+            nargs--;
+        }
+    }
+
+    free(procargs);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_arg);
+    Py_XDECREF(py_retlist);
+    if (procargs != NULL)
+        free(procargs);
+    return NULL;
+}
+
+
+int
+psutil_get_kinfo_proc(pid_t pid, struct kinfo_proc *kp) {
+    int mib[4];
+    size_t len;
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC;
+    mib[2] = KERN_PROC_PID;
+    mib[3] = pid;
+
+    // fetch the info with sysctl()
+    len = sizeof(struct kinfo_proc);
+
+    // now read the data from sysctl
+    if (sysctl(mib, 4, kp, &len, NULL, 0) == -1) {
+        // raise an exception and throw errno as the error
+        PyErr_SetFromErrno(PyExc_OSError);
+        return -1;
+    }
+
+    // sysctl succeeds but len is zero, happens when process has gone away
+    if (len == 0) {
+        NoSuchProcess();
+        return -1;
+    }
+    return 0;
+}
+
+
+/*
+ * A thin wrapper around proc_pidinfo()
+ */
+int
+psutil_proc_pidinfo(long pid, int flavor, void *pti, int size) {
+    int ret = proc_pidinfo((int)pid, flavor, 0, pti, size);
+    if (ret == 0) {
+        if (! psutil_pid_exists(pid)) {
+            NoSuchProcess();
+            return 0;
+        }
+        else {
+            AccessDenied();
+            return 0;
+        }
+    }
+    else if (ret != size) {
+        AccessDenied();
+        return 0;
+    }
+    else {
+        return 1;
+    }
+}
diff --git a/code/train/C/0137259_cbuf.c b/code/train/C/0137259_cbuf.c
new file mode 100644
index 0000000000000000000000000000000000000000..b8bd246d95d4c30656cc9ed4e91fcc20f90889b2
--- /dev/null
+++ b/code/train/C/0137259_cbuf.c
@@ -0,0 +1,280 @@
+/*
+ * Copyright 2010-2015 National ICT Australia (NICTA)
+ *
+ * This software may be used and distributed solely under the terms of
+ * the MIT license (License).  You should find a copy of the License in
+ * COPYING or at http://opensource.org/licenses/MIT. By downloading or
+ * using this software you accept the terms and the liability disclaimer
+ * in the License.
+ */
+/** \file cbuf.c
+ * \brief A FIFO implementation used by the proxy that uses a circular list of pages to manage the memory.
+ * 
+ * It always writes in the tail buffer and always reads from the read buffer;
+ * tail->next points back to the start of the buffer:
+ * 
+ * \verbatim
+ *  +------------------------------------------+
+ *  V                                          |
+ * [X] -> [X] -> ... [X] -> ... -> [X] -> [X] -+
+ *                    ^                    ^
+ *                    |_ read              |_ tail
+ * \endverbatim
+ *
+ * When the tail buffer fills up, add a new one after tail, link the
+ * new tail to the head, and keep writing.
+ *
+ * To remove a buffer from the head, link the tail to the next one.
+ *
+ * Could also implement this as a circular chain where beyond a certain
+ * size the chain does not expand, by having an empty flag on the nodes
+ * and allowing the tail to process, rather than inserting new nodes at
+ * the tail.
+ */
+#include <stdlib.h>
+#include <string.h>
+
+#include "mem.h"
+#include "cbuf.h"
+
+#define CBUFFER_DEFAULT_SIZE 1024
+
+CBuffer*
+cbuf_create(int default_size)
+{
+  CBuffer *cbuf = NULL;
+  if (default_size <= 0)
+    default_size = CBUFFER_DEFAULT_SIZE;
+
+  cbuf = oml_malloc (sizeof (CBuffer));
+
+  if (cbuf == NULL)
+    return NULL;
+
+  cbuf->page_size = default_size;
+
+  if (cbuf_add_page (cbuf, -1) == -1) {
+    oml_free (cbuf);
+    return NULL;
+  }
+
+  return cbuf;
+}
+
+void
+cbuf_destroy (CBuffer *cbuf)
+{
+  if (cbuf == NULL)
+    return;
+
+  if (cbuf->tail != NULL) {
+    struct cbuffer_page *head, *current, *next;
+    current = cbuf->tail;
+    head = cbuf->tail->next;
+
+    do {
+      if (current->buf)
+        oml_free (current->buf);
+      next = current->next;
+      oml_free (current);
+      current = next;
+    } while (current != NULL && current != head);
+  }
+  oml_free (cbuf);
+}
+
+int
+cbuf_add_page (CBuffer *cbuf, int size)
+{
+  struct cbuffer_page *page;
+
+  if (cbuf == NULL)
+    return -1;
+
+  if (size <= 0)
+    size = cbuf->page_size;
+
+  page = oml_malloc (sizeof (struct cbuffer_page));
+
+  if (page == NULL)
+    return -1;
+
+  page->buf = oml_malloc (size);
+
+  if (page->buf == NULL) {
+    oml_free (page);
+    return -1;
+  }
+
+  page->empty = 1;
+  page->fill = 0;
+  page->size = size;
+  page->read = 0;
+  page->next = NULL;
+
+  if (cbuf->tail == NULL) {
+    cbuf->tail = page;
+    cbuf->read = page;
+    cbuf->tail->next = cbuf->tail;
+  } else {
+    struct cbuffer_page *head = cbuf->tail->next;
+    cbuf->tail->next = page;
+    cbuf->tail = page;
+    cbuf->tail->next = head;
+  }
+  return 0;
+}
+
+int
+cbuf_write (CBuffer *cbuf, char *buf, size_t size)
+{
+  int count = 0;
+
+  if (cbuf == NULL || buf == NULL)
+    return -1;
+
+  do {
+    struct cbuffer_page *page = cbuf->tail;
+    size_t remain = (page->size - page->fill);
+    size_t to_write = size < remain ? size : remain;
+
+    memcpy (&page->buf[page->fill], buf + count, to_write);
+    page->empty = 0;
+    page->fill += to_write;
+    count += to_write;
+
+    if (size > to_write) {
+      if (page->next->empty) {
+        cbuf->tail = page->next;
+      } else {
+        if (cbuf_add_page (cbuf, -1) == -1) {
+          break;
+        }
+      }
+    }
+    size -= to_write;
+  } while (size > 0);
+
+  return count;
+}
+
+/**
+ *  Get a cursor pointing to the current write position in the buffer
+ *  chain.
+ */
+
+void
+cbuf_write_cursor (CBuffer *cbuf, struct cbuffer_cursor *cursor)
+{
+  if (cbuf == NULL || cursor == NULL)
+    return;
+
+  cursor->page = cbuf->tail;
+  cursor->index = cursor->page->fill;
+}
+
+/**
+ *  Get a cursor pointing to the current read position in the buffer
+ *  chain.  Returns the number of bytes between the cursor position
+ *  and the end of the page the cursor points to.
+ *
+ */
+int
+cbuf_read_cursor (CBuffer *cbuf, struct cbuffer_cursor *cursor, size_t n)
+{
+  if (cbuf == NULL || cursor == NULL)
+    return -1;
+
+  cursor->page = cbuf->read;
+  cursor->index = cursor->page->read;
+
+  size_t remainder = cursor->page->fill - cursor->index;
+
+  if (remainder < n)
+    return remainder;
+  else
+    return n;
+}
+
+char*
+cbuf_cursor_pointer (struct cbuffer_cursor *cursor)
+{
+  return cursor->page->buf + cursor->index;
+}
+
+/**
+ *  Get the number of bytes remaining on the page following the
+ *  cursor.
+ */
+size_t
+cbuf_cursor_page_remaining (struct cbuffer_cursor *cursor)
+{
+  return cursor->page->fill - cursor->index;
+}
+
+
+/*
+ * Advance the cursor, but don't mark the page as empty if we go past the end.
+ */
+int
+cbuf_advance_cursor (struct cbuffer_cursor *cursor, size_t n)
+{
+  int count = 0;
+  do {
+    size_t page_remaining = cbuf_cursor_page_remaining (cursor);
+    size_t to_consume = n < page_remaining ? n : page_remaining;
+    count += to_consume;
+    cursor->index += to_consume;
+    n -= to_consume;
+
+    /* If we've read to the end of this page, skip to the next page */
+    if (cursor->index == cursor->page->fill) {
+      /* Advance to the next page */
+      cursor->page = cursor->page->next;
+      cursor->index = 0;
+    }
+  } while (n > 0);
+
+  return count;
+}
+
+/**
+ * a
+ */
+int
+cbuf_consume_cursor (struct cbuffer_cursor *cursor, size_t n)
+{
+  int count = 0;
+  do {
+    size_t page_remaining = cbuf_cursor_page_remaining (cursor);
+    size_t to_consume = n < page_remaining ? n : page_remaining;
+    count += to_consume;
+    cursor->index += to_consume;
+    n -= to_consume;
+
+    /* If we've read to the end of this page, skip to the next page */
+    if (cursor->index == cursor->page->fill) {
+      /* Reset the current page to empty */
+      cursor->page->empty = 1;
+      cursor->page->read = 0;
+      cursor->page->fill = 0;
+
+      /* Advance to the next page */
+      cursor->page = cursor->page->next;
+      cursor->index = 0;
+    }
+  } while (n > 0);
+
+  cursor->page->read = cursor->index;
+  //  cbuf->read = cursor->page; /* Not sure about this */
+  return count;
+}
+
+/*
+ Local Variables:
+ mode: C
+ tab-width: 2
+ indent-tabs-mode: nil
+ End:
+ vim: sw=2:sts=2:expandtab
+*/
diff --git a/code/train/C/0137546_io.c b/code/train/C/0137546_io.c
new file mode 100644
index 0000000000000000000000000000000000000000..c923c035faf881cd5b6842aecd7f0fac67d6f3ac
--- /dev/null
+++ b/code/train/C/0137546_io.c
@@ -0,0 +1,245 @@
+/*
+ * io.c -- Packaged I/O routines.
+ *
+ * **********************************************
+ * CMU ARPA Speech Project
+ *
+ * Copyright (c) 1996 Carnegie Mellon University.
+ * ALL RIGHTS RESERVED.
+ * **********************************************
+ * 
+ * HISTORY
+ * 
+ * 05-Sep-97	M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
+ * 		Started.
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "prim_type.h"
+#include "err.h"
+#include "io.h"
+
+
+FILE *fopen_comp (char *file, char *mode, int32 *ispipe)
+{
+    char command[16384];
+    FILE *fp;
+    int32 k, isgz;
+    
+    k = strlen (file);
+ /*   
+#if (WIN32)
+    *ispipe = (k > 3) &&
+	((strcmp (file+k-3, ".gz") == 0) || (strcmp (file+k-3, ".GZ") == 0));
+    isgz = *ispipe;
+#else
+
+    *ispipe = 0;
+    isgz = 0;
+    if ((k > 2) && ((strcmp (file+k-2, ".Z") == 0) || (strcmp (file+k-2, ".z") == 0))) {
+	*ispipe = 1;
+    } else {
+	if ((k > 3) &&
+	    ((strcmp (file+k-3, ".gz") == 0) || (strcmp (file+k-3, ".GZ") == 0))) {
+	    *ispipe = 1;
+	    isgz = 1;
+	}
+    }
+#endif
+
+    if (*ispipe) {
+#if (WIN32)
+	if (strcmp (mode, "r") == 0) {
+	    sprintf (command, "gzip.exe -d -c %s", file);
+	    if ((fp = _popen (command, mode)) == NULL) {
+		E_ERROR_SYSTEM("_popen (%s,%s) failed\n", command, mode);
+		return NULL;
+	    }
+	} else {
+	    E_ERROR ("fopen_comp not implemented for mode = %s\n", mode);
+	    return NULL;
+	}
+#else
+	if (strcmp (mode, "r") == 0) {
+	    if (isgz)
+		sprintf (command, "gunzip -c %s", file);
+	    else
+		sprintf (command, "zcat %s", file);
+	    
+	    if ((fp = popen (command, mode)) == NULL) {
+		E_ERROR_SYSTEM("popen (%s,%s) failed\n", command, mode);
+		return NULL;
+	    }
+	} else if (strcmp (mode, "w") == 0) {
+	    if (isgz)
+		sprintf (command, "gzip > %s", file);
+	    else
+		sprintf (command, "compress -c > %s", file);
+	    
+	    if ((fp = popen (command, mode)) == NULL) {
+		E_ERROR_SYSTEM("popen (%s,%s) failed\n", command, mode);
+		return NULL;
+	    }
+	} else {
+	    E_ERROR ("fopen_comp not implemented for mode = %s\n", mode);
+	    return NULL;
+	}
+#endif
+    } else
+*/ //1/20/04 Ed needed for Msim
+    {
+        fp = fopen (file, mode);
+    }
+
+    return (fp);
+}
+
+
+void fclose_comp (FILE *fp, int32 ispipe)
+{
+//1/20/04 Ed
+/*
+    if (ispipe) {
+#if (WIN32)
+	_pclose (fp);
+#else
+	pclose (fp);
+#endif
+    } else
+*/
+	fclose (fp);
+}
+
+
+FILE *fopen_compchk (char *file, int32 *ispipe)
+{
+    char tmpfile[16384];
+    FILE *fp;
+    int32 k, isgz;
+    struct stat statbuf;
+    
+    k = strlen (file);
+    
+#if (WIN32)
+    *ispipe = (k > 3) &&
+	((strcmp (file+k-3, ".gz") == 0) || (strcmp (file+k-3, ".GZ") == 0));
+    isgz = *ispipe;
+#else
+    *ispipe = 0;
+    isgz = 0;
+    if ((k > 2) && ((strcmp (file+k-2, ".Z") == 0) || (strcmp (file+k-2, ".z") == 0))) {
+	*ispipe = 1;
+    } else {
+	if ((k > 3) &&
+	    ((strcmp (file+k-3, ".gz") == 0) || (strcmp (file+k-3, ".GZ") == 0))) {
+	    *ispipe = 1;
+	    isgz = 1;
+	}
+    }
+#endif
+    
+    strcpy (tmpfile, file);
+    if (stat (tmpfile, &statbuf) != 0) {
+	/* File doesn't exist; try other compressed/uncompressed form, as appropriate */
+	E_ERROR_SYSTEM("stat(%s) failed\n", tmpfile);
+	
+	if (*ispipe) {
+	    if (isgz)
+		tmpfile[k-3] = '\0';
+	    else
+		tmpfile[k-2] = '\0';
+	    
+	    if (stat (tmpfile, &statbuf) != 0)
+		return NULL;
+	} else {
+	    strcpy (tmpfile+k, ".gz");
+	    if (stat (tmpfile, &statbuf) != 0) {
+#if (! WIN32)
+		strcpy (tmpfile+k, ".Z");
+		if (stat (tmpfile, &statbuf) != 0)
+		    return NULL;
+#else
+		return NULL;
+#endif
+	    }
+	}
+	
+	E_WARN("Using %s instead of %s\n", tmpfile, file);
+    }
+    
+    return (fopen_comp (tmpfile, "r", ispipe));
+}
+
+
+#define FREAD_RETRY_COUNT	60
+
+int32 fread_retry(void *pointer, int32 size, int32 num_items, FILE *stream)
+{
+    char *data;
+    uint32 n_items_read;
+    uint32 n_items_rem;
+    uint32 n_retry_rem;
+    int32 loc;
+
+    n_retry_rem = FREAD_RETRY_COUNT;
+
+    
+	data = pointer;
+    loc = 0;
+    n_items_rem = num_items;
+	
+    do {
+	n_items_read = fread(&data[loc], size, n_items_rem, stream);
+
+	n_items_rem -= n_items_read;
+
+	if (n_items_rem > 0) {
+	    /* an incomplete read occurred */
+
+	    if (n_retry_rem == 0)
+		return -1;
+
+	    if (n_retry_rem == FREAD_RETRY_COUNT) {
+		E_ERROR_SYSTEM("fread() failed; retrying...\n");
+	    }
+
+	    --n_retry_rem;
+	    
+	    loc += n_items_read * size;
+#if (! WIN32)
+//1/20/03 Ed 
+//	    sleep(1);
+#endif
+	}
+    } while (n_items_rem > 0);
+
+    return num_items;
+}
+
+
+#define STAT_RETRY_COUNT	10
+
+int32 stat_retry (char *file, struct stat *statbuf)
+{
+    int32 i;
+    
+    for (i = 0; i < STAT_RETRY_COUNT; i++) {
+	if (stat (file, statbuf) == 0)
+	    return 0;
+	
+	if (i == 0) {
+	    E_ERROR_SYSTEM("stat(%s) failed; retrying...\n", file);
+	}
+#if (! WIN32)
+//1/20/03 Ed 
+//	sleep (10);
+#endif
+    }
+    
+    return -1;
+}
diff --git a/code/train/C/0137573_scheduler.c b/code/train/C/0137573_scheduler.c
new file mode 100644
index 0000000000000000000000000000000000000000..c86c2fbf69800e97e98fa1bce4caaa3d64d7b31c
--- /dev/null
+++ b/code/train/C/0137573_scheduler.c
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "scheduler.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+base_frame* make_frame(void* derived_frame, int derived_frame_type) {
+  base_frame* frame = malloc(sizeof(base_frame));
+  init_frame(frame, derived_frame, derived_frame_type);
+  return frame;
+}
+
+void init_frame(base_frame* frame, void* derived_frame,
+                int derived_frame_type) {
+  frame->pc = 0;
+  frame->derived_frame = derived_frame;
+  frame->derived_frame_type = derived_frame_type;
+}
+
+int execute_schedule(uint8_t* schedule, size_t schedule_len, base_frame* frames,
+                     int num_frames, int max_context_switches) {
+  int num_context_switches = 0;
+  int num_done = 0;
+  uint8_t previous_op = schedule[0];
+  uint8_t current_op = previous_op;
+  assert(schedule != NULL);
+  bool frame_done = false; /* Tracks whether the last step ended a frame. */
+  for (size_t schedule_idx = 0;
+       schedule_idx < schedule_len && num_done < num_frames; ++schedule_idx) {
+    current_op = schedule[schedule_idx];
+    if (current_op != previous_op && !frame_done) {
+      ++num_context_switches;
+      if (num_context_switches > max_context_switches) {
+        return num_context_switches;
+      }
+    }
+    previous_op = current_op;
+
+    base_frame* frame = &frames[current_op];
+    if (frame->pc == PC_DONE) {
+      continue;
+    } else {
+      frame_done = false;
+      int next_pc = step(frame);
+      frame->pc = next_pc;
+      if (next_pc == PC_DONE) {
+        frame_done = true;
+        ++num_done;
+      } else if (next_pc == PC_ABORT) {
+        break;
+      }
+    }
+  }
+  return num_context_switches;
+}
diff --git a/code/train/C/0137707_peaje.c b/code/train/C/0137707_peaje.c
new file mode 100644
index 0000000000000000000000000000000000000000..a83d791ae630352aad78bda07062a02c9eefed42
--- /dev/null
+++ b/code/train/C/0137707_peaje.c
@@ -0,0 +1,145 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ipc.h>
+#include <sys/sem.h>
+#include <sys/shm.h>
+#include <sys/msg.h>
+#include <time.h>
+#include <string.h>
+#include <pthread.h>
+#include "mq.h"
+#include "common.h"
+#define CANT_MAX_VIAS 5
+#define MIN_N 1
+#define MAX_N 4
+
+typedef struct via
+{
+	int nro;						
+	int msqid;
+    int cantidadLiberaciones;
+}t_via;
+
+void validaParametrosInput(int argc, char *argv[]);
+void *ThreadVia(void *threadParam);
+
+
+int main(int argc, char *argv[])
+{
+    validaParametrosInput(argc, argv);
+
+    t_via *datos_thread;
+    int cantVias = atoi(argv[1]);
+    int i=0;
+    random_init();
+
+    int msqid = createMessageQueue(2487);
+    
+    pthread_t* idHilo = (pthread_t* ) malloc(sizeof(pthread_t)*cantVias);
+	pthread_attr_t 	atributos;
+	pthread_attr_init (&atributos);
+    pthread_attr_setdetachstate (&atributos, PTHREAD_CREATE_JOINABLE);
+    
+    datos_thread = (t_via*) malloc(sizeof(t_via)*cantVias);
+	
+	for(i=0; i <cantVias; i++)
+	{
+		datos_thread[i].nro = i+1;
+		datos_thread[i].msqid = msqid;
+        datos_thread[i].cantidadLiberaciones = 0;
+		
+		pthread_create (&idHilo[i], &atributos, ThreadVia, &datos_thread[i]);
+	}
+
+	int totalLiberaciones = 0;
+	for(i=0; i < cantVias; i++)
+	{
+		pthread_join (idHilo[i], NULL);
+        printf("\nRecibi de la via %d %d liberaciones",i+1, datos_thread[i].cantidadLiberaciones);
+        totalLiberaciones+= datos_thread[i].cantidadLiberaciones;
+    }			
+    		
+	printf("\nTOTAL %d\n", totalLiberaciones);
+    return 0;
+}
+
+
+//Declaracion de funciones
+
+void validaParametrosInput(int argc, char *argv[])
+{
+    if (argc != 2)
+    {
+        printf("\nDebe recibir el número de vias\n\n");
+        exit(1);
+    }
+    
+    int val = atoi(argv[1]);
+
+    if (val < 1 || val > CANT_MAX_VIAS)
+    {
+        printf("\nEl nro de vias no cumple con los permitidos\n\n");
+        exit(1);
+    }
+}
+
+
+
+void *ThreadVia(void *threadParam)
+{
+    int cantAutosEnCola = 0;
+    int cantLiberaciones = 0;
+    t_via* viaParam = (t_via*)threadParam;
+    
+    int nroVia = viaParam->nro;
+    int msqid = viaParam->msqid;
+    
+    int done = 0;
+    random_init();
+    printf("\nthread %d", nroVia);
+
+    while (done == 0)
+    {
+        Message msg;
+
+        printf("\nSoy Via %d y Tengo %d Autos", nroVia, cantAutosEnCola);
+        recvMessageQueue(msqid, MSG_VIAS + nroVia, &msg);
+
+        switch(msg.event)
+        {
+            case EVT_NINGUNO:
+                break;
+            case EVT_VEHICULOS:
+                cantAutosEnCola += msg.info.cantidad;
+                int descuenta = random_generate(MIN_N, MAX_N);
+
+                if(cantAutosEnCola > 10)
+                {
+                    printf("\n Abrir Barreras!!");
+                    cantAutosEnCola = 0;
+                    cantLiberaciones++;
+                }
+                else
+                {
+                    if(cantAutosEnCola - descuenta > 0)
+                    {
+                        cantAutosEnCola = cantAutosEnCola - descuenta;
+                    }
+                    else
+                    {
+                        cantAutosEnCola = 0;
+                    }
+                }
+                
+                break;
+            case EVT_FINALIZAR:
+                done = 1;
+                break;
+        }
+        usleep(100 * 1000);
+    }
+    
+    viaParam->cantidadLiberaciones = cantLiberaciones;
+    pthread_exit ((void *)"Listo");
+}
\ No newline at end of file
diff --git a/code/train/C/0137778_bookmarks.c b/code/train/C/0137778_bookmarks.c
new file mode 100644
index 0000000000000000000000000000000000000000..564041ab9cbc899f291909cbd29c1fd2c68d3b65
--- /dev/null
+++ b/code/train/C/0137778_bookmarks.c
@@ -0,0 +1,498 @@
+/*
+ *	bookmarks.c
+ *
+ *	(C) Copyright 1999-2005 Jan van den Baard.
+ *	    All Rights Reserved.
+ *
+ */
+
+#include "defs.h"
+
+void SetBookmark( LPCLASSDATA lpcd )
+{
+	LPLINE		lpLine = GETLINE( lpcd );
+
+	/*
+	 *	Bookmark already set?
+	 */
+	if (( lpLine->dwFlags & LNF_BOOKMARK ) != LNF_BOOKMARK )
+	{
+		/*
+		 *	Set the bit.
+		 */
+		lpLine->dwFlags |= LNF_BOOKMARK;
+
+		/*
+		 *	Increase the bookmark counter.
+		 */
+		lpcd->nBookmarks++;
+
+		/*
+		 *	Do we need to send a status message?
+		 */
+		if ( lpcd->nBookmarks == 1 )
+			SendStatusMessage( lpcd );
+
+		/*
+ 		 *	Re-render the line.
+		 */
+		RenderLine( lpcd, lpcd->ptCaretPos.y );
+	}
+}
+
+void ClearBookmark( LPCLASSDATA lpcd )
+{
+	LPLINE		lpLine = GETLINE( lpcd );
+
+	/*
+	 *	Bookmark bit set?
+	 */
+	if (( lpLine->dwFlags & LNF_BOOKMARK ) == LNF_BOOKMARK )
+	{
+		/*
+ 		 *	Clear the bit.
+		 */
+		lpLine->dwFlags &= ~LNF_BOOKMARK;
+
+		/*
+		 *	Decrease the bookmark counter.
+		 */
+		lpcd->nBookmarks--;
+
+		/*
+		 *	Do we need to send a status message?
+		 */
+		if ( lpcd->nBookmarks == 0 )
+			SendStatusMessage( lpcd );
+
+		/*
+		 *	Re-render the line.
+		 */
+		RenderLine( lpcd, lpcd->ptCaretPos.y );
+	}
+}
+
+void ToggleBookmark( LPCLASSDATA lpcd )
+{
+	LPLINE		lpLine = GETLINE( lpcd );
+	BOOL		bStatus = FALSE;
+
+	/*
+	 *	Is the bookmark set or cleared?
+	 */
+	if (( lpLine->dwFlags & LNF_BOOKMARK ) == LNF_BOOKMARK ) 
+	{
+		/*
+		 *	Decrease the bookmark counter.
+		 */
+		lpcd->nBookmarks--;
+		if ( lpcd->nBookmarks == 0 )
+			bStatus = TRUE;
+	}
+	else
+	{
+		/*
+		 *	Increase the bookmark counter.
+		 */
+		lpcd->nBookmarks++;
+		if ( lpcd->nBookmarks == 1 )
+			bStatus = TRUE;
+	}
+
+	/*
+	 *	Flip the bookmark
+	 *	bit.
+	 */
+	lpLine->dwFlags ^= LNF_BOOKMARK;
+
+	/*
+	 *	Send the status message.
+	 */
+	if ( bStatus )
+		SendStatusMessage( lpcd );
+
+	/*
+	 *	Re-render the line.
+	 */
+	RenderLine( lpcd, lpcd->ptCaretPos.y );
+}
+
+void ClearAllBookmarks( LPCLASSDATA lpcd )
+{
+	LPLINE		lpLine;
+	BOOL		bStatus = FALSE;
+	int		i;
+
+	/*
+	 *	Iterate lines.
+	 */
+	for ( i = 0; i < ArrayGetSize( lpcd->lpLines ); i++ )
+	{
+		/*
+		 *	Get line pointer.
+		 */
+		lpLine = ArrayGetAt( lpcd->lpLines, i );
+
+		/*
+		 *	Bookmark?
+		 */
+		if (( lpLine->dwFlags & LNF_BOOKMARK ) == LNF_BOOKMARK )
+		{
+			/*
+			 *	We must send a status message.
+			 */
+			bStatus = TRUE;
+
+			/*
+			 *	Clear the bit.
+			 */
+			lpLine->dwFlags &= ~LNF_BOOKMARK;
+
+			/*
+			 *	Is it visible?
+			 */
+			if ( i >= lpcd->ptViewPos.y && i < lpcd->ptViewPos.y + lpcd->szViewSize.cy )
+				/*
+				 *	Render the line.
+				 */
+				RenderLine( lpcd, i );
+		}
+	}
+
+	/*
+	 *	No more bookmarks.
+	 */
+	lpcd->nBookmarks = 0;
+
+	/*
+	 *	Send status message if necessary.
+	 */
+	if ( bStatus )
+		SendStatusMessage( lpcd );
+}
+
+void NextBookmark( LPCLASSDATA lpcd )
+{
+	LPLINE		lpLine;
+	int		i, nLines = ArrayGetSize( lpcd->lpLines ) - 1, nLine = lpcd->ptCaretPos.y;
+
+	/*
+	 *	Only one line?
+	 */
+	if ( nLines == 0 )
+		return;
+
+	/*
+	 *	On the last line?
+	 */
+	if ( lpcd->ptCaretPos.y == nLines )
+	{
+		/*
+		 *	Set anchor.
+		 */
+		lpcd->nBookmarkAnchor = lpcd->ptCaretPos.y;
+
+		/*
+		 *	Go to the start of the first line.
+		 */
+		lpcd->ptCaretPos.y = lpcd->ptCaretPos.x = lpcd->nLastColumnPos = 0;
+
+		/*
+		 *	Call ourselves.
+		 */
+		NextBookmark( lpcd );
+	}
+
+	/*
+	 *	If we are located on a bookmark
+	 *	and the anchor is not set yet
+	 *	we start looking on the next line.
+	 */
+	lpLine = GETLINE( lpcd );
+	if ((( lpLine->dwFlags & LNF_BOOKMARK ) == LNF_BOOKMARK ) && lpcd->nBookmarkAnchor == -1 )
+		nLine++;
+
+	/*
+	 *	Iterate lines.
+	 */
+	for ( i = nLine; i <= nLines; i++ )
+	{
+		lpLine = ArrayGetAt( lpcd->lpLines, i );
+
+		/*
+		 *	Bookmark?
+		 */
+		if ((( lpLine->dwFlags & LNF_BOOKMARK ) == LNF_BOOKMARK ) || i == lpcd->nBookmarkAnchor )
+		{
+		 	/*
+			 *	On the anchor?
+			 */
+			if ( i == lpcd->nBookmarkAnchor )
+			{
+				/*
+				 *	Done...
+				 */
+				MessageBeep( 0xFFFFFFFF );
+			}
+
+			/*
+			 *	Hide the caret.
+			 */
+			DisplayCaret( lpcd, FALSE );
+
+			/*
+			 *	Yes. Move the caret here.
+			 */
+			lpcd->ptCaretPos.y = i;
+			lpcd->ptCaretPos.x = lpcd->nLastColumnPos = 0;
+
+			/*
+			 *	Make the caret visible.
+			 */
+			MakeCaretVisible( lpcd );
+
+			/*
+			 *	Reset anchor.
+			 */
+			lpcd->nBookmarkAnchor = -1;
+
+			/*
+			 *	Show the caret.
+			 */
+			DisplayCaret( lpcd, TRUE );
+			return;
+		}
+	}
+
+	/*
+	 *	Reaching this means that we are
+	 *	on the last line or that there
+	 *	are no bookmarks.
+	 */
+
+	/*
+	 *	Set anchor.
+	 */
+	lpcd->nBookmarkAnchor = nLine;
+
+	/*
+	 *	Go to the start of the file and try again.
+	 */
+	lpcd->ptCaretPos.y = lpcd->ptCaretPos.x = lpcd->nLastColumnPos = 0;
+
+	/*
+	 *	Call ourselves.
+	 */
+	NextBookmark( lpcd );
+}
+
+void PrevBookmark( LPCLASSDATA lpcd )
+{
+	LPLINE		lpLine;
+	int		i, nLines = ArrayGetSize( lpcd->lpLines ) - 1, nLine = lpcd->ptCaretPos.y;
+
+	/*
+	 *	Only one line?
+	 */
+	if ( nLines== 0 )
+		return;
+
+	/*
+	 *	On the first line?
+	 */
+	if ( lpcd->ptCaretPos.y== 0 )
+	{
+		/*
+		 *	Set anchor.
+		 */
+		lpcd->nBookmarkAnchor = lpcd->ptCaretPos.y;
+
+		/*
+		 *	Go to the start of the last line.
+		 */
+		lpcd->ptCaretPos.y = nLines;
+		lpcd->ptCaretPos.x = lpcd->nLastColumnPos = 0;
+
+		/*
+		 *	Call ourselves.
+		 */
+		PrevBookmark( lpcd );
+	}
+
+	/*
+	 *	If we are located on a bookmark
+	 *	and the anchor is not set yet
+	 *	we start looking on the previous line.
+	 */
+	lpLine = GETLINE( lpcd );
+	if ((( lpLine->dwFlags & LNF_BOOKMARK ) == LNF_BOOKMARK ) && lpcd->nBookmarkAnchor == -1 )
+		nLine--;
+
+	/*
+	 *	Iterate lines.
+	 */
+	for ( i = nLine; i >= 0; i-- )
+	{
+		lpLine = ArrayGetAt( lpcd->lpLines, i );
+
+		/*
+		 *	Bookmark?
+		 */
+		if ((( lpLine->dwFlags & LNF_BOOKMARK ) == LNF_BOOKMARK ) || i == lpcd->nBookmarkAnchor )
+		{
+			/*
+			 *	On the anchor?
+			 */
+			if ( i == lpcd->nBookmarkAnchor )
+			{
+				/*
+				 *	Done...
+				 */
+				MessageBeep( 0xFFFFFFFF );
+			}
+
+			/*
+			 *	Hide the caret.
+			 */
+			DisplayCaret( lpcd, FALSE );
+
+			/*
+			 *	Yes. Move the caret here.
+			 */
+			lpcd->ptCaretPos.y = i;
+			lpcd->ptCaretPos.x=lpcd->nLastColumnPos = 0;
+
+			/*
+			 *	Make the caret visible.
+			 */
+			MakeCaretVisible( lpcd );
+
+			/*
+			 *	Reset anchor.
+			 */
+			lpcd->nBookmarkAnchor = -1;
+
+			/*
+			 *	Show the caret.
+			 */
+			DisplayCaret( lpcd, TRUE );
+			return;
+		}
+	}
+
+	/*
+	 *	Reaching this means that we are
+	 *	on the last line or that there
+	 *	are no bookmarks.
+	 */
+
+	/*
+	 *	Set anchor.
+	 */
+	lpcd->nBookmarkAnchor = nLine;
+
+	/*
+	 *	Go to the end of the file and try again.
+	 */
+	lpcd->ptCaretPos.y = nLines;
+	lpcd->ptCaretPos.x = lpcd->nLastColumnPos = 0;
+
+	/*
+	 *	Call ourselves.
+	 */
+	PrevBookmark( lpcd );
+}
+
+void FirstBookmark( LPCLASSDATA lpcd )
+{
+	LPLINE		lpLine;
+	int		i;
+
+	/*
+	 *	Iterate...
+	 */
+	for ( i = 0; i < ArrayGetSize( lpcd->lpLines ); i++ )
+	{
+		lpLine = ArrayGetAt( lpcd->lpLines, i );
+
+		/*
+		 *	Bookmark?
+		 */
+		if (( lpLine->dwFlags & LNF_BOOKMARK ) == LNF_BOOKMARK )
+		{
+			/*
+			 *	Hide the caret.
+			 */
+			DisplayCaret( lpcd, FALSE );
+
+			/*
+			 *	Yes. Move the caret here.
+			 */
+			lpcd->ptCaretPos.y = i;
+			lpcd->ptCaretPos.x = lpcd->nLastColumnPos = 0;
+
+			/*
+			 *	Make the caret visible.
+			 */
+			MakeCaretVisible( lpcd );
+
+			/*
+			 *	Show the caret.
+			 */
+			DisplayCaret( lpcd, TRUE );
+			return;
+		}
+	}
+
+	/*
+	 *	No bookmark found.
+	 */
+	MessageBeep( 0xFFFFFFFF );
+}
+
+void LastBookmark( LPCLASSDATA lpcd )
+{
+	LPLINE		lpLine;
+	int		i;
+
+	/*
+	 *	Iterate...
+	 */
+	for ( i = ArrayGetSize( lpcd->lpLines ) - 1; i >= 0; i-- )
+	{
+		lpLine = ArrayGetAt( lpcd->lpLines, i );
+
+		/*
+		 *	Bookmark?
+		 */
+		if (( lpLine->dwFlags & LNF_BOOKMARK ) == LNF_BOOKMARK )
+		{
+			/*
+			 *	Hide the caret.
+			 */
+			DisplayCaret( lpcd, FALSE );
+
+			/*
+			 *	Yes. Move the caret here.
+			 */
+			lpcd->ptCaretPos.y = i;
+			lpcd->ptCaretPos.x = lpcd->nLastColumnPos = 0;
+
+			/*
+			 *	Make the caret visible.
+			 */
+			MakeCaretVisible( lpcd );
+
+			/*
+			 *	Show the caret.
+			 */
+			DisplayCaret( lpcd, TRUE );
+			return;
+		}
+	}
+
+	/*
+	 *	No bookmark found.
+	 */
+	MessageBeep( 0xFFFFFFFF );
+}
\ No newline at end of file
diff --git a/code/train/C/0137820_seriot.c b/code/train/C/0137820_seriot.c
new file mode 100644
index 0000000000000000000000000000000000000000..a6097ffc14760d78b92c37c01b81984ec98a75a2
--- /dev/null
+++ b/code/train/C/0137820_seriot.c
@@ -0,0 +1,198 @@
+/* 
+Copyright (C) 1995-2001 Activision, Inc.
+
+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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#include <stdlib.h>
+#include <time.h>
+#include <stdio.h>
+#include <string.h>
+#include "serio.h"
+
+void fillRamp(char *buffer, int len)
+{
+	int	i;
+
+	for (i=1; i<=len; i++) buffer[i-1]=(i&15)+'A';
+	/* buffer[len-1]=13; */
+}
+
+void oneWayTestTx(serio_t *serio, int packetLen, int packetCnt)
+{
+	int			txrx = 0;
+	int			txrxok = 0;
+	double		duration = 0.0;
+	char		buf[1000];
+	clock_t		first;
+	clock_t		last;
+	clock_t		now;
+
+	first=clock();
+	fillRamp(buf, packetLen);
+	last = first;
+	while (txrxok < packetCnt) {
+		clock_t before_send = clock();
+
+		txrx++;
+		if (serio_write(serio, buf, packetLen) == serio_RES_OK) {
+			now = clock();
+			txrxok++;
+			/* print out how long since last send, and how long 
+			 * this commTxPkt() took 
+			 */
+			printf("txrxok %d txrx %d interval %d duration %d\n",txrxok, txrx, now - last, now - before_send);
+			last = now;
+		}
+	}
+
+	duration = clock()-first;
+	duration /= CLOCKS_PER_SEC;
+	printf("\ntxrx %d, txrxok %d, packets/sec %f\n",
+		txrx, txrxok,
+		txrxok / duration);
+
+}
+
+void oneWayTestRx(serio_t *serio, int packetLen, int packetCnt)
+{
+	int			txrx = 0;
+	int			txrxok = 0;
+	double		duration = 0.0;
+	char		buf[1000];
+	clock_t		first;
+	clock_t		last;
+	clock_t		now;
+	size_t		n_received;
+
+	first=clock();
+	last = first;
+	while (txrxok < packetCnt) {
+		size_t got;
+
+		txrx++;
+		got = 0;
+		while ((int)got < packetLen) {
+			clock_t before_read = clock();
+			size_t get = packetLen - got;
+			n_received = 6666666;
+			if (serio_read(serio, buf+got, get, &n_received) == serio_RES_OK) {
+				got += n_received;
+				now = clock();
+				printf("n_received %d duration %d\n",n_received, now - before_read);
+			}
+		}
+		txrxok++;
+		/* print out how long since last read, and how long 
+		 * it took to read the packet
+		 */
+		printf("txrxok %d txrx %d interval %d\n",txrxok, txrx, now - last);
+		fwrite(buf, packetLen, 1, stdout);
+		printf("\n");
+		last = now;
+	}
+
+	duration = clock()-first;
+	duration /= CLOCKS_PER_SEC;
+	printf("\ntxrx %d, txrxok %d, packets/sec %f\n",
+		txrx, txrxok,
+		txrxok / duration);
+
+}
+
+void main(int argc, char **argv)
+{
+	int   i;
+	int packetCnt;
+	size_t packetLen;
+	long baud;
+	char portname[_MAX_PATH];
+	char *command = "t";
+	serio_res_t err;
+	serio_t serio;
+
+	packetLen = 1;
+	packetCnt = 100;
+	baud = 19200;
+	strcpy(portname, "COM1");
+
+	for (i = 1; i < argc; ++i) {
+		if (argv[i][0] != '-') { 
+			command = argv[i];
+			continue;
+		}
+		if (argv[i][1] == 0) {
+			printf("Expected letter after -\n");
+			exit(1);
+		}
+		if (argv[i][2] != '=' && argv[i][2] != ':') {
+			printf("Expected = after -%c\n", argv[i][1]);
+			exit(1);
+		}
+
+		switch (toupper(argv[i][1])) {
+
+		case 'L':
+			printf("Setting packetLen to %s\n", argv[i]+3);
+			packetLen = atoi(argv[i]+3);
+			break;
+			
+		case 'M':
+			printf("Setting number of packet to %d\n", argv[i]+3);
+			packetCnt = atoi(argv[i]+3);
+			break;
+			
+		case 'Y':   /*  Set comm port */
+			sscanf(argv[i]+3, "%s", portname);
+			break;
+
+		case 'Z':   /*  Set baud rate */
+			sscanf(argv[i]+3, "%ld", &baud);
+			break;
+
+		default:
+			printf("Usage: %s cmd [-Y=commport][-Z=baudrate][-L=packetlen][-M=packetCnt]\n"
+				"Unknown arg %s\n", argv[0], argv[i]);
+			exit(1);
+		} /*  end switch */
+	}
+
+	err = serio_open(&serio, baud, portname);
+	if (err != serio_RES_OK) {
+		printf("seriot: error initializing\n");
+		exit(1);
+	}
+
+	switch (toupper(command[0])) {
+	case 'T':
+		oneWayTestTx(&serio, packetLen, packetCnt);
+		break;
+	case 'R':
+		oneWayTestRx(&serio, packetLen, packetCnt);
+		break;
+	default :
+		printf("seriot: error: unknown command %s\n", command);
+		exit(1);
+	}
+
+	err = serio_close(&serio);
+	if (err != serio_RES_OK) {
+		printf("seriot: error closing port\n");
+		exit(1);
+	}
+
+	exit(0);
+}
diff --git a/code/train/C/0138075_selectionSort.c b/code/train/C/0138075_selectionSort.c
new file mode 100644
index 0000000000000000000000000000000000000000..f542aeb0eaae22904b447ab261d2f2491822c5be
--- /dev/null
+++ b/code/train/C/0138075_selectionSort.c
@@ -0,0 +1,55 @@
+//selection sort using a function 
+#include <stdio.h>
+#include <stdlib.h>
+#define MAX 10
+
+int minimum(int a[],int k,int size) {
+	int min=a[k],loc=k,j;
+	
+	for(j=k+1;j<size;j++) {
+		if(min>a[j]) {
+			min=a[j];
+			loc=j;
+		}
+	}
+	return loc;
+}
+
+void selectionSort(int a[],int size) {
+	int i,loc,temp,k;
+	
+	for(i=0;i<size;i++) {
+		loc=minimum(a,i,size);
+		temp=a[i];
+		a[i]=a[loc];
+		a[loc]=temp;
+				
+		printf("\nResult after Pass %d -->\n",i+1);
+		for(k=0;k<size;k++) {
+			printf(" %d",a[k]);
+		}
+	}
+}
+
+int main() 
+{
+	int a[MAX] = {0},n=0,i;
+	system("cls");
+	
+	printf("\nEnter the number of elemenets: ");
+	scanf("%d",&n);
+	
+	printf("\nEnter the array:\n");
+	for(i=0;i<n;i++) {
+		scanf("%d",&a[i]);
+	}
+	selectionSort(a,n);
+	
+	printf("\n\nHere is the sorted array:\n");
+	for(i=0;i<n;i++) {
+		printf(" %d",a[i]);
+	}
+	printf("\n\n");
+	system("pause");
+	return 0;
+}
diff --git a/code/train/C/0138386_calc_desc.c b/code/train/C/0138386_calc_desc.c
new file mode 100644
index 0000000000000000000000000000000000000000..6f54fb6bc296bad13e87aa4925b95dd8a0b5fd38
--- /dev/null
+++ b/code/train/C/0138386_calc_desc.c
@@ -0,0 +1,79 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include "calc_desc.h"
+#include "check_syscalls.h"
+#include "inthash.h"
+
+int compare_int64(const void *a, const void *b) {
+    int64_t c = *((int64_t *)a);
+    int64_t d = *((int64_t *)b);
+    if (c < d) return -1;
+    if (c > d) return 1;
+    return 0;
+}
+
+void calculate_descendants(int64_t * desc, struct snap *s1, struct snap *s2) {
+    /* s2 is the later snap */
+
+    int64_t i, j, k, p_count, max_num_p, cand, cand_count, flag;
+    int64_t * new_hid_idx = NULL;
+    struct inthash * hash = NULL;
+
+    /* initialize descendants */
+    if (!s1->num_p_total || !s1->num_h) return;
+    for (i=0; i<s1->num_h; ++i) desc[i] = -1;
+
+    /* generate hash table */
+    if (!s2->num_p_total || !s2->num_h) return;
+    hash = new_inthash();
+    ih_prealloc(hash, s2->num_p_total);
+    p_count = 0;
+    for (i=0; i<s2->num_h; ++i) {
+        for (j=p_count; j<p_count+s2->num_p_halo[i]; ++j){
+            k = ih_getint64(hash, s2->pid[j]);
+            if (k == IH_INVALID || s2->num_p_halo[k] > s2->num_p_halo[i])
+                ih_setint64(hash, s2->pid[j], i);
+        }
+        p_count += s2->num_p_halo[i];
+    }
+
+    /* match particles in s1 to s2 */
+    p_count = 0;
+    max_num_p = 0;
+    for (i=0; i<s1->num_h; ++i) {
+        if (s1->num_p_halo[i] > max_num_p) {
+            max_num_p = s1->num_p_halo[i];
+            new_hid_idx = check_realloc(new_hid_idx, sizeof(int64_t)*max_num_p,
+			        "calc_desc.c: Allocate new_hid_idx.");
+        }
+
+        k=0;
+        for (j=p_count; j<p_count+s1->num_p_halo[i]; ++j){
+            new_hid_idx[k] = ih_getint64(hash, s1->pid[j]);
+            if (new_hid_idx[k] < IH_INVALID) ++k;
+        }
+        p_count += s1->num_p_halo[i];
+        if (!k) continue;
+
+        /* find the new halo with most particles */
+        qsort(new_hid_idx, k, sizeof(int64_t), compare_int64);
+        cand = new_hid_idx[0];
+        cand_count = 0;
+        flag = 0;
+        for (j=1; j<k; ++j){
+            if (new_hid_idx[j] != new_hid_idx[flag]){
+                if (j-flag > cand_count){
+                    cand = new_hid_idx[flag];
+                    cand_count = j-flag;
+                }
+                flag = j;
+            }
+        }
+        desc[i] = s2->hid[cand];
+    }
+
+    free_inthash(hash);
+    new_hid_idx = check_realloc(new_hid_idx, 0, 
+            "calc_desc.c: free new_hid_idx.");
+}
+
diff --git a/code/train/C/0138906_dijkstras-algorithm.c b/code/train/C/0138906_dijkstras-algorithm.c
new file mode 100644
index 0000000000000000000000000000000000000000..9af33bf6172bbb06bc020d9505840d63ba38e13e
--- /dev/null
+++ b/code/train/C/0138906_dijkstras-algorithm.c
@@ -0,0 +1,135 @@
+/* ===== ===== =====
+
+Theory of Programming
+
+Dijkstra's Algorithm - O(V^2) implementation
+http://theoryofprogramming.com/2015/01/11/dijkstras-algorithm/
+GitHub - https://github.com/VamsiSangam/theoryofprogramming
+Code Contributor - Vamsi Sangam
+
+===== ===== ===== */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+// Node of the adjacency list
+struct node {
+    int vertex, weight;
+    struct node * next;
+};
+
+// Follows head insertion to give O(1) insertion
+struct node * addEdge(struct node * head, int vertex, int weight)
+{    
+    struct node * newNode = (struct node *) calloc(1, sizeof(struct node));
+     
+    newNode->vertex = vertex;
+    newNode->weight = weight;
+    newNode->next = head;
+     
+    return newNode;
+}
+
+// Retuns the vertex which is not visited and has least distance
+int getMinVertex(int distances[], int visited[], int vertices) 
+{
+	int min = INT_MAX, index = -1, i;
+	
+	for (i = 1; i <= vertices; ++i) {
+		if (visited[i] == 0 && min > distances[i]) {
+			min = distances[i];
+			index = i;
+		}
+	}
+	
+	return index;
+}
+
+// Dijkstra's Algorithm function
+void dijkstra(struct node * adjacencyList[], int vertices, int startVertex, int distances[], int parent[])
+{
+    int i, visited[vertices + 1];
+    
+    // Initially no routes to vertices are know, so all are infinity
+    for (i = 1; i <= vertices; ++i) {
+        distances[i] = INT_MAX;
+        parent[i] = 0;
+        visited[i] = 0;    
+    }
+     
+    // Setting distance to source to zero
+    distances[startVertex] = 0;
+    
+    for (i = 1; i <= vertices; ++i) {     // Untill there are vertices to be processed
+        int minVertex = getMinVertex(distances, visited, vertices);	// Greedily process the nearest vertex
+		struct node * trav = adjacencyList[minVertex];    // Checking all the vertices adjacent to 'min'
+		visited[minVertex] = 1;
+		
+        while (trav != NULL) {
+        	int u = minVertex;
+        	int v = trav->vertex;
+        	int w = trav->weight;
+        	
+            if (distances[u] != INT_MAX && distances[v] > distances[u] + w) {
+                // We have discovered a new shortest route, make the neccesary adjustments in data
+                distances[v] = distances[u] + w;
+                parent[v] = u;
+            }
+            
+            trav = trav->next;
+        }
+    }
+}
+
+// Recursively looks at a vertex's parent to print the path
+void printPath(int parent[], int vertex, int startVertex)
+{
+    if (vertex == startVertex) {	// reached the source vertex
+        printf("%d ", startVertex);
+        return;
+    } else if (parent[vertex] == 0) {	// current vertex has no parent
+    	printf("%d ", vertex);
+    	return;
+	} else {	// go for the current vertex's parent
+        printPath(parent, parent[vertex], startVertex);
+        printf("%d ", vertex);
+    }
+}
+
+int main()
+{
+    int vertices, edges, i, j, v1, v2, w, startVertex;
+    
+    printf("Enter the Number of Vertices -\n");
+    scanf("%d", &vertices);
+    printf("Enter the Number of Edges -\n");
+    scanf("%d", &edges);
+    
+    struct node * adjacencyList[vertices + 1];	// to use the array as 1-indexed for simplicity
+    int distances[vertices + 1];
+    int parent[vertices + 1];
+    
+    for (i = 0; i <= vertices; ++i) {	// Must initialize your array
+        adjacencyList[i] = NULL;
+    }
+    
+    for (i = 1; i <= edges; ++i) {
+        scanf("%d%d%d", &v1, &v2, &w);
+        adjacencyList[v1] = addEdge(adjacencyList[v1], v2, w);
+    }
+    
+    printf("Enter start vertex -\n");
+    scanf("%d", &startVertex);
+    dijkstra(adjacencyList, vertices, startVertex, distances, parent);
+	printf("Shortest distances -\n");
+	
+    for (i = 1; i <= vertices; ++i) {
+    	printf("Vertex %d, Distance = %d, Parent = %d, ", i, distances[i], parent[i]);
+    	printf("Path = ");
+    	printPath(parent, i, startVertex);
+    	printf("\n");
+	}
+    
+    return 0;
+}
diff --git a/code/train/C/0139020_4.1-4.c b/code/train/C/0139020_4.1-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..59c460dc555fe74e6ff0416a99c20bd0bfd0c816
--- /dev/null
+++ b/code/train/C/0139020_4.1-4.c
@@ -0,0 +1,81 @@
+#include <stdio.h>
+
+int arr[] = {13, -3, -25, 20, -3, -16, -23, 18, 20, -7, 12, -5, -22, 15, -4, 7};
+int fake[] = {};
+
+typedef struct sub_arr {
+	int low;
+	int high;
+	int sum;
+} mark;
+
+mark find_max_crossing_subarray(int[], int, int, int);
+mark find_maximum_subarray(int[], int, int);
+
+
+int
+main(int argc, char *argv[])
+{
+	mark result;
+	result = find_maximum_subarray(fake, 0, sizeof(fake)/sizeof(int));
+	printf("The lowest of maximum is %d\t, the highest of maximum is %d\n", result.low, result.high);
+	return 0;
+}
+
+mark find_max_crossing_subarray(int arr[], int low, int mid, int high)
+{
+	int left, left_sum, right_sum, i, j, max_left, max_right, sum;
+	left_sum = -1111;
+	sum = 0;
+	for (i = mid; i >= low; i--) {
+		sum = sum + arr[i];
+		if (sum > left_sum) {
+			left_sum = sum;
+			max_left = i;
+		}
+	}
+	right_sum = -1111;
+	sum = 0;
+	for (j = mid + 1; j <=high; j++) {
+		sum = sum + arr[j];
+		if (sum > right_sum) {
+			right_sum = sum;
+			max_right = j;
+		}
+	}
+	mark result;
+	result.low = max_left;
+	result.high = max_right;
+	result.sum = left_sum + right_sum;
+	return result;
+}
+
+mark find_maximum_subarray(int arr[], int low, int high)
+{
+	mark result, mark_left, mark_right, cross;
+	int mid;
+	if (arr == NULL) {
+		result.low = 0;
+		result.high = 0;
+		result.sum = 0;
+		return result;
+	}
+	if (high == low) {
+		result.low = low;
+		result.high = high;
+		result.sum = arr[low];
+		return result;
+	} else {
+		mid = (low + high) / 2;
+		mark_left = find_maximum_subarray(arr, low, mid);
+		mark_right = find_maximum_subarray(arr, mid+1, high);
+		cross = find_max_crossing_subarray(arr, low, mid, high);
+		if (mark_left.sum >= mark_right.sum && mark_left.sum >= cross.sum)
+			return mark_left;
+		else if (mark_right.sum >= mark_left.sum && mark_right.sum >= cross.sum)
+			return mark_right;
+		else
+			return cross;
+	}
+	
+}
diff --git a/code/train/C/0139150_demo.c b/code/train/C/0139150_demo.c
new file mode 100644
index 0000000000000000000000000000000000000000..d8e6fc33b6a3d6c18ae0bb2f50c0809a82ea1915
--- /dev/null
+++ b/code/train/C/0139150_demo.c
@@ -0,0 +1,160 @@
+#include <eZ80.h>
+#include <uart.h>
+#include <gpio.h>
+#include <stdlib.h>
+
+#include "skeelib.h"
+#include "framebuffer.h"
+#include <lib_ay-3-8912.h>
+#include "lib_fontrender.h"
+#include "menu.h"
+
+void demo_linedemo ( UINT16 maxlines ) {
+	
+	//while ( 1 ) {
+		UINT8 x, y, lx = 0, ly; // x, y, last-x, last-y
+		UINT8 c;
+		UINT16 i;
+		UINT8 *extram;
+			
+		extram = (UINT8 *) 0x0C0000;
+
+		//fb_render_rect_filled ( extram, 0, 0, 250, 230, 1 );
+		memset ( extram, 1, 256*200 );
+		
+		render_font_8x8 ( 0, 0,  "Zikzak http://www.zikzak.ca", lame_randrange8 ( 1, 0xFF ) );
+		render_font_8x8 ( 0, 8,  "Mode: Colour 256x240", lame_randrange8 ( 1, 0xFF ) );
+		render_font_8x8 ( 0, 16, "In: CPU Serial", lame_randrange8 ( 1, 0xFF ) );
+		
+		x = y = lx = ly = 0;
+
+		for ( i = 0; i < maxlines; i++ ) {
+			
+			x = lame_randrange8 ( 10, 230 );
+			y = lame_randrange8 ( 30, 170 );
+			c = lame_randrange8 ( 0, 0x3F ); // 0b00111111
+			
+			if ( lx != 0 ) {
+				zl_render_line ( extram, c, lx, ly, x, y );
+			}
+			
+			lx = x;
+			ly = y;
+			
+		} // for
+
+		//delay_ms_spin ( 20 );		
+		
+		//while(1);
+
+	//}
+
+	return;
+}
+
+void demo_pause ( char *message ) {
+	char inbuf [ 5 ] = "\0\0\0\0\0";
+	UINT24 nbytes;
+
+	UINT8 *extram;
+	extram = (UINT8 *) 0x0C0000;
+	memset ( extram, 1, 256*8*3 );
+
+	render_font_8x8 ( 0, 0,  message, lame_randrange8 ( 1, 0xFF ) );
+	nbytes = 1;
+	read_UART0 ( inbuf, &nbytes );
+	
+	return;
+}
+
+void demo_offset_squares ( void ) {
+    UINT16 x, y, i;
+    unsigned char v;
+	
+	UINT8 *extram;
+	extram = (UINT8 *) 0x0C0000;
+
+	memset ( extram, 1, 256*200 );
+	
+    for ( y = 0; y < FBHEIGHT; y++ ) {
+
+      //i = 0;
+      i = ( y / 10 ) % 5;
+
+      for ( x = 0; x < (FBWIDTH/12); x++ ) {
+
+        i++;
+
+        if ( i == 0 ) {
+          v = (unsigned char) 1;
+        } else if ( i == 1 ) {
+          v = (unsigned char) 2;
+        } else if ( i == 2 ) {
+          v = (unsigned char) 4;
+        } else if ( i == 3 ) {
+          v = (unsigned char) 8;
+        } else if ( i == 4 ) {
+          v = (unsigned char) 16;
+        } else if ( i == 5 ) {
+          v = (unsigned char) 32;
+        } else {
+          i = 0;
+          v = (unsigned char) 1;
+        }
+
+        if ( y % 10 == 0 ) {
+          v = 0; // black
+        }
+
+		memset ( extram + ( y * FBWIDTH ) + (x*12), v, 12 );
+
+      } // x
+
+    } // y
+
+	return;	
+}
+
+void demo_charset ( void ) {
+	UINT8 *extram;
+	UINT8 c;
+	char b [ 3 ] = "\0\0\0";
+			
+	extram = (UINT8 *) 0x0C0000;
+
+	memset ( extram, 1, 256*200 );
+	
+	for ( c = 0; c < 128; c++ ) {
+		b [ 0 ] = c;
+		render_font_8x8 ( (c % 16) * 12, 32 + ((c / 16) * 16), b, 0xFF );
+	}
+	
+}
+
+void demo_sprite_fb ( void ) {
+	UINT8 *extram, *spriterow;
+	UINT8 x;
+	char b [ 3 ] = "\0\0\0";
+	UINT8 rounds;
+	
+	b [ 0 ] = 15;
+	
+	extram = (UINT8 *) 0x0C0000;
+	memset ( extram, 1, 256*200 );
+	
+	spriterow = extram + ( 256*64 );
+
+	for ( rounds = 0; rounds < 5; rounds++ ) {
+
+		for ( x = 10; x < 230; x++ ) {
+			memset ( spriterow, 1, 256*8 );
+			render_font_8x8 ( x, 64, b, 0xFF );
+		}
+		for ( ; x > 10; x-- ) {
+			memset ( spriterow, 1, 256*8 );
+			render_font_8x8 ( x, 64, b, 0xFF );
+		}
+
+	} // rounds
+
+}
diff --git a/code/train/C/0139325_hsort.c b/code/train/C/0139325_hsort.c
new file mode 100644
index 0000000000000000000000000000000000000000..8cb8f6be4465c8a0571eefe1098830366457a19b
--- /dev/null
+++ b/code/train/C/0139325_hsort.c
@@ -0,0 +1,79 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   hsort.c                                            :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: pbondoer <pbondoer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2017/12/14 11:49:53 by pbondoer          #+#    #+#             */
+/*   Updated: 2017/12/14 14:22:24 by pbondoer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+#include <inttypes.h>
+
+inline void	*elem(t_array a, size_t pos)
+{
+	return ((void *)((char *)a.ptr + pos * a.size));
+}
+
+inline void	swap(t_array a, size_t first, size_t second)
+{
+	void *buf;
+
+	buf = ft_memalloc(a.size);
+	if (!buf)
+		return ;
+	ft_memmove(buf, elem(a, first), a.size);
+	ft_memmove(elem(a, first), elem(a, second), a.size);
+	ft_memmove(elem(a, second), buf, a.size);
+	ft_memdel(&buf);
+}
+
+inline void	sift_down(t_array a, size_t start, size_t end,
+				int (*compar)(const void *, const void *))
+{
+	size_t root;
+	size_t child;
+	size_t selected;
+
+	root = start;
+	while (2 * root + 1 <= end)
+	{
+		child = 2 * root + 1;
+		selected = root;
+		if (compar(elem(a, selected), elem(a, child)) < 0)
+			selected = child;
+		if (child + 1 <= end &&
+				compar(elem(a, selected), elem(a, child + 1)) < 0)
+			selected = child + 1;
+		if (selected == root)
+			return ;
+		swap(a, root, selected);
+		root = selected;
+	}
+}
+
+void		ft_hsort(void *base, size_t num, size_t size,
+				int (*compar)(const void *, const void *))
+{
+	intmax_t	cur;
+	t_array		a;
+
+	a.ptr = base;
+	a.size = size;
+	cur = (num) / 2 - 1;
+	while (cur >= 0)
+	{
+		sift_down(a, cur, num - 1, compar);
+		cur--;
+	}
+	cur = num - 1;
+	while (cur > 0)
+	{
+		swap(a, cur, 0);
+		cur--;
+		sift_down(a, 0, cur, compar);
+	}
+}
diff --git a/code/train/C/0139329_main.c b/code/train/C/0139329_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..526319616758ecb48b3fb0b65934ff1402abbc28
--- /dev/null
+++ b/code/train/C/0139329_main.c
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2015 Intel Corporation.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/*
+ * Copyright (c) 2016 Intel Corporation
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <ztest.h>
+
+#include <device.h>
+#include <misc/byteorder.h>
+#include <adc.h>
+#include <misc/printk.h>
+
+/* in millisecond */
+#define SLEEPTIME  2000
+
+#define ADC_DEVICE_NAME "ADC_0"
+
+/*
+ * The analog input pin and channel number mapping
+ * for Arduino 101 board.
+ * A0 Channel 10
+ * A1 Channel 11
+ * A2 Channel 12
+ * A3 Channel 13
+ * A4 Channel 14
+ */
+#define CHANNEL 10
+#define BUFFER_SIZE 10
+
+static u32_t seq_buffer[2][BUFFER_SIZE];
+
+static struct adc_seq_entry sample = {
+	.sampling_delay = 12,
+	.channel_id = CHANNEL,
+	.buffer_length = BUFFER_SIZE * sizeof(seq_buffer[0][0])
+};
+
+static struct adc_seq_table table = {
+	.entries = &sample,
+	.num_entries = 1,
+};
+
+static void _print_sample_in_hex(const u32_t *buf, u32_t length)
+{
+	const u32_t *top;
+
+	printk("Buffer content:\n");
+	for (top = buf + length; buf < top; buf++)
+		printk("0x%x ", *buf);
+	printk("\n");
+}
+
+static long _abs(long x)
+{
+	return x < 0 ? -x : x;
+}
+
+
+static void adc_test(void)
+{
+	int result = TC_FAIL;
+	struct device *adc;
+	unsigned int loops = 10;
+	unsigned int bufi0 = ~0, bufi;
+
+	adc = device_get_binding(ADC_DEVICE_NAME);
+	zassert_not_null(adc, "Cannot get adc controller\n");
+
+	adc_enable(adc);
+	while (loops--) {
+		bufi = loops & 0x1;
+		/* .buffer should be void * ... */
+		sample.buffer = (void *) seq_buffer[bufi];
+		result = adc_read(adc, &table);
+		zassert_equal(result, 0, "Sampling could not proceed, "
+			"an error occurred\n");
+		printk("loop %u: sampling done to buffer #%u\n", loops, bufi);
+		_print_sample_in_hex(seq_buffer[bufi], BUFFER_SIZE);
+		if (bufi0 != ~0) {
+			unsigned int cnt;
+			long delta;
+
+			for (cnt = 0; cnt < BUFFER_SIZE; cnt++) {
+				delta = _abs((long)seq_buffer[bufi][cnt]
+					     - seq_buffer[bufi0][cnt]);
+				printk("loop %u delta %u = %ld\n",
+				       loops, cnt, delta);
+			}
+		}
+		k_sleep(SLEEPTIME);
+		bufi0 = bufi;
+	}
+	adc_disable(adc);
+}
+
+
+void test_main(void)
+{
+	ztest_test_suite(_adc_test,
+			 ztest_unit_test(adc_test));
+	ztest_run_test_suite(_adc_test);
+}
+
diff --git a/code/train/C/0139459_devel.c b/code/train/C/0139459_devel.c
new file mode 100644
index 0000000000000000000000000000000000000000..abb257756575520765d8b819e470eb5bfb320213
--- /dev/null
+++ b/code/train/C/0139459_devel.c
@@ -0,0 +1,250 @@
+/* mp4h -- A macro processor for HTML documents
+   Copyright 2000-2003, Denis Barbier
+   All rights reserved.
+
+   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, or (at your option)
+   any later version.
+
+   This program is a work based on GNU m4 version 1.4n. Below is the
+   original copyright.
+*/
+/* GNU m4 -- A simple macro processor
+   Copyright (C) 1989, 90, 91, 92, 93, 94, 98 Free Software Foundation, Inc.
+  
+   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, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* Global function useful for builtin.c and loadable modules.  */
+
+#define MP4H_MODULE
+#include "mp4h.h"
+#undef MP4H_MODULE
+
+static const char * skip_space __P ((const char *));
+
+/*  Stack for predefined attributes.  */
+static var_stack *tag_attr = NULL;
+
+/*------------------------------------------------------------------------.
+| Give friendly warnings if a builtin macro is passed an inappropriate    |
+| number of arguments.  NAME is macro name for messages, ARGC is actual   |
+| number of arguments, MIN is the minimum number of acceptable arguments, |
+| negative if not applicable, MAX is the maximum number, negative if not  |
+| applicable.                                                             |
+`------------------------------------------------------------------------*/
+
+boolean
+bad_argc (token_data *name, int argc, int min, int max)
+{
+  boolean isbad = FALSE;
+
+  if (min > 0 && argc < min)
+    {
+      if (!suppress_warnings)
+        MP4HERROR ((warning_status, 0,
+          _("Warning:%s:%d: Too few arguments to built-in `%s'"),
+               CURRENT_FILE_LINE, TOKEN_DATA_TEXT (name)));
+      isbad = TRUE;
+    }
+  else if (max > 0 && argc > max && !suppress_warnings)
+    {
+      MP4HERROR ((warning_status, 0,
+        _("Warning:%s:%d: Excess arguments to built-in `%s' ignored"),
+             CURRENT_FILE_LINE, TOKEN_DATA_TEXT (name)));
+    }
+
+  return isbad;
+}
+
+/*--------------------------------------------------------------------------.
+| The function numeric_arg () converts ARG to an int pointed to by VALUEP.  |
+| If the conversion fails, print error message for macro MACRO.  Return     |
+| TRUE iff conversion succeeds.                                             |
+`--------------------------------------------------------------------------*/
+static const char *
+skip_space (const char *arg)
+{
+  while (IS_SPACE (*arg))
+    arg++;
+  return arg;
+}
+
+boolean
+numeric_arg (token_data *macro, const char *arg, boolean warn, int *valuep)
+{
+  char *endp;
+
+  if (*arg == 0 || (*valuep = strtol (skip_space (arg), &endp, 10), 
+                    *skip_space (endp) != 0))
+    {
+      if (warn)
+        MP4HERROR ((warning_status, 0,
+          _("Warning:%s:%d: Argument `%s' non-numeric in the <%s> tag"),
+               CURRENT_FILE_LINE, arg, TOKEN_DATA_TEXT (macro)));
+      return FALSE;
+    }
+  return TRUE;
+}
+
+/*----------------------------------------------------------------------.
+| Format an int VAL, and stuff it into an obstack OBS.  Used for macros |
+| expanding to numbers.                                                 |
+`----------------------------------------------------------------------*/
+
+void
+shipout_int (struct obstack *obs, int val)
+{
+  char buf[128];
+
+  sprintf (buf, "%d", val);
+  obstack_grow (obs, buf, strlen (buf));
+}
+
+/*---------------------.
+| Idem, for long int.  |
+`---------------------*/
+
+void
+shipout_long (struct obstack *obs, long val)
+{
+  char buf[128];
+
+  sprintf (buf, "%ld", val);
+  obstack_grow (obs, buf, strlen (buf));
+}
+
+/*----------------------------------------------------------------.
+| The shipout_string is used when string length can be computed.  |
+`----------------------------------------------------------------*/
+
+void
+shipout_string (struct obstack *obs, const char *s, int len)
+{
+  if (s == NULL)
+    s = "";
+
+  if (len == 0)
+    len = strlen (s);
+
+  obstack_grow (obs, s, len);
+}
+
+/*----------------------------------------------------------.
+| Print ARGC arguments from the table ARGV to obstack OBS,  |
+| separated by SEP.                                         |
+`----------------------------------------------------------*/
+
+void
+dump_args (struct obstack *obs, int argc, token_data **argv, const char *sep)
+{
+  int i;
+
+  for (i = 1; i < argc; i++)
+    {
+      if (i > 1 && sep)
+        obstack_grow (obs, sep, strlen (sep));
+
+      obstack_1grow (obs, CHAR_BGROUP);
+      /*   Remove surrounding double quotes  */
+      if (*ARG (i) == '"' && LAST_CHAR (ARG (i)) == '"')
+        obstack_grow (obs, ARG (i) + 1, strlen (ARG (i)) - 2);
+      else
+        obstack_grow (obs, ARG (i), strlen (ARG (i)));
+
+      obstack_1grow (obs, CHAR_EGROUP);
+    }
+}
+
+/*--------------------------------------------------------------------------.
+| The function predefined_attribute () reads attributes and returns the     |
+| value associated with the key named ``key''.                              |
+`--------------------------------------------------------------------------*/
+
+const char *
+predefined_attribute (const char *key, int *ptr_argc, token_data **argv,
+                      boolean lowercase)
+{
+  var_stack *next;
+  char *cp, *sp, *lower;
+  int i, j, special_chars;
+  boolean found = FALSE;
+
+  i = 1;
+  while (i<*ptr_argc)
+    {
+      special_chars = 0;
+      sp = TOKEN_DATA_TEXT (argv[i]);
+      while (IS_GROUP (*sp))
+        {
+          sp++;
+          special_chars++;
+        }
+
+      cp = strchr (sp, '=');
+      if ((cp == NULL && strcasecmp (sp, key) == 0) ||
+          (cp != NULL && strncasecmp (sp, key, strlen (key)) == 0
+               && *(sp + strlen (key)) == '='))
+        {
+          found = TRUE;
+          next = (var_stack *) xmalloc (sizeof (var_stack));
+          next->prev = tag_attr;
+          if (cp)
+            {
+              next->text = (char *) xmalloc (special_chars + strlen (cp+1) + 1);
+              if (special_chars)
+                strncpy (next->text, TOKEN_DATA_TEXT (argv[i]), special_chars);
+              strcpy (next->text+special_chars, cp+1);
+            }
+          else
+            next->text = xstrdup (key);
+          tag_attr = next;
+
+          if (lowercase)
+            for (lower=tag_attr->text; *lower != '\0'; lower++)
+              *lower = tolower (*lower);
+
+          /* remove this attribute from argv[].  */
+          for (j=i+1; j<=*ptr_argc; j++)
+            argv[j-1] = argv[j];
+
+          (*ptr_argc)--;
+        }
+      i++;
+    }
+
+  return (found ? tag_attr->text : NULL );
+}
+
+/*--------------------------------------------------------------------------.
+| Clear stack containing predefined attributes.  This function is called    |
+| after macro has been evaluated.                                           |
+`--------------------------------------------------------------------------*/
+
+void
+clear_tag_attr (void)
+{
+  var_stack *pa;
+
+  while (tag_attr)
+    {
+      pa = tag_attr->prev;
+      xfree ((voidstar) tag_attr->text);
+      xfree ((voidstar) tag_attr);
+      tag_attr = pa;
+    }
+}
+
diff --git a/code/train/C/0139505_dlagtf.c b/code/train/C/0139505_dlagtf.c
new file mode 100644
index 0000000000000000000000000000000000000000..eb3e586d303168d7fc9099b787a3dd2ec11c41c4
--- /dev/null
+++ b/code/train/C/0139505_dlagtf.c
@@ -0,0 +1,202 @@
+/* dlagtf.f -- translated by f2c (version 20061008).
+   You must link the resulting object file with libf2c:
+	on Microsoft Windows system, link with libf2c.lib;
+	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
+	or, if you install libf2c.a in a standard place, with -lf2c -lm
+	-- in that order, at the end of the command line, as in
+		cc *.o -lf2c -lm
+	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
+
+		http://www.netlib.org/f2c/libf2c.zip
+*/
+
+#include "f2c.h"
+#include "blaswrap.h"
+
+/* Subroutine */ int dlagtf_(integer *n, doublereal *a, doublereal *lambda, 
+	doublereal *b, doublereal *c__, doublereal *tol, doublereal *d__, 
+	integer *in, integer *info)
+{
+    /* System generated locals */
+    integer i__1;
+    doublereal d__1, d__2;
+
+    /* Local variables */
+    integer k;
+    doublereal tl, eps, piv1, piv2, temp, mult, scale1, scale2;
+
+/*  -- LAPACK routine (version 3.2) -- */
+/*     November 2006 */
+
+/*  Purpose */
+/*  ======= */
+
+/*  DLAGTF factorizes the matrix (T - lambda*I), where T is an n by n */
+/*  tridiagonal matrix and lambda is a scalar, as */
+
+/*     T - lambda*I = PLU, */
+
+/*  where P is a permutation matrix, L is a unit lower tridiagonal matrix */
+/*  with at most one non-zero sub-diagonal elements per column and U is */
+/*  an upper triangular matrix with at most two non-zero super-diagonal */
+/*  elements per column. */
+
+/*  The factorization is obtained by Gaussian elimination with partial */
+/*  pivoting and implicit row scaling. */
+
+/*  The parameter LAMBDA is included in the routine so that DLAGTF may */
+/*  be used, in conjunction with DLAGTS, to obtain eigenvectors of T by */
+/*  inverse iteration. */
+
+/*  Arguments */
+/*  ========= */
+
+/*  N       (input) INTEGER */
+/*          The order of the matrix T. */
+
+/*  A       (input/output) DOUBLE PRECISION array, dimension (N) */
+/*          On entry, A must contain the diagonal elements of T. */
+
+/*          On exit, A is overwritten by the n diagonal elements of the */
+/*          upper triangular matrix U of the factorization of T. */
+
+/*  LAMBDA  (input) DOUBLE PRECISION */
+/*          On entry, the scalar lambda. */
+
+/*  B       (input/output) DOUBLE PRECISION array, dimension (N-1) */
+/*          On entry, B must contain the (n-1) super-diagonal elements of */
+/*          T. */
+
+/*          On exit, B is overwritten by the (n-1) super-diagonal */
+/*          elements of the matrix U of the factorization of T. */
+
+/*  C       (input/output) DOUBLE PRECISION array, dimension (N-1) */
+/*          On entry, C must contain the (n-1) sub-diagonal elements of */
+/*          T. */
+
+/*          On exit, C is overwritten by the (n-1) sub-diagonal elements */
+/*          of the matrix L of the factorization of T. */
+
+/*  TOL     (input) DOUBLE PRECISION */
+/*          On entry, a relative tolerance used to indicate whether or */
+/*          not the matrix (T - lambda*I) is nearly singular. TOL should */
+/*          normally be chose as approximately the largest relative error */
+/*          in the elements of T. For example, if the elements of T are */
+/*          correct to about 4 significant figures, then TOL should be */
+/*          set to about 5*10**(-4). If TOL is supplied as less than eps, */
+/*          where eps is the relative machine precision, then the value */
+/*          eps is used in place of TOL. */
+
+/*  D       (output) DOUBLE PRECISION array, dimension (N-2) */
+/*          On exit, D is overwritten by the (n-2) second super-diagonal */
+/*          elements of the matrix U of the factorization of T. */
+
+/*  IN      (output) INTEGER array, dimension (N) */
+/*          On exit, IN contains details of the permutation matrix P. If */
+/*          an interchange occurred at the kth step of the elimination, */
+/*          then IN(k) = 1, otherwise IN(k) = 0. The element IN(n) */
+/*          returns the smallest positive integer j such that */
+
+/*             abs( u(j,j) ).le. norm( (T - lambda*I)(j) )*TOL, */
+
+/*          where norm( A(j) ) denotes the sum of the absolute values of */
+/*          the jth row of the matrix A. If no such j exists then IN(n) */
+/*          is returned as zero. If IN(n) is returned as positive, then a */
+/*          diagonal element of U is small, indicating that */
+/*          (T - lambda*I) is singular or nearly singular, */
+
+/*  INFO    (output) INTEGER */
+/*          = 0   : successful exit */
+/*          .lt. 0: if INFO = -k, the kth argument had an illegal value */
+
+/* ===================================================================== */
+
+    /* Parameter adjustments */
+    --in;
+    --d__;
+    --c__;
+    --b;
+    --a;
+
+    /* Function Body */
+    *info = 0;
+    if (*n < 0) {
+	*info = -1;
+	i__1 = -(*info);
+	xerbla_("DLAGTF", &i__1);
+	return 0;
+    }
+
+    if (*n == 0) {
+	return 0;
+    }
+
+    a[1] -= *lambda;
+    in[*n] = 0;
+    if (*n == 1) {
+	if (a[1] == 0.) {
+	    in[1] = 1;
+	}
+	return 0;
+    }
+
+    eps = dlamch_("Epsilon");
+
+    tl = max(*tol,eps);
+    scale1 = abs(a[1]) + abs(b[1]);
+    i__1 = *n - 1;
+    for (k = 1; k <= i__1; ++k) {
+	a[k + 1] -= *lambda;
+	scale2 = (d__1 = c__[k], abs(d__1)) + (d__2 = a[k + 1], abs(d__2));
+	if (k < *n - 1) {
+	    scale2 += (d__1 = b[k + 1], abs(d__1));
+	}
+	if (a[k] == 0.) {
+	    piv1 = 0.;
+	} else {
+	    piv1 = (d__1 = a[k], abs(d__1)) / scale1;
+	}
+	if (c__[k] == 0.) {
+	    in[k] = 0;
+	    piv2 = 0.;
+	    scale1 = scale2;
+	    if (k < *n - 1) {
+		d__[k] = 0.;
+	    }
+	} else {
+	    piv2 = (d__1 = c__[k], abs(d__1)) / scale2;
+	    if (piv2 <= piv1) {
+		in[k] = 0;
+		scale1 = scale2;
+		c__[k] /= a[k];
+		a[k + 1] -= c__[k] * b[k];
+		if (k < *n - 1) {
+		    d__[k] = 0.;
+		}
+	    } else {
+		in[k] = 1;
+		mult = a[k] / c__[k];
+		a[k] = c__[k];
+		temp = a[k + 1];
+		a[k + 1] = b[k] - mult * temp;
+		if (k < *n - 1) {
+		    d__[k] = b[k + 1];
+		    b[k + 1] = -mult * d__[k];
+		}
+		b[k] = temp;
+		c__[k] = mult;
+	    }
+	}
+	if (max(piv1,piv2) <= tl && in[*n] == 0) {
+	    in[*n] = k;
+	}
+    }
+    if ((d__1 = a[*n], abs(d__1)) <= scale1 * tl && in[*n] == 0) {
+	in[*n] = *n;
+    }
+
+    return 0;
+
+/*     End of DLAGTF */
+
+} /* dlagtf_ */
diff --git a/code/train/C/0139845_pxa27x_voltage.c b/code/train/C/0139845_pxa27x_voltage.c
new file mode 100644
index 0000000000000000000000000000000000000000..730c1fdd521159f0636b337c403c4154e8c1e595
--- /dev/null
+++ b/code/train/C/0139845_pxa27x_voltage.c
@@ -0,0 +1,263 @@
+/* Helper module for the cpufreq. It is responsible for changing core
+ * voltage on CPU through Intel(R) PXA27x EMTS compliant PMIC. Commands
+ * sent to dumb PMIC through PWR_I2C sequencer integrated in PXA27x.
+ * That driver do not expose PWR_I2C as general purpose I2C bus and
+ * so far it supports single-byte commands only.
+ *
+ * Copyright (c) 2006  Michal Sroczynski <msroczyn@elka.pw.edu.pl> 
+ * Copyright (c) 2006  Anton Vorontsov <cbou@mail.ru>
+ *
+ * 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.
+ *
+ * History:
+ * 2006-02-04 : Michal Sroczynski <msroczyn@elka.pw.edu.pl> 
+ * 	initial driver for Asus730
+ * 2006-06-05 : Anton Vorontsov <cbou@mail.ru>
+ *      hx4700 port, various changes
+ * 2006-12-06 : Anton Vorontsov <cbou@mail.ru>
+ *      Convert to the generic PXA driver.
+ */
+
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/cpufreq.h>
+#include <linux/platform_device.h>
+#include <asm/hardware.h>
+#include <asm/arch/pxa-regs.h>
+#include <asm/arch/pxa27x_voltage.h>
+
+#ifdef DEBUG
+#define dbg(msg...) do {printk("pxa27x_voltage:%s: ", __FUNCTION__);\
+	                    printk(msg);} while(0);
+#else
+#define dbg(msg...)
+#endif
+
+struct freq2mv_table {
+	 unsigned int khz;
+	 unsigned int mv;
+};
+
+static struct freq2mv_table freq2mv_table[] = {
+	//  kHz,   mV
+	{104000,  900},
+	{156000, 1050},
+	{208000, 1100},
+	{312000, 1250},
+	{416000, 1350},
+	{520000, 1450},
+	{624000, 1550}
+};
+
+#define MAX_VOLTAGE_DROP (freq2mv_table[ARRAY_SIZE(freq2mv_table)-1].mv - \
+                          freq2mv_table[0].mv)
+
+static inline int freq2mv(int khz)
+{
+	int i;
+	for (i = 0; i < ARRAY_SIZE(freq2mv_table); i++) {
+		if (freq2mv_table[i].khz == khz)
+			return freq2mv_table[i].mv;
+	}
+	// Return maximal voltage we know if no freq2mv record found
+	printk(KERN_WARNING "pxa27x_voltage: unknown freq: %d\n", khz);
+	return freq2mv_table[ARRAY_SIZE(freq2mv_table)-1].mv;
+}
+
+
+/* This is Errata 28 workaround, see Intel Specification Update
+ * POWER MANAGER: Core hangs during voltage change when there are
+ * outstanding transactions on the bus */
+static void start_voltage_change(void)
+{
+	unsigned int unused;
+	unsigned long flags;
+	local_irq_save(flags);
+	__asm__ __volatile__("                                                \n\
+	b       1f                                                            \n\
+	nop                                                                   \n\
+	.align  5                                                             \n\
+1:                                                                            \n\
+	ldr     r0, [%1]                   @ APB register read and compare    \n\
+	cmp     r0, #0                     @ fence for pending slow apb reads \n\
+	                                                                      \n\
+	mov     r0, #0x8                   @ VC bit for PWRMODE               \n\
+	movs    r1, #1                     @ don't execute mcr on 1st pass    \n\
+	                                                                      \n\
+retry:                                                                        \n\
+	ldreq   r3, [%2]                   @ only stall on the 2nd pass       \n\
+	cmpeq   r3, #0                     @ cmp causes fence on mem transfers\n\
+	cmp     r1, #0                     @ is this the 2nd pass?            \n\
+	mcreq   p14, 0, r0, c7, c0, 0      @ write to PWRMODE on 2nd pass only\n\
+	                                                                      \n\
+	@ Read VC bit until it is 0, indicates that the VoltageChange is done.\n\
+	@ On first pass, we never set the VC bit, so it will be clear already.\n\
+VoltageChange_loop:                                                           \n\
+	mrc     p14, 0, r3, c7, c0, 0                                         \n\
+	tst     r3, #0x8                                                      \n\
+	bne     VoltageChange_loop                                            \n\
+	                                                                      \n\
+	subs    r1, r1, #1                                                    \n\
+	beq     retry"
+		:"=&r"(unused)
+		:"r"(&CCCR), "r"(UNCACHED_ADDR)
+		:"r0", "r1", "r3");
+	local_irq_restore(flags);
+	return;
+}
+
+static int fill_ramp(int old_mv, int new_mv,
+                     struct pxa27x_voltage_chip *chip)
+{
+	int delta;
+	int sign;
+	int steps;
+	int i;
+
+	delta = new_mv - old_mv;
+	if (!delta) return 0;
+
+	sign  = abs(delta)/delta;
+	steps = abs(delta)/chip->step;
+
+	if (sign > 0 && old_mv + chip->step*steps < new_mv) steps++;
+	else if (!steps) return 0;
+	
+	i = 0;
+	while (steps > i) {
+		old_mv += sign*chip->step;
+		dbg("i:%d	mv: %d	lc:%d\n",
+		    i, old_mv, steps <= i+1 ? 1 : 0);
+		PCMD(i) = chip->mv2cmd(old_mv) |
+		          (chip->delay ? PCMD_DCE : 0) |
+		          (steps <= i+1 ? PCMD_LC : 0);
+		i++;
+	}
+
+	return steps;
+}
+
+static int change_voltage(struct cpufreq_freqs *f,
+                           struct pxa27x_voltage_chip *chip)
+{
+	int ret = 0;
+	int steps = 1;
+
+	PVCR = chip->address;
+	if (chip->step) {
+		PVCR = PVCR | (chip->delay << 7 & PVCR_CommandDelay);
+		steps = fill_ramp(freq2mv(f->old), freq2mv(f->new), chip);
+		if (steps == 0) return ret;
+	}
+	else PCMD(0) = chip->mv2cmd(freq2mv(f->new)) | PCMD_LC;
+
+	start_voltage_change();
+
+	while (PVCR & PVCR_VCSA) {
+		dbg("read pointer at %d\n", PVCR >> 20);
+		if (steps-- <= 0) {
+			printk(KERN_WARNING "pxa27x_voltage: tired to wait, "
+			       "read pointer at %d\n", PVCR >> 20);
+			ret = 1;
+			break;
+		}
+		msleep(chip->delay_ms);
+	}
+	return ret;
+}
+
+static int do_freq_transition(struct notifier_block *nb, unsigned long val,
+                              void *data)
+{
+	int ret = 0;
+	struct pxa27x_voltage_chip *chip = container_of(nb,
+			struct pxa27x_voltage_chip, freq_transition);
+	struct cpufreq_freqs *f = data;
+
+	dbg("v=%ld cpu=%u old=%u new=%u flags=%hu\n",
+	    val, f->cpu, f->old, f->new, f->flags);
+	
+	switch (val) {
+		case CPUFREQ_PRECHANGE:
+			if (f->new < f->old) break;
+			ret = change_voltage(f, chip);
+			break;
+		case CPUFREQ_POSTCHANGE:
+			if (f->new > f->old) break;
+			ret = change_voltage(f, chip);
+			break;
+		default:
+			printk(KERN_WARNING "pxa27x_voltage: "
+			       "Unhandled cpufreq event\n");
+			ret = 1;
+			break;
+	}
+
+	return ret;
+}
+
+static int pxa27x_voltage_probe(struct platform_device *pdev)
+{
+	struct pxa27x_voltage_chip *chip = pdev->dev.platform_data;
+
+	if (chip->step && (MAX_VOLTAGE_DROP + chip->step)/chip->step > 32) {
+		printk(KERN_ERR "pxa27x_voltage: step too small, commands "
+		       "will not fit in sequencer");
+		return -EINVAL;
+	}
+	else if (chip->delay) {
+		int i;
+		if (chip->delay > 24) chip->delay = 24;
+		chip->delay_ms = 2;
+		for (i = 1; i < chip->delay; i++)
+			chip->delay_ms *= 2;
+		chip->delay_ms = chip->delay_ms/13000 + 1;
+		dbg("delay_ms = %d\n", chip->delay_ms)
+	}
+
+	PCFR |= PCFR_PI2C_EN;
+	pxa_set_cken(CKEN15_PWRI2C,1);
+	chip->freq_transition.notifier_call = do_freq_transition;
+	return cpufreq_register_notifier(&chip->freq_transition,
+	                                 CPUFREQ_TRANSITION_NOTIFIER);
+}
+
+static int pxa27x_voltage_remove(struct platform_device *pdev)
+{
+	struct pxa27x_voltage_chip *chip = pdev->dev.platform_data;
+	int ret;
+	ret = cpufreq_unregister_notifier(&chip->freq_transition,
+	                                  CPUFREQ_TRANSITION_NOTIFIER);
+	pxa_set_cken(CKEN15_PWRI2C,0);
+	return ret;
+}
+
+static struct platform_driver pxa27x_voltage_driver = {
+	.probe = pxa27x_voltage_probe,
+	.remove = pxa27x_voltage_remove,
+	.driver = {
+		.name = "pxa27x-voltage",
+	},
+};
+
+static int __init pxa27x_voltage_init(void)
+{
+	return platform_driver_register(&pxa27x_voltage_driver);
+}
+
+static void __exit pxa27x_voltage_exit(void)
+{
+	platform_driver_unregister(&pxa27x_voltage_driver);
+	return;
+}
+
+module_init(pxa27x_voltage_init);
+module_exit(pxa27x_voltage_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Michal Sroczynski <msroczyn@elka.pw.edu.pl>, "
+              "Anton Vorontsov <cbou@mail.ru>");
+MODULE_DESCRIPTION("Voltage change for PXA27x");
diff --git a/code/train/C/0139982_Exercise-1-16-1.c b/code/train/C/0139982_Exercise-1-16-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4f328c21f01b2bc3fe3bf51018b1307cd90dfc5a
--- /dev/null
+++ b/code/train/C/0139982_Exercise-1-16-1.c
@@ -0,0 +1,81 @@
+/*
+ ============================================================================
+ Name        : Exercise-1-16-1.c
+ Author      : Daniel Marchena Parreira
+ Email       : danielmapar@gmail.com
+ Date        : 05/12/2013
+ Version     : 0.1
+ Copyright   : GNU General Public License Version 2
+ Description : Revise the main routine of the longest-line program so it will
+               correctly print the length of arbitrary long input lines, and
+               as much as possible of the text.
+ ============================================================================
+*/
+
+#include <stdio.h>
+#define MAXLINE 10 /* maximum input line length */
+
+int getline_new(char line[], int maxline); /* there is already a getline on stdio.h */
+void copy(char to[], char from[]);
+
+/* print the longest input line */
+int main(void)
+{
+	int len;                    /* first line length */
+	int len_tmp;                /* other lines temporarily length */
+	int max_len;                /* maximum length seen so far */
+	char first_line[MAXLINE];   /* first line saved here */
+	char line_tmp[MAXLINE];     /* other lines temporarily saved here */
+	char longest_line[MAXLINE]; /* longest line saved here */
+	char end_line;              /* flag to determine end of line */
+
+	max_len = 0;
+	end_line = ' ';
+	while ((len = getline_new(first_line, MAXLINE)) > 0)
+	{
+		if (len == (MAXLINE-1))
+			while (end_line == ' ' && (len_tmp = getline_new(line_tmp, MAXLINE)) > 0)
+			{
+				len += len_tmp;
+				if(len_tmp < (MAXLINE-1))
+					end_line = 'X';
+			}
+		len_tmp = 0;
+		end_line = ' ';
+		if(max_len < len)
+		{
+			max_len = len;
+			copy(longest_line, first_line);
+		}
+	}
+
+	if (max_len > 0) /* there was a line  */
+	{
+		printf("----------------\n");
+		printf("String: %s\nSize: %d\n", longest_line, max_len);
+	}
+
+	return 0;
+}
+
+/* getline_new: read a line into s, return length */
+int getline_new(char s[], int lim)
+{
+	int c, i;
+
+	for(i = 0; i < lim-1 && (c = getchar()) != EOF && c != '\n'; ++i)
+		s[i] = c;
+
+	s[i] = '\0';
+	return i;
+}
+
+/* copy: copy 'from' into 'to'; assume to is big enough */
+void copy(char to[], char from[])
+{
+	int i;
+
+	i = 0;
+	while((to[i] = from[i]) != '\0')
+		++i;
+}
diff --git a/code/train/C/0139990_1252.c b/code/train/C/0139990_1252.c
new file mode 100644
index 0000000000000000000000000000000000000000..a9483e6e2e3e6a848b4850a456c14dc849f1b2b1
--- /dev/null
+++ b/code/train/C/0139990_1252.c
@@ -0,0 +1,78 @@
+/******************************************************************************
+** File Name: 1252.c
+** Author:
+** Creation Time: Mon Oct 23 08:20:03 2017
+**
+** Result	Memory	Time	Language	Code Length	Submit Time
+** Accepted	436K	0MS	GCC		926B		2017-10-28 00:09:01
+*/
+#include <stdio.h>
+#include <string.h>
+
+#define	M	6	/* number of coin values */
+#define	V	100	/* value of coins ranges [1..V] */
+
+#define	Z	2000	/*(V * V) */
+
+int v[M + 1];
+int f[Z + 1];
+
+static void dp(void);
+
+int main(void)
+{
+	int n;
+	int i;
+	int sum;
+	int max;
+
+	scanf("%d", &n);
+	while (n--) {
+		for (i = 1; i <= M; ++i)
+			scanf("%d", &v[i]);
+		dp();
+
+		sum = 0;
+		max = 0;
+		for (i = 1; i <= V; ++i) {
+			sum += f[i];
+			if (max < f[i])
+				max = f[i];
+		}
+
+		printf("%d.%02d %d\n", sum / V, sum % V, max);
+	}
+
+	return 0;
+}
+
+#define	INF	0x7f
+
+void dp(void)
+{
+	int i;
+	int c;	/* capacity */
+	int w;	/* weight */
+	int t;
+
+	memset(f, INF, sizeof f);
+	f[0] = 0;
+
+	for (i = 1; i <= M; ++i) {
+		w = v[i];
+		for (c = w; c <= Z; ++c) {
+			t = f[c - w] + 1;
+			if (f[c] > t)
+				f[c] = t;
+		}
+	}
+
+	for (i = 1; i <= M; ++i) {
+		w = v[i];
+		for (c = Z - w; c > 0; --c) {
+			t = f[c + w] + 1;
+			if (f[c] > t)
+				f[c] = t;
+		}
+	}
+}
diff --git a/code/train/C/0140535_gcdext_1.c b/code/train/C/0140535_gcdext_1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f1dd9ee9630976792f0b7383fe271a70e08f7116
--- /dev/null
+++ b/code/train/C/0140535_gcdext_1.c
@@ -0,0 +1,81 @@
+/* mpn_gcdext -- Extended Greatest Common Divisor.
+
+Copyright 1996, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009 Free Software
+Foundation, Inc.
+
+This file is part of the GNU MP Library.
+
+The GNU MP 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 3 of the License, or (at your
+option) any later version.
+
+The GNU MP 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 the GNU MP Library.  If not, see http://www.gnu.org/licenses/.  */
+
+#include "gmp.h"
+#include "gmp-impl.h"
+#include "longlong.h"
+
+
+/* FIXME: Takes two single-word limbs. It could be extended to a
+ * function that accepts a bignum for the first input, and only
+ * returns the first co-factor. */
+
+mp_limb_t
+mpn_gcdext_1 (mp_limb_signed_t *up, mp_limb_signed_t *vp,
+	      mp_limb_t a, mp_limb_t b)
+{
+  /* Maintain
+
+     a =  u0 A + v0 B
+     b =  u1 A + v1 B
+
+     where A, B are the original inputs.
+  */
+  mp_limb_signed_t u0 = 1;
+  mp_limb_signed_t v0 = 0;
+  mp_limb_signed_t u1 = 0;
+  mp_limb_signed_t v1 = 1;
+
+  ASSERT (a > 0);
+  ASSERT (b > 0);
+
+  if (a < b)
+    goto divide_by_b;
+
+  for (;;)
+    {
+      mp_limb_t q;
+
+      q = a / b;
+      a -= q * b;
+
+      if (a == 0)
+	{
+	  *up = u1;
+	  *vp = v1;
+	  return b;
+	}
+      u0 -= q * u1;
+      v0 -= q * v1;
+
+    divide_by_b:
+      q = b / a;
+      b -= q * a;
+
+      if (b == 0)
+	{
+	  *up = u0;
+	  *vp = v0;
+	  return a;
+	}
+      u1 -= q * u0;
+      v1 -= q * v0;
+    }
+}
diff --git a/code/train/C/0140652_exynos3470_ppmu.c b/code/train/C/0140652_exynos3470_ppmu.c
new file mode 100644
index 0000000000000000000000000000000000000000..765ba661f4275d4f8ecbca0e75d2b6a6b3409c06
--- /dev/null
+++ b/code/train/C/0140652_exynos3470_ppmu.c
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ *		http://www.samsung.com/
+ *	Jonghwan Choi <Jonghwan Choi@samsung.com>
+ *
+ * EXYNOS - PPMU polling support
+ *	This version supports EXYNOS5250 only. This changes bus frequencies.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/debugfs.h>
+#include <linux/hrtimer.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+
+#include <mach/map.h>
+
+#include "exynos3470_ppmu.h"
+
+static DEFINE_SPINLOCK(exynos4270_ppmu_lock);
+static LIST_HEAD(exynos4270_ppmu_handle_list);
+
+struct exynos4270_ppmu_handle {
+	struct list_head node;
+	struct exynos4270_ppmu ppmu[PPMU_END];
+};
+
+static struct exynos4270_ppmu ppmu[PPMU_END] = {
+	[PPMU_DMC_0] = {
+		.hw_base = S5P_VA_PPMU_DMC0,
+		.event[PPMU_PMNCNT3] = RDWR_DATA_COUNT,
+	},
+	[PPMU_DMC_1] = {
+		.hw_base = S5P_VA_PPMU_DMC1,
+		.event[PPMU_PMNCNT3] = RDWR_DATA_COUNT,
+	},
+	[PPMU_CPU] = {
+		.hw_base = S5P_VA_PPMU_CPU,
+		.event[PPMU_PMNCNT3] = RDWR_DATA_COUNT,
+	},
+	[PPMU_RIGHT] = {
+		.hw_base = S5P_VA_PPMU_RIGHT,
+		.event[PPMU_PMNCNT3] = RDWR_DATA_COUNT,
+	},
+	[PPMU_LEFT] = {
+		.hw_base = S5P_VA_PPMU_LEFT,
+		.event[PPMU_PMNCNT3] = RDWR_DATA_COUNT,
+	},
+};
+
+static void exynos4270_ppmu_setevent(void __iomem *ppmu_base,
+					unsigned int ch,
+					unsigned int evt)
+{
+	__raw_writel(evt, ppmu_base + PPMU_BEVTSEL(ch));
+}
+
+
+static void exynos4270_ppmu_start(void __iomem *ppmu_base)
+{
+	__raw_writel(PPMU_ENABLE, ppmu_base);
+}
+
+static void exynos4270_ppmu_stop(void __iomem *ppmu_base)
+{
+	__raw_writel(PPMU_DISABLE, ppmu_base);
+}
+
+static void exynos4270_ppmu_reset(struct exynos4270_ppmu *ppmu)
+{
+	void __iomem *ppmu_base = ppmu->hw_base;
+	unsigned int cntens_val=0, flag_val=0, pmnc_val=0;
+	unsigned long flags;
+
+	cntens_val = PPMU_ENABLE_CYCLE | PPMU_ENABLE_COUNT0 |
+			PPMU_ENABLE_COUNT1 | PPMU_ENABLE_COUNT2 |
+			PPMU_ENABLE_COUNT3;
+
+	flag_val = cntens_val;
+
+	pmnc_val = PPMU_CC_RESET | PPMU_COUNT_RESET;
+
+	/* Reset PPMU */
+	__raw_writel(cntens_val, ppmu_base + PPMU_CNTENS);
+	__raw_writel(flag_val, ppmu_base + PPMU_FLAG);
+	__raw_writel(pmnc_val, ppmu_base);
+	__raw_writel(0x0, ppmu_base + PPMU_CCNT);
+
+	/* Set PPMU Event */
+	ppmu->event[PPMU_PMNCNT0] = RD_DATA_COUNT;
+	exynos4270_ppmu_setevent(ppmu_base, PPMU_PMNCNT0,
+				ppmu->event[PPMU_PMNCNT0]);
+
+	ppmu->event[PPMU_PMCCNT1] = WR_DATA_COUNT;
+	exynos4270_ppmu_setevent(ppmu_base, PPMU_PMCCNT1,
+				ppmu->event[PPMU_PMCCNT1]);
+
+	ppmu->event[PPMU_PMNCNT3] = RDWR_DATA_COUNT;
+	exynos4270_ppmu_setevent(ppmu_base, PPMU_PMNCNT3,
+				ppmu->event[PPMU_PMNCNT3]);
+
+	/* Start PPMU */
+	local_irq_save(flags);
+	exynos4270_ppmu_start(ppmu_base);
+	local_irq_restore(flags);
+
+}
+
+static void exynos4270_ppmu_read(struct exynos4270_ppmu *ppmu)
+{
+	void __iomem *ppmu_base = ppmu->hw_base;
+	u32 overflow;
+	int i;
+	unsigned long flags;
+
+	/* Stop PPMU */
+	local_irq_save(flags);
+	exynos4270_ppmu_stop(ppmu_base);
+	local_irq_restore(flags);
+
+	/* Update local data from PPMU */
+	ppmu->ccnt = __raw_readl(ppmu_base + PPMU_CCNT);
+	overflow = __raw_readl(ppmu_base + PPMU_FLAG);
+	ppmu->ccnt_overflow = overflow & PPMU_CCNT_OVERFLOW;
+
+	for (i = PPMU_PMNCNT0; i < PPMU_PMNCNT_MAX; i++) {
+		if (ppmu->event[i] == 0)
+			ppmu->count[i] = 0;
+		else {
+			if (i == PPMU_PMNCNT3)		/* RDWR data count */
+				ppmu->count[i] = ((__raw_readl(ppmu_base + PMCNT_OFFSET(i)) << 8) |
+						__raw_readl(ppmu_base + PMCNT_OFFSET(i + 1)));
+			else
+				ppmu->count[i] = __raw_readl(ppmu_base + PMCNT_OFFSET(i));
+		}
+	}
+}
+
+static void exynos4270_ppmu_add(struct exynos4270_ppmu *to, struct exynos4270_ppmu *from)
+{
+	int i, j;
+
+	for (i = 0; i < PPMU_END; i++) {
+		for (j = PPMU_PMNCNT0; j < PPMU_PMNCNT_MAX; j++)
+			to[i].count[j] += from[i].count[j];
+
+		to[i].ccnt += from[i].ccnt;
+		if (to[i].ccnt < from[i].ccnt)
+			to[i].ccnt_overflow = true;
+
+		to[i].ns += from[i].ns;
+
+		if (from[i].ccnt_overflow)
+			to[i].ccnt_overflow = true;
+	}
+}
+
+static void exynos4270_ppmu_handle_clear(struct exynos4270_ppmu_handle *handle)
+{
+	memset(&handle->ppmu, 0, sizeof(struct exynos4270_ppmu) * PPMU_END);
+}
+
+int exynos4270_ppmu_update(enum exynos4270_ppmu_sets filter)
+{
+	int i, ret = 0;
+	struct exynos4270_ppmu_handle *handle;
+	enum exynos4270_ppmu_list start, end;
+
+	ret = exynos4270_ppmu_get_filter(filter, &start, &end);
+	if (ret < 0)
+		return ret;
+
+	for (i = start; i <= end; i++) {
+		exynos4270_ppmu_read(&ppmu[i]);
+		exynos4270_ppmu_reset(&ppmu[i]);
+	}
+
+	list_for_each_entry(handle, &exynos4270_ppmu_handle_list, node)
+		exynos4270_ppmu_add(handle->ppmu, ppmu);
+
+	return ret;
+}
+
+int exynos4270_ppmu_get_filter(enum exynos4270_ppmu_sets filter,
+	enum exynos4270_ppmu_list *start, enum exynos4270_ppmu_list *end)
+{
+	switch (filter) {
+	case PPMU_SET_DDR:
+		*start = PPMU_DMC_0;
+		*end = PPMU_DMC_1;
+		break;
+	case PPMU_SET_INT:
+		*start = PPMU_RIGHT;
+		*end = PPMU_LEFT;
+		break;
+	case PPMU_SET_CPU:
+		*start = PPMU_CPU;
+		*end = PPMU_CPU;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+int exynos4270_ppmu_get_busy(struct exynos4270_ppmu_handle *handle,
+				enum exynos4270_ppmu_sets filter,
+				unsigned int *ccnt, unsigned long *pmcnt)
+{
+	unsigned long flags;
+	int i, ret, temp;
+	int busy = 0;
+	enum exynos4270_ppmu_list start, end;
+	unsigned int max_ccnt = 0, temp_ccnt = 0;
+	unsigned long max_pmcnt = 0, temp_pmcnt = 0;
+
+	ret = exynos4270_ppmu_get_filter(filter, &start, &end);
+	if (ret < 0)
+		return ret;
+
+	spin_lock_irqsave(&exynos4270_ppmu_lock, flags);
+
+	exynos4270_ppmu_update(filter);
+
+	for (i = start; i <= end; i++) {
+		if (handle->ppmu[i].ccnt_overflow) {
+			busy = -EOVERFLOW;
+			break;
+		}
+
+		temp_ccnt = handle->ppmu[i].ccnt;
+		if (temp_ccnt > max_ccnt)
+			max_ccnt = temp_ccnt;
+
+		temp_pmcnt = handle->ppmu[i].count[PPMU_PMNCNT3];
+		if (temp_pmcnt > max_pmcnt)
+			max_pmcnt = temp_pmcnt;
+
+		temp = handle->ppmu[i].count[PPMU_PMNCNT3] * 100;
+		if (handle->ppmu[i].count > 0 && temp > 0)
+			temp /= handle->ppmu[i].ccnt;
+
+		if (temp > busy)
+			busy = temp;
+
+	}
+
+	*ccnt = max_ccnt;
+	*pmcnt = max_pmcnt;
+
+	exynos4270_ppmu_handle_clear(handle);
+
+	spin_unlock_irqrestore(&exynos4270_ppmu_lock, flags);
+
+	return busy;
+
+}
+
+void exynos4270_ppmu_put(struct exynos4270_ppmu_handle *handle)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&exynos4270_ppmu_lock, flags);
+
+	list_del(&handle->node);
+
+	spin_unlock_irqrestore(&exynos4270_ppmu_lock, flags);
+
+	kfree(handle);
+}
+
+struct exynos4270_ppmu_handle *exynos4270_ppmu_get(enum exynos4270_ppmu_sets filter)
+{
+	struct exynos4270_ppmu_handle *handle;
+	unsigned long flags;
+
+	handle = kzalloc(sizeof(struct exynos4270_ppmu_handle), GFP_KERNEL);
+	if (!handle)
+		return NULL;
+
+	spin_lock_irqsave(&exynos4270_ppmu_lock, flags);
+
+	exynos4270_ppmu_update(filter);
+	list_add_tail(&handle->node, &exynos4270_ppmu_handle_list);
+
+	spin_unlock_irqrestore(&exynos4270_ppmu_lock, flags);
+
+	return handle;
+}
diff --git a/code/train/C/0140848_cuckoo.c b/code/train/C/0140848_cuckoo.c
new file mode 100644
index 0000000000000000000000000000000000000000..a44a6f49805936d7ea493b761c3e239a12c54e5c
--- /dev/null
+++ b/code/train/C/0140848_cuckoo.c
@@ -0,0 +1,288 @@
+/*
+Copyright (c) 2014. The YARA Authors. 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 <string.h>
+#include <jansson.h>
+
+
+#include <yara/re.h>
+#include <yara/modules.h>
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define strcasecmp _stricmp
+#endif
+
+#define MODULE_NAME cuckoo
+
+
+define_function(network_dns_lookup)
+{
+  YR_OBJECT* network_obj = parent();
+
+  json_t* network_json = (json_t*) network_obj->data;
+  json_t* dns_json = json_object_get(network_json, "dns");
+  json_t* value;
+
+  uint64_t result = 0;
+  size_t index;
+
+  char* ip;
+  char* hostname;
+
+  json_array_foreach(dns_json, index, value)
+  {
+    json_unpack(value, "{s:s, s:s}", "ip", &ip, "hostname", &hostname);
+
+    if (yr_re_match(regexp_argument(1), hostname) > 0)
+    {
+      result = 1;
+      break;
+    }
+  }
+
+  return_integer(result);
+}
+
+
+#define METHOD_GET    0x01
+#define METHOD_POST   0x02
+
+
+uint64_t http_request(
+    YR_OBJECT* network_obj,
+    RE_CODE uri_regexp,
+    int methods)
+{
+  json_t* network_json = (json_t*) network_obj->data;
+  json_t* http_json = json_object_get(network_json, "http");
+  json_t* value;
+
+  uint64_t result = 0;
+  size_t index;
+
+  char* method;
+  char* uri;
+
+  json_array_foreach(http_json, index, value)
+  {
+    json_unpack(value, "{s:s, s:s}", "uri", &uri, "method", &method);
+
+    if (((methods & METHOD_GET && strcasecmp(method, "get") == 0) ||
+         (methods & METHOD_POST && strcasecmp(method, "post") == 0)) &&
+         yr_re_match(uri_regexp, uri) > 0)
+    {
+      result = 1;
+      break;
+    }
+  }
+
+  return result;
+}
+
+
+define_function(network_http_request)
+{
+  return_integer(
+      http_request(
+          parent(),
+          regexp_argument(1),
+          METHOD_GET | METHOD_POST));
+}
+
+
+define_function(network_http_get)
+{
+  return_integer(
+      http_request(
+          parent(),
+          regexp_argument(1),
+          METHOD_GET));
+}
+
+
+define_function(network_http_post)
+{
+  return_integer(
+      http_request(
+          parent(),
+          regexp_argument(1),
+          METHOD_POST));
+}
+
+
+define_function(registry_key_access)
+{
+  YR_OBJECT* registry_obj = parent();
+
+  json_t* keys_json = (json_t*) registry_obj->data;
+  json_t* value;
+
+  uint64_t result = 0;
+  size_t index;
+
+  json_array_foreach(keys_json, index, value)
+  {
+    if (yr_re_match(regexp_argument(1), json_string_value(value)) > 0)
+    {
+      result = 1;
+      break;
+    }
+  }
+
+  return_integer(result);
+}
+
+
+define_function(filesystem_file_access)
+{
+  YR_OBJECT* filesystem_obj = parent();
+
+  json_t* files_json = (json_t*) filesystem_obj->data;
+  json_t* value;
+
+  uint64_t result = 0;
+  size_t index;
+
+  json_array_foreach(files_json, index, value)
+  {
+    if (yr_re_match(regexp_argument(1), json_string_value(value)) > 0)
+    {
+      result = 1;
+      break;
+    }
+  }
+
+  return_integer(result);
+}
+
+
+
+define_function(sync_mutex)
+{
+  YR_OBJECT* sync_obj = parent();
+
+  json_t* mutexes_json = (json_t*) sync_obj->data;
+  json_t* value;
+
+  uint64_t result = 0;
+  size_t index;
+
+  json_array_foreach(mutexes_json, index, value)
+  {
+    if (yr_re_match(regexp_argument(1), json_string_value(value)) > 0)
+    {
+      result = 1;
+      break;
+    }
+  }
+
+  return_integer(result);
+}
+
+
+begin_declarations;
+
+  begin_struct("network");
+    declare_function("dns_lookup", "r", "i", network_dns_lookup);
+    declare_function("http_get", "r", "i", network_http_get);
+    declare_function("http_post", "r", "i", network_http_post);
+    declare_function("http_request", "r", "i", network_http_request);
+  end_struct("network");
+
+  begin_struct("registry");
+    declare_function("key_access", "r", "i", registry_key_access);
+  end_struct("registry");
+
+  begin_struct("filesystem");
+    declare_function("file_access", "r", "i", filesystem_file_access);
+  end_struct("filesystem");
+
+  begin_struct("sync");
+    declare_function("mutex", "r", "i", sync_mutex);
+  end_struct("sync");
+
+end_declarations;
+
+
+int module_initialize(
+    YR_MODULE* module)
+{
+  return ERROR_SUCCESS;
+}
+
+
+int module_finalize(
+    YR_MODULE* module)
+{
+  return ERROR_SUCCESS;
+}
+
+
+int module_load(
+    YR_SCAN_CONTEXT* context,
+    YR_OBJECT* module_object,
+    void* module_data,
+    size_t module_data_size)
+{
+  YR_OBJECT* network_obj;
+  YR_OBJECT* registry_obj;
+  YR_OBJECT* filesystem_obj;
+  YR_OBJECT* sync_obj;
+
+  json_error_t json_error;
+
+  json_t* summary_json;
+  json_t* json;
+
+  if (module_data == NULL)
+    return ERROR_SUCCESS;
+
+  json = json_loadb(
+      (const char*) module_data,
+      module_data_size,
+      0,
+      &json_error);
+
+  if (json == NULL)
+    return ERROR_INVALID_FILE;
+
+  module_object->data = (void*) json;
+
+  network_obj = get_object(module_object, "network");
+  registry_obj = get_object(module_object, "registry");
+  filesystem_obj = get_object(module_object, "filesystem");
+  sync_obj = get_object(module_object, "sync");
+
+  network_obj->data = (void*) json_object_get(json, "network");
+
+  json = json_object_get(json, "behavior");
+  summary_json = json_object_get(json, "summary");
+
+  registry_obj->data = (void*) json_object_get(summary_json, "keys");
+  filesystem_obj->data = (void*) json_object_get(summary_json, "files");
+  sync_obj->data = (void*) json_object_get(summary_json, "mutexes");
+
+  return ERROR_SUCCESS;
+}
+
+
+int module_unload(YR_OBJECT* module)
+{
+  if (module->data != NULL)
+    json_decref((json_t*) module->data);
+
+  return ERROR_SUCCESS;
+}
diff --git a/code/train/C/0141297_network_timing.c b/code/train/C/0141297_network_timing.c
new file mode 100644
index 0000000000000000000000000000000000000000..678a69577c5595050b389bb29a90e3cf252ba18a
--- /dev/null
+++ b/code/train/C/0141297_network_timing.c
@@ -0,0 +1,188 @@
+/*
+  Estimate bandwidth and latency of a parallel computer using MPI.
+  Ole Moller Nielsen - 1998
+*/
+	
+#include <stdio.h>
+#include <stdlib.h>
+#include <mpi.h>
+
+
+#define MAXI  10         /* Number of blocks */
+#define MAXM  500000     /* Largest block */
+#define BLOCK MAXM/MAXI  /* Block size */
+
+
+double linfit(double* x, double* y, int N, double* a, double* b) 
+{
+  /* Given vectors y and x fit a and b to the model y = ax + b */
+  
+  double Sx=0, Sy=0, SxoN=0, SSoN=0, t=0;
+  double res, varest=0, norm=0; 
+  int i;
+  
+  for (i=0; i<N; i++)
+  {
+    /*printf("x,y = %f, %f\n",x[i],y[i]);*/
+    Sx  = Sx + x[i];
+    Sy  = Sy + y[i];
+  }
+
+  SxoN = Sx/N;
+  
+  *a = 0.0; 
+  for (i=0; i<N; i++)
+  {
+    t    = x[i] - SxoN;
+    SSoN = SSoN + t*t;
+    *a   = *a + t*y[i];
+  }
+
+  *a = (*a)/SSoN;          /* a = (N Sxy - SxSy)/(NSxx - Sx^2) */
+  *b = (Sy - Sx*(*a))/N;
+  
+  /* Quality - variance estimate \sum_i r_i^2 /(m-n) */
+  for (i=0; i<N; i++)
+  {
+    norm = norm + x[i]*x[i];
+    res = y[i] - (*a)*x[i] - (*b);
+    varest = varest + res*res;
+  } 
+  varest = varest/norm/(N-2); 
+  return(varest);
+}
+
+main(int argc, char **argv) 
+{
+   int repeats = 10, msgid = 0;
+   int myid, procs;
+   int i,j,k,m;
+
+   double t1, t2, cpuOH; 
+   double Tbw, Tlat;
+   double varest;
+      
+   int noelem[MAXI];
+   double bytes[MAXI];   
+   double mintime[MAXI];   
+   double maxtime[MAXI];      
+   double avgtime[MAXI];         
+   double A[MAXM]; 
+
+   int  namelen;
+   char processor_name[MPI_MAX_PROCESSOR_NAME];
+   
+   MPI_Status stat;
+  
+   
+   /* Initialize */
+
+   MPI_Init(&argc,&argv);
+   MPI_Comm_size(MPI_COMM_WORLD,&procs);
+   MPI_Comm_rank(MPI_COMM_WORLD,&myid);
+   MPI_Get_processor_name(processor_name,&namelen);
+   
+   if (myid==0)
+   {
+     printf("MAXM = %d, number of processors = %d\n",MAXM,procs);         
+     printf("Measurements are repeated %d times for reliability\n",repeats);
+   } 
+   
+   if (procs < 2) {
+     printf("Program needs at least two processors - aborting\n");
+     MPI_Abort(MPI_COMM_WORLD,999);
+   }
+   
+   MPI_Barrier(MPI_COMM_WORLD); /* Synchronize */   
+   printf("I am process %d on %s\n",myid,processor_name);   
+      
+   for (j=0; j<MAXM; j++) 
+   {
+      A[j]=rand();
+   }   
+   for (i=0; i<MAXI; i++) 
+   {
+      avgtime[i] =  0;         
+      mintime[i] =  1000000;      
+      maxtime[i] = -1000000;            
+   }
+   
+   /* Determine timer overhead */
+   if (myid == 0) {   
+     cpuOH = 1.0;
+     for (k=0; k<repeats; k++)   /* Repeat to get reliable timings */
+     { 
+       t1 = MPI_Wtime();
+       t2 = MPI_Wtime();
+       if (t2-t1 < cpuOH) cpuOH = t2-t1;
+     }  
+     printf("Timing overhead is %f seconds\n\n", cpuOH);              
+   }
+
+   
+        
+   /* Pass msg circularly */
+     
+   for (k=0; k<repeats; k++) {
+     if (myid == 0) {  
+       printf("Run %d of %d\n", k+1, repeats);
+     }  
+
+     for (i=0; i<MAXI; i++) {
+       /*m=BLOCK*(i+1);*/
+       m=BLOCK*i+1;       
+      
+       noelem[i] = m;
+      
+       MPI_Barrier(MPI_COMM_WORLD); /* Synchronize */
+      
+       if (myid == 0) {
+         t1=MPI_Wtime();
+         MPI_Send(&A[0],m,MPI_DOUBLE,1,msgid,MPI_COMM_WORLD);
+         MPI_Recv(&A[0],m,MPI_DOUBLE,procs-1,msgid,MPI_COMM_WORLD,&stat);
+         t2=MPI_Wtime() - t1 - cpuOH;
+	 t2 = t2/procs;
+	 avgtime[i] = avgtime[i] + t2;
+         if (t2 < mintime[i]) mintime[i] = t2;
+         if (t2 > maxtime[i]) maxtime[i] = t2;	 
+       } else {
+         MPI_Recv(&A[0],m,MPI_DOUBLE,myid-1,msgid,MPI_COMM_WORLD,&stat);
+         MPI_Send(&A[0],m,MPI_DOUBLE,(myid+1)%procs,msgid,MPI_COMM_WORLD);
+       }
+     } 
+   }
+
+   if (myid == 0) {
+     printf("Bytes transferred   time (micro seconds)\n");
+     printf("                    min        avg        max \n");     
+     printf("----------------------------------------------\n");      
+        
+     for (i=0; i<MAXI; i++) {
+       avgtime[i] = avgtime[i]/repeats*1.0e6; /*Average micro seconds*/
+       mintime[i] = mintime[i]*1.0e6;         /*Min micro seconds*/       
+       maxtime[i] = maxtime[i]*1.0e6;         /*Min micro seconds*/              
+             
+       m = noelem[i];
+       bytes[i] = (double) 8*noelem[i];       
+	 
+       /* printf("m=%d, time(min)=%lf, time(avg)=%lf, time(max)=%lf\n",
+	       m,mintime[i],avgtime[i],maxtime[i]); */
+       printf("%10d    %10d %10d %10d\n",
+	 (int) bytes[i], (int) mintime[i], (int) avgtime[i], (int)maxtime[i]); 
+     }		 
+   
+     varest=linfit(bytes, mintime, MAXI, &Tbw, &Tlat);
+     printf("\nLinear regression on best timings (t = t_l + t_b * bytes):\n");
+
+     printf("  t_b = %f\n  t_l = %f\n", Tbw, Tlat);
+     printf("  Estimated relative variance = %.9f\n\n",varest);     
+
+     printf("Estimated bandwith (1/t_b):  %.3f Mb/s\n", (1.0/Tbw));         
+     printf("Estimated latency:           %d micro s\n", 
+             (int) (mintime[0] - (float) bytes[0]* (float)Tbw));         
+     
+   }
+
+   MPI_Finalize();
+}
+
diff --git a/code/train/C/0141391_value.c b/code/train/C/0141391_value.c
new file mode 100644
index 0000000000000000000000000000000000000000..fcbc6c21e23506995c93dabd267c3a323f97b57d
--- /dev/null
+++ b/code/train/C/0141391_value.c
@@ -0,0 +1,169 @@
+#include "internal.h"
+
+#if !defined( __CELLOS_LV2__) && !defined(__MWERKS__)
+#include <memory.h>
+#endif
+#include <string.h>
+
+static void rc_parse_cond_value(rc_value_t* self, const char** memaddr, rc_parse_state_t* parse) {
+  rc_condition_t** next;
+  int has_measured;
+  int in_add_address;
+
+  has_measured = 0;
+  in_add_address = 0;
+  self->expressions = 0;
+
+  /* this largely duplicates rc_parse_condset, but we cannot call it directly, as we need to check the 
+   * type of each condition as we go */
+  self->conditions = RC_ALLOC(rc_condset_t, parse);
+  self->conditions->next = 0;
+  self->conditions->has_pause = 0;
+
+  next = &self->conditions->conditions;
+  for (;;) {
+    *next = rc_parse_condition(memaddr, parse, in_add_address);
+
+    if (parse->offset < 0) {
+      return;
+    }
+
+    in_add_address = (*next)->type == RC_CONDITION_ADD_ADDRESS;
+
+    switch ((*next)->type) {
+      case RC_CONDITION_ADD_HITS:
+      case RC_CONDITION_ADD_SOURCE:
+      case RC_CONDITION_SUB_SOURCE:
+      case RC_CONDITION_AND_NEXT:
+      case RC_CONDITION_ADD_ADDRESS:
+        /* combining flags are allowed */
+        break;
+
+      case RC_CONDITION_RESET_IF:
+        /* ResetIf is allowed (primarily for rich presense - leaderboard will typically cancel instead of resetting) */
+        break;
+
+      case RC_CONDITION_MEASURED:
+        if (has_measured) {
+          parse->offset = RC_MULTIPLE_MEASURED;
+          return;
+        }
+        has_measured = 1;
+        if ((*next)->required_hits == 0 && (*next)->oper != RC_CONDITION_NONE)
+          (*next)->required_hits = (unsigned)-1;
+        break;
+
+      default:
+        /* non-combinding flags and PauseIf are not allowed */
+        parse->offset = RC_INVALID_VALUE_FLAG;
+        return;
+    }
+
+    (*next)->pause = 0;
+    next = &(*next)->next;
+
+    if (**memaddr != '_') {
+      break;
+    }
+
+    (*memaddr)++;
+  }
+
+  *next = 0;
+
+  if (!has_measured) {
+    parse->offset = RC_MISSING_VALUE_MEASURED;
+  }
+}
+
+void rc_parse_value_internal(rc_value_t* self, const char** memaddr, rc_parse_state_t* parse) {
+  rc_expression_t** next;
+
+  /* if it starts with a condition flag (M: A: B: C:), parse the conditions */
+  if ((*memaddr)[1] == ':') {
+    rc_parse_cond_value(self, memaddr, parse);
+    return;
+  }
+
+  self->conditions = 0;
+  next = &self->expressions;
+
+  for (;;) {
+    *next = rc_parse_expression(memaddr, parse);
+
+    if (parse->offset < 0) {
+      return;
+    }
+
+    next = &(*next)->next;
+
+    if (**memaddr != '$') {
+      break;
+    }
+
+    (*memaddr)++;
+  }
+
+  *next = 0;
+}
+
+int rc_value_size(const char* memaddr) {
+  rc_value_t* self;
+  rc_parse_state_t parse;
+  rc_init_parse_state(&parse, 0, 0, 0);
+
+  self = RC_ALLOC(rc_value_t, &parse);
+  rc_parse_value_internal(self, &memaddr, &parse);
+
+  rc_destroy_parse_state(&parse);
+  return parse.offset;
+}
+
+rc_value_t* rc_parse_value(void* buffer, const char* memaddr, lua_State* L, int funcs_ndx) {
+  rc_value_t* self;
+  rc_parse_state_t parse;
+  rc_init_parse_state(&parse, buffer, L, funcs_ndx);
+  
+  self = RC_ALLOC(rc_value_t, &parse);
+  rc_init_parse_state_memrefs(&parse, &self->memrefs);
+
+  rc_parse_value_internal(self, &memaddr, &parse);
+
+  rc_destroy_parse_state(&parse);
+  return parse.offset >= 0 ? self : 0;
+}
+
+static int rc_evaluate_expr_value(rc_value_t* self, rc_eval_state_t* eval_state) {
+  rc_expression_t* exp;
+  int value, max;
+
+  exp = self->expressions;
+  max = rc_evaluate_expression(exp, eval_state);
+
+  for (exp = exp->next; exp != 0; exp = exp->next) {
+    value = rc_evaluate_expression(exp, eval_state);
+
+    if (value > max) {
+      max = value;
+    }
+  }
+
+  return max;
+}
+
+int rc_evaluate_value(rc_value_t* self, rc_peek_t peek, void* ud, lua_State* L) {
+  rc_eval_state_t eval_state;
+  memset(&eval_state, 0, sizeof(eval_state));
+  eval_state.peek = peek;
+  eval_state.peek_userdata = ud;
+  eval_state.L = L;
+
+  rc_update_memref_values(self->memrefs, peek, ud);
+
+  if (self->expressions) {
+    return rc_evaluate_expr_value(self, &eval_state);
+  }
+
+  rc_test_condset(self->conditions, &eval_state);
+  return (int)eval_state.measured_value;
+}
diff --git a/code/train/C/0141441_cr.c b/code/train/C/0141441_cr.c
new file mode 100644
index 0000000000000000000000000000000000000000..00466cc40a6add846c73d983c02575e772e81e34
--- /dev/null
+++ b/code/train/C/0141441_cr.c
@@ -0,0 +1,234 @@
+/* strips carriage returns from input to convert from DOS format
+ * or places carriage returns before newlines to convert to DOS format
+ * written by Alexander George
+ * 11/20/2015
+ */
+#include <stdio.h>
+#include <string.h>
+#ifdef WIN32
+#include <io.h>
+#include <fcntl.h>
+#endif
+
+// struct to hold the flags generated from the command line parse
+struct Flags
+{
+	int help;
+	int reverse;
+	int count;
+};
+
+int parse(int, char*[], struct Flags*);
+int printhelp(void);
+int process(char*, struct Flags*);
+int getfd(char*, char**, FILE**, FILE**);
+int stripcr(FILE*, FILE*);
+int reversecr(FILE*, FILE*);
+int closefiles(char*, char*, FILE*, FILE*);
+
+int main(int argc, char *argv[])
+{
+	int numfiles, i, error;
+	struct Flags f;
+
+	numfiles = parse(argc, argv, &f);
+	if (f.help)	// if the help flag is specified, print help and return
+	{
+		printhelp();
+		return 0;
+	}
+	else if (numfiles < 0)	// if unknown command line option, return error
+	{
+		return -1;
+	}
+	else if (numfiles == 0) // if no files specified, use as filter
+	{
+		process(NULL, &f);
+	}
+	else if (numfiles)	// process each file according to flags
+	{
+		for (i = 1; i < argc; i++)
+		{
+			error = 0;
+			if (argv[i][0] != '-')	// if it is a file, process it
+			{
+				error = process(argv[i], &f);
+			}
+			if (error)	// print an error message if an error occurs but continue processing remaining files
+			{
+				fprintf(stderr, "Error processing %s\n", argv[i]);
+			}
+		}
+	}
+	return 0;
+}
+
+// fill flags struct and return the number of files or error
+int parse(int argc, char *argv[], struct Flags *f)
+{
+	int i, numfiles;
+
+	f->help = f->reverse = f->count = numfiles = 0;
+	for (i = 1; i < argc; i++)	// for each argument
+	{
+		if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "-?") || !strcmp(argv[i], "--help"))
+		{
+			f->help = 1;
+		}
+		else if (!strcmp(argv[i], "-r") || !strcmp(argv[i], "--reverse"))
+		{
+			f->reverse = 1;
+		}
+		else if (!strcmp(argv[i], "-c") || !strcmp(argv[i], "--count"))
+		{
+			f->count = 1;
+		}
+		else if (argv[i][0] == '-')	// error
+		{
+			fprintf(stderr, "Unknown option %s\n", argv[i]);
+			return  -1;
+		}
+		else
+		{
+			numfiles++;
+		}
+	}
+	return numfiles;	// the actual number of files doesn't matter; only whether it is zero or not
+}
+
+int printhelp(void)
+{
+	printf("usage: cr [option] ... [file] ...\nstrips carriage returns from input\noptions:\n");
+	printf("%-20sConvert to DOS format by adding carriage returns before newlines\n", "-r, --reverse");
+	printf("%-20sDisplay the number of carriage returns processed\n", "-c, --count");
+	printf("%-20sShow this help message\n", "-h, -?, --help");
+}
+
+// process a single file given the flags
+int process(char *file, struct Flags *f)
+{
+	int count, error;
+	char *tempname;
+	FILE *in, *out;
+
+	if (file)
+	{
+		error = getfd(file, &tempname, &in, &out);
+		if (error)
+		{
+			return error;
+		}
+	}
+	else
+	{
+		in = stdin;
+		out = stdout;
+	}
+
+#ifdef WIN32
+	if (_setmode(_fileno( in), _O_BINARY) < 0 || _setmode(_fileno( out), _O_BINARY) < 0)
+	{
+		fprintf(stderr, "Error setting file mode to binary\n");
+		return -1;
+	}
+#endif
+	if (f->reverse)
+	{
+		count = reversecr(in, out);
+	}
+	else
+	{
+		count = stripcr(in, out);
+	}
+	if (f->count)
+	{
+		if (file)
+		{
+			printf("%s:\t", file);
+		}
+		printf("%d\n", count);
+	}
+	if (file)
+	{
+		closefiles(file, tempname, in, out);
+	}
+	return 0;
+}
+
+// get input and output file descriptors
+int getfd(char *file, char **tempname, FILE **in, FILE **out)
+{
+	static char temp[] = "XXXXXX";
+	// open input file
+	*in = fopen(file, "rb");
+	if (!*in)
+	{
+		fprintf(stderr, "Error opening file %s for input\n", file);
+		return -1;
+	}
+	*tempname = mktemp(temp);
+	*out = fopen(*tempname, "wb");
+	if (!*out)
+	{
+		fprintf(stderr, "Error opening temporary output file\n");
+		return -2;
+	}
+	return 0;
+}
+
+int stripcr(FILE *in, FILE *out)
+{
+	int c, count;
+
+	count = 0;
+	while ((c = fgetc(in)) != EOF)
+	{
+		if (c != '\r')
+		{
+			fputc(c, out);
+		}
+		else
+		{
+			count++;
+		}
+	}
+	return count;
+}
+
+int reversecr(FILE *in, FILE *out)
+{
+	int c, d, count;
+
+	count = d = 0;
+	while ((c = fgetc(in)) != EOF)
+	{
+		if (c == '\n')
+		{
+			if (d != '\r')
+			{
+				fputc('\r', out);
+				count++;
+			}
+		}
+		fputc(c, out);
+		d = c;
+	}
+	return count;
+}
+
+int closefiles(char *file, char *tempname, FILE *in, FILE *out)
+{
+	fclose(in);
+	fclose(out);
+	if (remove(file))
+	{
+		fprintf(stderr, "Error removing %s\n", file);
+		return -3;
+	}
+	if (rename(tempname, file))
+	{
+		fprintf(stderr, "Error renaming file.\n");
+		return -4;
+	}
+	return 0;
+}
diff --git a/code/train/C/0141859_cbuf.c b/code/train/C/0141859_cbuf.c
new file mode 100644
index 0000000000000000000000000000000000000000..bb700f2d457a81f2d89d782bc5c75340b910f66d
--- /dev/null
+++ b/code/train/C/0141859_cbuf.c
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2008-2013 Travis Geiselbrecht
+ *
+ * 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 <stdlib.h>
+#include <debug.h>
+#include <pow2.h>
+#include <string.h>
+#include <assert.h>
+#include <lib/cbuf.h>
+#include <kernel/event.h>
+
+#define LOCAL_TRACE 0
+
+#define INC_POINTER(cbuf, ptr, inc) \
+    modpow2(((ptr) + (inc)), (cbuf)->len_pow2)
+
+void cbuf_initialize(cbuf_t *cbuf, size_t len)
+{
+	DEBUG_ASSERT(cbuf);
+	DEBUG_ASSERT(len > 0);
+	DEBUG_ASSERT(ispow2(len));
+
+	cbuf->head = 0;
+	cbuf->tail = 0;
+	cbuf->len_pow2 = log2_uint(len);
+	cbuf->buf = malloc(len);
+	event_init(&cbuf->event, false, 0);
+
+	LTRACEF("len %zd, len_pow2 %u\n", len, cbuf->len_pow2);
+}
+
+size_t cbuf_space_avail(cbuf_t *cbuf)
+{
+	uint consumed = modpow2((uint)(cbuf->head - cbuf->tail), cbuf->len_pow2);
+	return valpow2(cbuf->len_pow2) - consumed - 1;
+}
+
+size_t cbuf_write(cbuf_t *cbuf, const void *_buf, size_t len, bool canreschedule)
+{
+	const char *buf = (const char *)_buf;
+
+	LTRACEF("len %zd\n", len);
+
+	DEBUG_ASSERT(cbuf);
+	DEBUG_ASSERT(_buf);
+	DEBUG_ASSERT(len < valpow2(cbuf->len_pow2));
+
+	enter_critical_section();
+
+	size_t write_len;
+	size_t pos = 0;
+
+	while (pos < len && cbuf_space_avail(cbuf) > 0) {
+		if (cbuf->head >= cbuf->tail) {
+			write_len = MIN(valpow2(cbuf->len_pow2) - cbuf->head, len - pos);
+		} else {
+			write_len = MIN(cbuf->tail - cbuf->head - 1, len - pos);
+		}
+
+		// if it's full, abort and return how much we've written
+		if (write_len == 0) {
+			break;
+		}
+
+		memcpy(cbuf->buf + cbuf->head, buf + pos, write_len);
+
+		cbuf->head = INC_POINTER(cbuf, cbuf->head, write_len);
+		pos += write_len;
+	}
+
+	if (cbuf->head != cbuf->tail)
+		event_signal(&cbuf->event, canreschedule);
+
+	exit_critical_section();
+
+	return pos;
+}
+
+size_t cbuf_read(cbuf_t *cbuf, void *_buf, size_t buflen, bool block)
+{
+	char *buf = (char *)_buf;
+
+	DEBUG_ASSERT(cbuf);
+	DEBUG_ASSERT(_buf);
+
+	enter_critical_section();
+
+	if (block)
+		event_wait(&cbuf->event);
+
+	// see if there's data available
+	size_t ret = 0;
+	if (cbuf->tail != cbuf->head) {
+		size_t pos = 0;
+
+		// loop until we've read everything we need
+		// at most this will make two passes to deal with wraparound
+		while (pos < buflen && cbuf->tail != cbuf->head) {
+			size_t read_len;
+			if (cbuf->head > cbuf->tail) {
+				// simple case where there is no wraparound
+				read_len = MIN(cbuf->head - cbuf->tail, buflen - pos);
+			} else {
+				// read to the end of buffer in this pass
+				read_len = MIN(valpow2(cbuf->len_pow2) - cbuf->tail, buflen - pos);
+			}
+
+			memcpy(buf + pos, cbuf->buf + cbuf->tail, read_len);
+
+			cbuf->tail = INC_POINTER(cbuf, cbuf->tail, read_len);
+			pos += read_len;
+		}
+
+		if (cbuf->tail == cbuf->head) {
+			// we've emptied the buffer, unsignal the event
+			event_unsignal(&cbuf->event);
+		}
+
+		ret = pos;
+	}
+
+	exit_critical_section();
+
+	return ret;
+}
+
+size_t cbuf_write_char(cbuf_t *cbuf, char c, bool canreschedule)
+{
+	DEBUG_ASSERT(cbuf);
+
+	enter_critical_section();
+
+	size_t ret = 0;
+	if (cbuf_space_avail(cbuf) > 0) {
+		cbuf->buf[cbuf->head] = c;
+
+		cbuf->head = INC_POINTER(cbuf, cbuf->head, 1);
+		ret = 1;
+
+		if (cbuf->head != cbuf->tail)
+			event_signal(&cbuf->event, canreschedule);
+	}
+
+	exit_critical_section();
+
+	return ret;
+}
+
+size_t cbuf_read_char(cbuf_t *cbuf, char *c, bool block)
+{
+	DEBUG_ASSERT(cbuf);
+	DEBUG_ASSERT(c);
+
+	enter_critical_section();
+
+	if (block)
+		event_wait(&cbuf->event);
+
+	// see if there's data available
+	size_t ret = 0;
+	if (cbuf->tail != cbuf->head) {
+
+		*c = cbuf->buf[cbuf->tail];
+		cbuf->tail = INC_POINTER(cbuf, cbuf->tail, 1);
+
+		if (cbuf->tail == cbuf->head) {
+			// we've emptied the buffer, unsignal the event
+			event_unsignal(&cbuf->event);
+		}
+
+		ret = 1;
+	}
+
+	exit_critical_section();
+
+	return ret;
+}
+
diff --git a/code/train/C/0141891_australian.c b/code/train/C/0141891_australian.c
new file mode 100644
index 0000000000000000000000000000000000000000..eaf9efffb740d7c8c1bfe76fbc7327c8e90713e4
--- /dev/null
+++ b/code/train/C/0141891_australian.c
@@ -0,0 +1,105 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Global candidates array */
+typedef struct {
+    char name[80];
+    int votes[20]; /* Each element from 0 to n represent preference of votes 0 = first */
+} candidate;
+
+candidate candidates[20];
+
+void printCands(int n) {
+    for (int i = 0; i < n; i++) printf("[%s]", candidates[i].name);
+    printf("\n");
+}
+
+void winners(int n, int voters) {
+    int place = 0;
+    while (place <= n) {
+        int max = -1;
+        int min = 1001;
+        int ties = 0;
+        int totalVotes = 0;
+
+        for (int i = 0; i < n; i++) {
+            int currVotes = candidates[i].votes[place];
+            totalVotes += currVotes;
+            if (currVotes > max) max = currVotes;
+            if (currVotes < min) min = currVotes;
+        }
+
+        for (int i = 0; i < n; i++) {
+            candidate curr = candidates[i];
+            if (((float) curr.votes[place] / (float) totalVotes) > (float) .5) { // Has to be more than fifty percent of the vote
+                printf("%s\n",curr.name);
+                return;
+            } else if (curr.votes[place] == min) { ties++; }
+        }
+
+        candidate tmp[n - ties];
+        int tmpIndex = 0;
+        for (int i = 0; i < n; i++) { /* Eliminate the lowest votes */
+            if (candidates[i].votes[place] > min) {
+                tmp[tmpIndex] = candidates[i];
+                tmpIndex++;
+            }
+        }
+        printCands(n);
+        memset(candidates, 0, sizeof candidates);
+        memcpy(candidates, tmp, sizeof tmp);
+        printCands(n);
+        place++;
+        n -= ties;
+    }
+    for (int i = 0; i < n; i++) printf("%s\n", candidates[i].name);
+    return;
+}
+
+int main(int argc, char const *argv[]) {
+    int cases;
+    char line[80];
+    fgets(line, sizeof line, stdin);
+    sscanf(line, "%d", &cases);
+    fgets(line, sizeof line, stdin); /* Empty Line */
+    for (int i = 0; i < cases; i++) {
+        int n; /* Number of candidates */
+        fgets(line, sizeof line, stdin);
+        sscanf(line, "%d", &n);
+        char first[40];
+        char last[40];
+        for (int j = 0 ; j < n; j++) {
+            candidate curr;
+            fgets(line, sizeof line, stdin);
+            sscanf(line, "%s %s", first, last);
+            strcpy(curr.name, first);
+            strcat(curr.name, " ");
+            strcat(curr.name, last);
+            candidates[j] = curr;
+        }
+
+        /* Now we have an array of the candidates */
+        int vote;
+        int totalVoters = 0;
+        while (fgets(line, sizeof line, stdin) != NULL && (line[0] != '\n')) { /* Until we hit an empty line */
+            totalVoters++;
+            int counter = 0;
+            vote = 0;
+            char* token = strtok(line, " ");
+            while (token != NULL) {
+                if (token) {
+                    vote =  atoi(token);
+                    candidate* votedFor = &candidates[vote - 1]; //candidate votedFor = candidates[vote - 1]
+                    votedFor->votes[counter] += 1; /* increment votes for candidate at the received preference */
+                    counter++;
+                }
+                token = strtok(NULL, " ");
+            }
+            memset(line, 0, sizeof line);
+        }
+
+        winners(n, totalVoters);
+    }
+    return 0;
+}
diff --git a/code/train/C/0141896_utf8.c b/code/train/C/0141896_utf8.c
new file mode 100644
index 0000000000000000000000000000000000000000..d237eb2211f8ba414197c225acbf422fa150b397
--- /dev/null
+++ b/code/train/C/0141896_utf8.c
@@ -0,0 +1,170 @@
+/**********************************************************************************************/
+/* The MIT License                                                                            */
+/*                                                                                            */
+/* Copyright 2016-2016 Twitch Interactive, Inc. or its affiliates. All Rights Reserved.       */
+/*                                                                                            */
+/* 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 "utf8.h"
+#include <string.h>
+
+const utf8_char_t* utf8_char_next (const char* s)
+{
+    if (0x80 == (s[0]&0xC0)) { ++s; }
+
+    return s;
+}
+
+// returnes the length of the char in bytes
+size_t utf8_char_length (const utf8_char_t* c)
+{
+    // count null term as zero size
+    if (0x00 == c[0]) { return 0; }
+
+    if (0x00 == (c[0]&0x80)) { return 1; }
+
+    if (0xC0 == (c[0]&0xE0) && 0x80 == (c[1]&0xC0)) { return 2; }
+
+    if (0xE0 == (c[0]&0xF0) && 0x80 == (c[1]&0xC0) && 0x80 == (c[2]&0xC0)) { return 3; }
+
+    if (0xF0 == (c[0]&0xF8) && 0x80 == (c[1]&0xC0) && 0x80 == (c[2]&0xC0) && 0x80 == (c[3]&0xC0)) { return 4; }
+
+    return 0;
+}
+
+// returns length of the string in bytes
+// size is number of charcter to count (0 to count until NULL term)
+size_t utf8_string_length (const utf8_char_t* data, utf8_size_t size)
+{
+    size_t char_length, byts = 0;
+
+    if (0 == size) {
+        size = utf8_char_count (data,0);
+    }
+
+    for (; 0 < size ; --size) {
+        if (0 == (char_length = utf8_char_length (data))) {
+            break;
+        }
+
+        data += char_length;
+        byts += char_length;
+    }
+
+    return byts;
+}
+
+size_t utf8_char_copy (utf8_char_t* dst, const utf8_char_t* src)
+{
+    size_t bytes = utf8_char_length (src);
+
+    if (bytes&&dst) {
+        memcpy (dst,src,bytes);
+        dst[bytes] = '\0';
+    }
+
+    return bytes;
+}
+
+// returnes the number of utf8 charcters in a string given the number of bytes
+// to count until the a null terminator, pass 0 for size
+utf8_size_t utf8_char_count (const char* data, size_t size)
+{
+    size_t i, bytes = 0;
+    utf8_size_t count = 0;
+
+    if (0 == size) {
+        size = strlen (data);
+    }
+
+    for (i = 0 ; i < size ; ++count, i += bytes) {
+        if (0 == (bytes = utf8_char_length (&data[i]))) {
+            break;
+        }
+    }
+
+    return count;
+}
+
+// returnes the length of the line in bytes triming not printable charcters at the end
+size_t utf8_trimmed_length (const char* data, size_t size)
+{
+    for (; 0 < size && ' ' >= (uint8_t) data[size-1] ; --size) { }
+
+    return size;
+}
+
+// returns the length in bytes of the line including the new line charcter(s)
+// auto detects between windows(CRLF), unix(LF), mac(CR) and riscos (LFCR) line endings
+size_t utf8_line_length (const char* data)
+{
+    size_t len = 0;
+
+    for (len = 0; 0 != data[len]; ++len) {
+        if ('\r' == data[len]) {
+            if ('\n' == data[len+1]) {
+                return len + 2; // windows
+            } else {
+                return len + 1; // unix
+            }
+        } else if ('\n' == data[len]) {
+            if ('\r' == data[len+1]) {
+                return len + 2; // riscos
+            } else {
+                return len + 1; // macos
+            }
+        }
+    }
+
+    return len;
+}
+
+// returns number of chars to include before split
+utf8_size_t utf8_wrap_length (const utf8_char_t* data, utf8_size_t size)
+{
+    // Set split_at to size, so if a split point cna not be found, retuns the size passed in
+    size_t char_length, char_count, split_at = size;
+
+    for (char_count = 0 ; char_count <= size ; ++char_count) {
+        if (' ' >= (*data)) {
+            split_at = char_count;
+        }
+
+        char_length = utf8_char_length (data);
+        data += char_length;
+    }
+
+    return split_at;
+}
+
+int utf8_line_count (const utf8_char_t* data)
+{
+    size_t len = 0;
+    int count = 0;
+
+    do {
+        len = utf8_line_length (data);
+        data += len; ++count;
+    } while (0<len);
+
+    return count-1;
+}
diff --git a/code/train/C/0141960_apilist.c b/code/train/C/0141960_apilist.c
new file mode 100644
index 0000000000000000000000000000000000000000..03846cd50c44b089cc7b273e558567abe83020ca
--- /dev/null
+++ b/code/train/C/0141960_apilist.c
@@ -0,0 +1,235 @@
+/*
+ * apilist.c
+ */
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "mrdb.h"
+#include "mrdberror.h"
+#include "apilist.h"
+#include "mruby/compile.h"
+#include "mruby/irep.h"
+#include "mruby/debug.h"
+
+#define LINE_BUF_SIZE MAX_COMMAND_LINE
+
+typedef struct source_file {
+  char *path;
+  uint16_t lineno;
+  FILE *fp;
+} source_file;
+
+static void
+source_file_free(mrb_state *mrb, source_file *file)
+{
+  if (file != NULL) {
+    if (file->path != NULL) {
+      mrb_free(mrb, file->path);
+    }
+    if (file->fp != NULL) {
+      fclose(file->fp);
+      file->fp = NULL;
+    }
+    mrb_free(mrb, file);
+  }
+}
+
+static char*
+build_path(mrb_state *mrb, const char *dir, const char *base)
+{
+  int len;
+  char *path = NULL;
+
+  len = strlen(base) + 1;
+
+  if (strcmp(dir, ".")) {
+    len += strlen(dir) + sizeof("/") - 1;
+  }
+
+  path = mrb_malloc(mrb, len);
+  memset(path, 0, len);
+
+  if (strcmp(dir, ".")) {
+    strcat(path, dir);
+    strcat(path, "/");
+  }
+  strcat(path, base);
+
+  return path;
+}
+
+static char*
+dirname(mrb_state *mrb, const char *path)
+{
+  size_t len;
+  char *p, *dir;
+
+  if (path == NULL) {
+    return NULL;
+  }
+
+  p = strrchr(path, '/');
+  len = p != NULL ? p - path : strlen(path);
+
+  dir = mrb_malloc(mrb, len + 1);
+  strncpy(dir, path, len);
+  dir[len] = '\0';
+
+  return dir;
+}
+
+static source_file*
+source_file_new(mrb_state *mrb, mrb_debug_context *dbg, char *filename)
+{
+  source_file *file = NULL;
+
+  file = mrb_malloc(mrb, sizeof(source_file));
+
+  memset(file, '\0', sizeof(source_file));
+  file->fp = fopen(filename, "rb");
+
+  if (file->fp == NULL) {
+    source_file_free(mrb, file);
+    return NULL;
+  }
+
+  file->lineno = 1;
+  file->path = mrb_malloc(mrb, strlen(filename) + 1);
+  strcpy(file->path, filename);
+  return file;
+}
+
+static mrb_bool
+remove_newlines(char *s, FILE *fp)
+{
+  int c;
+  char *p;
+  size_t len;
+
+  if ((len = strlen(s)) == 0) {
+    return FALSE;
+  }
+
+  p = s + len - 1;
+
+  if (*p != '\r' && *p != '\n') {
+    return FALSE;
+  }
+
+  if (*p == '\r') {
+    /* peek the next character and skip '\n' */
+    if ((c = fgetc(fp)) != '\n') {
+      ungetc(c, fp);
+    }
+  }
+
+  /* remove trailing newline characters */
+  while (s <= p && (*p == '\r' || *p == '\n')) {
+    *p-- = '\0';
+  }
+
+  return TRUE;
+}
+
+static void
+show_lines(source_file *file, uint16_t line_min, uint16_t line_max)
+{
+  char buf[LINE_BUF_SIZE];
+  int show_lineno = 1, found_newline = 0, is_printed = 0;
+
+  if (file->fp == NULL) {
+    return;
+  }
+
+  while (fgets(buf, sizeof(buf), file->fp) != NULL) {
+    found_newline = remove_newlines(buf, file->fp);
+
+    if (line_min <= file->lineno) {
+      if (show_lineno) {
+        printf("%-8d", file->lineno);
+      }
+      show_lineno = found_newline;
+      printf(found_newline ? "%s\n" : "%s", buf);
+      is_printed = 1;
+    }
+
+    if (found_newline) {
+      if (line_max < ++file->lineno) {
+        break;
+      }
+    }
+  }
+
+  if (is_printed && !found_newline) {
+    printf("\n");
+  }
+}
+
+char*
+mrb_debug_get_source(mrb_state *mrb, mrdb_state *mrdb, const char *srcpath, const char *filename)
+{
+  int i;
+  FILE *fp;
+  const char *search_path[3];
+  char *path = NULL;
+
+  search_path[0] = srcpath;
+  search_path[1] = dirname(mrb, mrb_debug_get_filename(mrdb->dbg->root_irep, 0));
+  search_path[2] = ".";
+
+  for (i = 0; i < 3; i++) {
+    if (search_path[i] == NULL) {
+      continue;
+    }
+
+    if ((path = build_path(mrb, search_path[i], filename)) == NULL) {
+      continue;
+    }
+
+    if ((fp = fopen(path, "rb")) == NULL) {
+      mrb_free(mrb, path);
+      path = NULL;
+      continue;
+    }
+    fclose(fp);
+    break;
+  }
+
+  mrb_free(mrb, (void *)search_path[1]);
+
+  return path;
+}
+
+int32_t
+mrb_debug_list(mrb_state *mrb, mrb_debug_context *dbg, char *filename, uint16_t line_min, uint16_t line_max)
+{
+  char *ext;
+  source_file *file;
+
+  if (mrb == NULL || dbg == NULL || filename == NULL) {
+    return MRB_DEBUG_INVALID_ARGUMENT;
+  }
+
+  ext = strrchr(filename, '.');
+
+  if (ext == NULL || strcmp(ext, ".rb")) {
+    printf("List command only supports .rb file.\n");
+    return MRB_DEBUG_INVALID_ARGUMENT;
+  }
+
+  if (line_min > line_max) {
+    return MRB_DEBUG_INVALID_ARGUMENT;
+  }
+
+  if ((file = source_file_new(mrb, dbg, filename)) != NULL) {
+    show_lines(file, line_min, line_max);
+    source_file_free(mrb, file);
+    return MRB_DEBUG_OK;
+  }
+  else {
+    printf("Invalid source file named %s.\n", filename);
+    return MRB_DEBUG_INVALID_ARGUMENT;
+  }
+}
diff --git a/code/train/C/0141973_tracex2_user.c b/code/train/C/0141973_tracex2_user.c
new file mode 100644
index 0000000000000000000000000000000000000000..7321a3f253c991f88e96f2a53e6ffa3e7c5f1719
--- /dev/null
+++ b/code/train/C/0141973_tracex2_user.c
@@ -0,0 +1,159 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <linux/bpf.h>
+#include <string.h>
+#include <sys/resource.h>
+
+#include "libbpf.h"
+#include "bpf_load.h"
+#include "bpf_util.h"
+
+#define MAX_INDEX	64
+#define MAX_STARS	38
+
+static void stars(char *str, long val, long max, int width)
+{
+	int i;
+
+	for (i = 0; i < (width * val / max) - 1 && i < width - 1; i++)
+		str[i] = '*';
+	if (val > max)
+		str[i - 1] = '+';
+	str[i] = '\0';
+}
+
+struct task {
+	char comm[16];
+	__u64 pid_tgid;
+	__u64 uid_gid;
+};
+
+struct hist_key {
+	struct task t;
+	__u32 index;
+};
+
+#define SIZE sizeof(struct task)
+
+static void print_hist_for_pid(int fd, void *task)
+{
+	unsigned int nr_cpus = bpf_num_possible_cpus();
+	struct hist_key key = {}, next_key;
+	long values[nr_cpus];
+	char starstr[MAX_STARS];
+	long value;
+	long data[MAX_INDEX] = {};
+	int max_ind = -1;
+	long max_value = 0;
+	int i, ind;
+
+	while (bpf_map_get_next_key(fd, &key, &next_key) == 0) {
+		if (memcmp(&next_key, task, SIZE)) {
+			key = next_key;
+			continue;
+		}
+		bpf_map_lookup_elem(fd, &next_key, values);
+		value = 0;
+		for (i = 0; i < nr_cpus; i++)
+			value += values[i];
+		ind = next_key.index;
+		data[ind] = value;
+		if (value && ind > max_ind)
+			max_ind = ind;
+		if (value > max_value)
+			max_value = value;
+		key = next_key;
+	}
+
+	printf("           syscall write() stats\n");
+	printf("     byte_size       : count     distribution\n");
+	for (i = 1; i <= max_ind + 1; i++) {
+		stars(starstr, data[i - 1], max_value, MAX_STARS);
+		printf("%8ld -> %-8ld : %-8ld |%-*s|\n",
+		       (1l << i) >> 1, (1l << i) - 1, data[i - 1],
+		       MAX_STARS, starstr);
+	}
+}
+
+static void print_hist(int fd)
+{
+	struct hist_key key = {}, next_key;
+	static struct task tasks[1024];
+	int task_cnt = 0;
+	int i;
+
+	while (bpf_map_get_next_key(fd, &key, &next_key) == 0) {
+		int found = 0;
+
+		for (i = 0; i < task_cnt; i++)
+			if (memcmp(&tasks[i], &next_key, SIZE) == 0)
+				found = 1;
+		if (!found)
+			memcpy(&tasks[task_cnt++], &next_key, SIZE);
+		key = next_key;
+	}
+
+	for (i = 0; i < task_cnt; i++) {
+		printf("\npid %d cmd %s uid %d\n",
+		       (__u32) tasks[i].pid_tgid,
+		       tasks[i].comm,
+		       (__u32) tasks[i].uid_gid);
+		print_hist_for_pid(fd, &tasks[i]);
+	}
+
+}
+
+static void int_exit(int sig)
+{
+	print_hist(map_fd[1]);
+	exit(0);
+}
+
+int main(int ac, char **argv)
+{
+	struct rlimit r = {1024*1024, RLIM_INFINITY};
+	char filename[256];
+	long key, next_key, value;
+	FILE *f;
+	int i;
+
+	snprintf(filename, sizeof(filename), "%s_kern.o", argv[0]);
+
+	if (setrlimit(RLIMIT_MEMLOCK, &r)) {
+		perror("setrlimit(RLIMIT_MEMLOCK)");
+		return 1;
+	}
+
+	signal(SIGINT, int_exit);
+	signal(SIGTERM, int_exit);
+
+	/* start 'ping' in the background to have some kfree_skb events */
+	f = popen("ping -c5 localhost", "r");
+	(void) f;
+
+	/* start 'dd' in the background to have plenty of 'write' syscalls */
+	f = popen("dd if=/dev/zero of=/dev/null count=5000000", "r");
+	(void) f;
+
+	if (load_bpf_file(filename)) {
+		printf("%s", bpf_log_buf);
+		return 1;
+	}
+
+	for (i = 0; i < 5; i++) {
+		key = 0;
+		while (bpf_map_get_next_key(map_fd[0], &key, &next_key) == 0) {
+			bpf_map_lookup_elem(map_fd[0], &next_key, &value);
+			printf("location 0x%lx count %ld\n", next_key, value);
+			key = next_key;
+		}
+		if (key)
+			printf("\n");
+		sleep(1);
+	}
+	print_hist(map_fd[1]);
+
+	return 0;
+}
diff --git a/code/train/C/0142002_redboot.c b/code/train/C/0142002_redboot.c
new file mode 100644
index 0000000000000000000000000000000000000000..dc97028383d30a27fac278ce0b1ace6ef7eb9eef
--- /dev/null
+++ b/code/train/C/0142002_redboot.c
@@ -0,0 +1,205 @@
+/*
+ * $Id: redboot.c,v 1.6 2001/10/25 09:16:06 dwmw2 Exp $
+ *
+ * Parse RedBoot-style Flash Image System (FIS) tables and
+ * produce a Linux partition array to match.
+ */
+
+#include <linux/kernel.h>
+#include <linux/slab.h>
+
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/partitions.h>
+
+struct fis_image_desc {
+    unsigned char name[16];      // Null terminated name
+    unsigned long flash_base;    // Address within FLASH of image
+    unsigned long mem_base;      // Address in memory where it executes
+    unsigned long size;          // Length of image
+    unsigned long entry_point;   // Execution entry point
+    unsigned long data_length;   // Length of actual data
+    unsigned char _pad[256-(16+7*sizeof(unsigned long))];
+    unsigned long desc_cksum;    // Checksum over image descriptor
+    unsigned long file_cksum;    // Checksum over image data
+};
+
+struct fis_list {
+	struct fis_image_desc *img;
+	struct fis_list *next;
+};
+
+static inline int redboot_checksum(struct fis_image_desc *img)
+{
+	/* RedBoot doesn't actually write the desc_cksum field yet AFAICT */
+	return 1;
+}
+
+int parse_redboot_partitions(struct mtd_info *master, struct mtd_partition **pparts, unsigned long fis_origin)
+{
+	int nrparts = 0;
+	struct fis_image_desc *buf;
+	struct mtd_partition *parts;
+	struct fis_list *fl = NULL, *tmp_fl;
+	int ret, i;
+	size_t retlen;
+	char *names;
+	int namelen = 0;
+	char *nullname;
+	int nulllen = 0;
+#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
+	static char nullstring[] = "unallocated";
+#endif
+
+	buf = kmalloc(master->erasesize, GFP_KERNEL);
+
+	if (!buf)
+		return -ENOMEM;
+
+	/* Read the start of the last erase block */
+	ret = master->read(master, master->size - master->erasesize,
+			   master->erasesize, &retlen, (void *)buf);
+
+	if (ret)
+		goto out;
+
+	if (retlen != master->erasesize) {
+		ret = -EIO;
+		goto out;
+	}
+
+	/* RedBoot image could appear in any of the first three slots */
+	for (i = 0; i < 3; i++) {
+		if (!memcmp(buf[i].name, "RedBoot", 8))
+			break;
+	}
+	if (i == 3) {
+		/* Didn't find it */
+		printk(KERN_NOTICE "No RedBoot partition table detected in %s\n",
+		       master->name);
+		ret = 0;
+		goto out;
+	}
+
+	if (fis_origin == ULONG_MAX)
+		fis_origin = buf->flash_base;
+	else if (fis_origin != buf->flash_base)
+		printk(KERN_NOTICE
+		       "RedBoot says flash is at %lx, but it's actually at %lx\n",
+		       buf->flash_base, fis_origin);
+
+	for (i = 0; i < master->erasesize / sizeof(struct fis_image_desc); i++) {
+		struct fis_list *new_fl, **prev;
+
+		if (buf[i].name[0] == 0xff)
+			break;
+		if (!redboot_checksum(&buf[i]))
+			break;
+
+		new_fl = kmalloc(sizeof(struct fis_list), GFP_KERNEL);
+		namelen += strlen(buf[i].name)+1;
+		if (!new_fl) {
+			ret = -ENOMEM;
+			goto out;
+		}
+		new_fl->img = &buf[i];
+		if (fis_origin) {
+			buf[i].flash_base -= fis_origin;
+		} else {
+			buf[i].flash_base &= master->size-1;
+		}
+
+		/* I'm sure the JFFS2 code has done me permanent damage.
+		 * I now think the following is _normal_
+		 */
+		prev = &fl;
+		while(*prev && (*prev)->img->flash_base < new_fl->img->flash_base)
+			prev = &(*prev)->next;
+		new_fl->next = *prev;
+		*prev = new_fl;
+
+		nrparts++;
+	}
+#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
+	if (fl->img->flash_base) {
+		nrparts++;
+		nulllen = sizeof(nullstring);
+	}
+
+	for (tmp_fl = fl; tmp_fl->next; tmp_fl = tmp_fl->next) {
+		if (tmp_fl->img->flash_base + tmp_fl->img->size + master->erasesize <= tmp_fl->next->img->flash_base) {
+			nrparts++;
+			nulllen = sizeof(nullstring);
+		}
+	}
+#endif
+	parts = kmalloc(sizeof(*parts)*nrparts + nulllen + namelen, GFP_KERNEL);
+
+	if (!parts) {
+		ret = -ENOMEM;
+		goto out;
+	}
+
+	memset(parts, 0, sizeof(*parts)*nrparts + nulllen + namelen);
+
+	nullname = (char *)&parts[nrparts];
+#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
+	if (nulllen > 0) {
+		strcpy(nullname, nullstring);
+	}
+#endif
+	names = nullname + nulllen;
+
+	i=0;
+
+#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
+	if (fl->img->flash_base) {
+		parts[0].name = nullname;
+		parts[0].size = fl->img->flash_base;
+		parts[0].offset = 0;
+		i++;
+	}
+#endif
+	for ( ; i<nrparts; i++) {
+		parts[i].size = fl->img->size;
+		parts[i].offset = fl->img->flash_base;
+		parts[i].name = names;
+
+		strcpy(names, fl->img->name);
+#ifdef CONFIG_MTD_REDBOOT_PARTS_READONLY
+		if (!memcmp(names, "RedBoot", 8) ||
+				!memcmp(names, "RedBoot config", 15) ||
+				!memcmp(names, "FIS directory", 14)) {
+			parts[i].mask_flags = MTD_WRITEABLE;
+		}
+#endif
+		names += strlen(names)+1;
+
+#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
+		if(fl->next && fl->img->flash_base + fl->img->size + master->erasesize <= fl->next->img->flash_base) {
+			i++;
+			parts[i].offset = parts[i-1].size + parts[i-1].offset;
+			parts[i].size = fl->next->img->flash_base - parts[i].offset;
+			parts[i].name = nullname;
+		}
+#endif
+		tmp_fl = fl;
+		fl = fl->next;
+		kfree(tmp_fl);
+	}
+	ret = nrparts;
+	*pparts = parts;
+ out:
+	while (fl) {
+		struct fis_list *old = fl;
+		fl = fl->next;
+		kfree(old);
+	}
+	kfree(buf);
+	return ret;
+}
+
+EXPORT_SYMBOL(parse_redboot_partitions);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Red Hat, Inc. - David Woodhouse <dwmw2@cambridge.redhat.com>");
+MODULE_DESCRIPTION("Parsing code for RedBoot Flash Image System (FIS) tables");
diff --git a/code/train/C/0142109_error.c b/code/train/C/0142109_error.c
new file mode 100644
index 0000000000000000000000000000000000000000..5cb7e4b24bb89e014865ccfc67d283a25d4ab4e2
--- /dev/null
+++ b/code/train/C/0142109_error.c
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2002, 2015 Jens Keiner, Stefan Kunis, Daniel Potts
+ *
+ * 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.
+ */
+
+/* $Id: util.c 3483 2010-04-23 19:02:34Z keiner $ */
+
+#include "infft.h"
+
+static R cnrm1(const C *x, const INT n)
+{
+  INT k;
+  R nrm = K(0.0);
+
+  for (k = 0; k < n; k++)
+    nrm += CABS(x[k]);
+
+  return nrm;
+}
+
+static R nrm1(const R *x, const INT n)
+{
+  INT k;
+  R nrm = K(0.0);
+
+  for (k = 0; k < n; k++)
+    nrm += FABS(x[k]);
+
+  return nrm;
+}
+
+static R cerr2(const C *x, const C *y, const INT n)
+{
+  INT k;
+  R err = K(0.0);
+
+  if (!y)
+  {
+    for (k = 0; k < n; k++)
+      err += CONJ(x[k]) * x[k];
+  }
+  else
+  {
+    for (k = 0; k < n; k++)
+      err += CONJ(x[k]-y[k]) * (x[k]-y[k]);
+  }
+
+  return SQRT(err);
+}
+
+static R err2(const R *x, const R *y, const INT n)
+{
+  INT k;
+  R err = K(0.0);
+
+  if (!y)
+  {
+    for (k = 0; k < n; k++)
+      err += x[k]*x[k];
+  }
+  else
+  {
+    for (k = 0; k < n; k++)
+      err += (x[k]-y[k]) * (x[k]-y[k]);
+  }
+
+  return SQRT(err);
+}
+
+static R cerri(const C *x, const C *y, const INT n)
+{
+  INT k;
+  R err = K(0.0), t;
+
+  if (!y)
+  {
+    for (k = 0; k < n; k++)
+    {
+      t = CABS(x[k]);
+      err = MAX(err, t);
+    }
+  }
+  else
+  {
+    for (k = 0; k < n; k++)
+    {
+      t = CABS(x[k] - y[k]);
+      err = MAX(err, t);
+    }
+  }
+
+  return err;
+}
+
+static R erri(const R *x, const R *y, const INT n)
+{
+  INT k;
+  R err = K(0.0), t;
+
+  if (!y)
+  {
+    for (k = 0; k < n; k++)
+    {
+      t = FABS(x[k]);
+      err = MAX(err, t);
+    }
+  }
+  else
+  {
+    for (k = 0; k < n; k++)
+    {
+      t = FABS(x[k] - y[k]);
+      err = MAX(err, t);
+    }
+  }
+
+  return err;
+}
+
+/** computes \f$\frac{\|x-y\|_{\infty}}{\|x\|_{\infty}} \f$
+ */
+R Y(error_l_infty_complex)(const C *x, const C *y, const INT n)
+{
+  return (cerri(x, y, n)/cerri(x, 0, n));
+}
+
+/** computes \f$\frac{\|x-y\|_{\infty}}{\|x\|_{\infty}} \f$
+ */
+R Y(error_l_infty_double)(const R *x, const R *y, const INT n)
+{
+  return (erri(x, y, n)/erri(x, 0, n));
+}
+
+/** computes \f$\frac{\|x-y\|_{\infty}}{\|z\|_1} \f$
+ */
+R Y(error_l_infty_1_complex)(const C *x, const C *y, const INT n,
+  const C *z, const INT m)
+{
+  return (cerri(x, y, n)/cnrm1(z, m));
+}
+
+/** computes \f$\frac{\|x-y\|_{\infty}}{\|z\|_1} \f$
+ */
+R Y(error_l_infty_1_double)(const R *x, const R *y, const INT n, const R *z,
+  const INT m)
+{
+  return (erri(x, y, n)/nrm1(z, m));
+}
+
+/** computes \f$\frac{\|x-y\|_2}{\|x\|_2} \f$
+ */
+R Y(error_l_2_complex)(const C *x, const C *y, const INT n)
+{
+  return (cerr2(x, y, n)/cerr2(x, 0, n));
+}
+
+/** computes \f$\frac{\|x-y\|_2}{\|x\|_2} \f$
+ */
+R Y(error_l_2_double)(const R *x, const R *y, const INT n)
+{
+  return (err2(x, y, n)/err2(x, NULL, n));
+}
diff --git a/code/train/C/0142183_acpitimer.c b/code/train/C/0142183_acpitimer.c
new file mode 100644
index 0000000000000000000000000000000000000000..fb78acf25645c2e11cd01ad98a7a8fd8d6247f49
--- /dev/null
+++ b/code/train/C/0142183_acpitimer.c
@@ -0,0 +1,117 @@
+/* $OpenBSD: acpitimer.c,v 1.11 2015/03/14 03:38:46 jsg Exp $ */
+/*
+ * Copyright (c) 2005 Thorsten Lockert <tholo@sigmasoft.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/device.h>
+#include <sys/timetc.h>
+
+#include <machine/bus.h>
+
+#include <dev/acpi/acpireg.h>
+#include <dev/acpi/acpivar.h>
+
+int acpitimermatch(struct device *, void *, void *);
+void acpitimerattach(struct device *, struct device *, void *);
+
+u_int acpi_get_timecount(struct timecounter *tc);
+
+static struct timecounter acpi_timecounter = {
+	acpi_get_timecount,	/* get_timecount */
+	0,			/* no poll_pps */
+	0x00ffffff,		/* counter_mask (24 bits) */
+	ACPI_FREQUENCY,		/* frequency */
+	0,			/* name */
+	1000			/* quality */
+};
+
+struct acpitimer_softc {
+	struct device		sc_dev;
+
+	bus_space_tag_t		sc_iot;
+	bus_space_handle_t	sc_ioh;
+};
+
+struct cfattach acpitimer_ca = {
+	sizeof(struct acpitimer_softc), acpitimermatch, acpitimerattach
+};
+
+struct cfdriver acpitimer_cd = {
+	NULL, "acpitimer", DV_DULL
+};
+
+int
+acpitimermatch(struct device *parent, void *match, void *aux)
+{
+	struct acpi_attach_args *aa = aux;
+	struct cfdata *cf = match;
+
+	/* sanity */
+	if (aa->aaa_name == NULL ||
+	    strcmp(aa->aaa_name, cf->cf_driver->cd_name) != 0 ||
+	    aa->aaa_table != NULL)
+		return (0);
+
+	return (1);
+}
+
+void
+acpitimerattach(struct device *parent, struct device *self, void *aux)
+{
+	struct acpitimer_softc *sc = (struct acpitimer_softc *) self;
+	struct acpi_softc *psc = (struct acpi_softc *) parent;
+	int rc;
+
+	if (psc->sc_fadt->hdr_revision >= 3 &&
+	    psc->sc_fadt->x_pm_tmr_blk.address != 0)
+		rc = acpi_map_address(psc, &psc->sc_fadt->x_pm_tmr_blk, 0,
+		    psc->sc_fadt->pm_tmr_len, &sc->sc_ioh, &sc->sc_iot);
+	else
+		rc = acpi_map_address(psc, NULL, psc->sc_fadt->pm_tmr_blk,
+		    psc->sc_fadt->pm_tmr_len, &sc->sc_ioh, &sc->sc_iot);
+	if (rc) {
+		printf(": can't map i/o space\n");
+		return;
+	}
+
+	printf(": %d Hz, %d bits\n", ACPI_FREQUENCY,
+	    psc->sc_fadt->flags & FADT_TMR_VAL_EXT ? 32 : 24);
+
+	if (psc->sc_fadt->flags & FADT_TMR_VAL_EXT)
+		acpi_timecounter.tc_counter_mask = 0xffffffffU;
+	acpi_timecounter.tc_priv = sc;
+	acpi_timecounter.tc_name = sc->sc_dev.dv_xname;
+	tc_init(&acpi_timecounter);
+}
+
+
+u_int
+acpi_get_timecount(struct timecounter *tc)
+{
+	struct acpitimer_softc *sc = tc->tc_priv;
+	u_int u1, u2, u3;
+
+	u2 = bus_space_read_4(sc->sc_iot, sc->sc_ioh, 0);
+	u3 = bus_space_read_4(sc->sc_iot, sc->sc_ioh, 0);
+	do {
+		u1 = u2;
+		u2 = u3;
+		u3 = bus_space_read_4(sc->sc_iot, sc->sc_ioh, 0);
+	} while (u1 > u2 || u2 > u3);
+
+	return (u2);
+}
diff --git a/code/train/C/0142235_freq_table.c b/code/train/C/0142235_freq_table.c
new file mode 100644
index 0000000000000000000000000000000000000000..a36011fc9dfe2bea629096e0f3404f473850fd1d
--- /dev/null
+++ b/code/train/C/0142235_freq_table.c
@@ -0,0 +1,245 @@
+/*
+ * linux/drivers/cpufreq/freq_table.c
+ *
+ * Copyright (C) 2002 - 2003 Dominik Brodowski
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/cpufreq.h>
+
+/*********************************************************************
+ *                     FREQUENCY TABLE HELPERS                       *
+ *********************************************************************/
+
+int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
+				    struct cpufreq_frequency_table *table)
+{
+	unsigned int min_freq = ~0;
+	unsigned int max_freq = 0;
+	unsigned int i;
+
+	for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
+		unsigned int freq = table[i].frequency;
+		if (freq == CPUFREQ_ENTRY_INVALID) {
+			pr_debug("table entry %u is invalid, skipping\n", i);
+
+			continue;
+		}
+		pr_debug("table entry %u: %u kHz, %u index\n",
+					i, freq, table[i].index);
+		if (freq < min_freq)
+			min_freq = freq;
+		if (freq > max_freq)
+			max_freq = freq;
+	}
+
+	policy->min = policy->cpuinfo.min_freq = min_freq;
+	policy->max = policy->cpuinfo.max_freq = max_freq;
+
+	if (policy->min == ~0)
+		return -EINVAL;
+	else
+		return 0;
+}
+EXPORT_SYMBOL_GPL(cpufreq_frequency_table_cpuinfo);
+
+
+int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
+				   struct cpufreq_frequency_table *table)
+{
+	unsigned int next_larger = ~0, freq, i = 0;
+	bool found = false;
+
+	pr_debug("request for verification of policy (%u - %u kHz) for cpu %u\n",
+					policy->min, policy->max, policy->cpu);
+
+	cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
+				     policy->cpuinfo.max_freq);
+
+	for (; freq = table[i].frequency, freq != CPUFREQ_TABLE_END; i++) {
+		if (freq == CPUFREQ_ENTRY_INVALID)
+			continue;
+		if ((freq >= policy->min) && (freq <= policy->max)) {
+			found = true;
+			break;
+		}
+
+		if ((next_larger > freq) && (freq > policy->max))
+			next_larger = freq;
+	}
+
+	if (!found) {
+		policy->max = next_larger;
+		cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
+				policy->cpuinfo.max_freq);
+	}
+
+	pr_debug("verification lead to (%u - %u kHz) for cpu %u\n",
+				policy->min, policy->max, policy->cpu);
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(cpufreq_frequency_table_verify);
+
+int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
+				   struct cpufreq_frequency_table *table,
+				   unsigned int target_freq,
+				   unsigned int relation,
+				   unsigned int *index)
+{
+	struct cpufreq_frequency_table optimal = {
+		.index = ~0,
+		.frequency = 0,
+	};
+	struct cpufreq_frequency_table suboptimal = {
+		.index = ~0,
+		.frequency = 0,
+	};
+	unsigned int i, diff;
+
+	pr_debug("request for target %u kHz (relation: %u) for cpu %u\n",
+					target_freq, relation, policy->cpu);
+
+	switch (relation) {
+	case CPUFREQ_RELATION_H:
+		suboptimal.frequency = ~0;
+		break;
+	case CPUFREQ_RELATION_L:
+		optimal.frequency = ~0;
+		break;
+	}
+
+	for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
+		unsigned int freq = table[i].frequency;
+		if (freq == CPUFREQ_ENTRY_INVALID)
+			continue;
+		if (freq < policy->min || freq > policy->max)
+			continue;
+		if (freq == target_freq) {
+			optimal.index = i;
+			break;
+		}
+		switch (relation) {
+		case CPUFREQ_RELATION_H:
+			if (freq < target_freq) {
+				if (freq >= optimal.frequency) {
+					optimal.frequency = freq;
+					optimal.index = i;
+				}
+			} else {
+				if (freq <= suboptimal.frequency) {
+					suboptimal.frequency = freq;
+					suboptimal.index = i;
+				}
+			}
+			break;
+		case CPUFREQ_RELATION_L:
+			if (freq > target_freq) {
+				if (freq <= optimal.frequency) {
+					optimal.frequency = freq;
+					optimal.index = i;
+				}
+			} else {
+				if (freq >= suboptimal.frequency) {
+					suboptimal.frequency = freq;
+					suboptimal.index = i;
+				}
+			}
+			break;
+		}
+	}
+	if (optimal.index > i) {
+		if (suboptimal.index > i)
+			return -EINVAL;
+		*index = suboptimal.index;
+	} else
+		*index = optimal.index;
+
+	pr_debug("target is %u (%u kHz, %u)\n", *index, table[*index].frequency,
+		table[*index].index);
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(cpufreq_frequency_table_target);
+
+static DEFINE_PER_CPU(struct cpufreq_frequency_table *, cpufreq_show_table);
+/**
+ * show_available_freqs - show available frequencies for the specified CPU
+ */
+static ssize_t show_available_freqs(struct cpufreq_policy *policy, char *buf)
+{
+	unsigned int i = 0;
+	unsigned int cpu = policy->cpu;
+	ssize_t count = 0;
+	struct cpufreq_frequency_table *table;
+
+	if (!per_cpu(cpufreq_show_table, cpu))
+		return -ENODEV;
+
+	table = per_cpu(cpufreq_show_table, cpu);
+
+	for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
+		if (table[i].frequency == CPUFREQ_ENTRY_INVALID)
+			continue;
+		count += sprintf(&buf[count], "%d ", table[i].frequency);
+	}
+	count += sprintf(&buf[count], "\n");
+
+	return count;
+
+}
+
+struct freq_attr cpufreq_freq_attr_scaling_available_freqs = {
+	.attr = { .name = "scaling_available_frequencies",
+		  .mode = 0444,
+		},
+	.show = show_available_freqs,
+};
+EXPORT_SYMBOL_GPL(cpufreq_freq_attr_scaling_available_freqs);
+
+/*
+ * if you use these, you must assure that the frequency table is valid
+ * all the time between get_attr and put_attr!
+ */
+void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table,
+				      unsigned int cpu)
+{
+	pr_debug("setting show_table for cpu %u to %p\n", cpu, table);
+	per_cpu(cpufreq_show_table, cpu) = table;
+}
+EXPORT_SYMBOL_GPL(cpufreq_frequency_table_get_attr);
+
+void cpufreq_frequency_table_put_attr(unsigned int cpu)
+{
+	pr_debug("clearing show_table for cpu %u\n", cpu);
+	per_cpu(cpufreq_show_table, cpu) = NULL;
+}
+EXPORT_SYMBOL_GPL(cpufreq_frequency_table_put_attr);
+
+void cpufreq_frequency_table_update_policy_cpu(struct cpufreq_policy *policy)
+{
+	pr_debug("Updating show_table for new_cpu %u from last_cpu %u\n",
+			policy->cpu, policy->last_cpu);
+	per_cpu(cpufreq_show_table, policy->cpu) = per_cpu(cpufreq_show_table,
+			policy->last_cpu);
+	per_cpu(cpufreq_show_table, policy->last_cpu) = NULL;
+}
+
+struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu)
+{
+	return per_cpu(cpufreq_show_table, cpu);
+}
+EXPORT_SYMBOL_GPL(cpufreq_frequency_get_table);
+
+MODULE_AUTHOR("Dominik Brodowski <linux@brodo.de>");
+MODULE_DESCRIPTION("CPUfreq frequency table helpers");
+MODULE_LICENSE("GPL");
diff --git a/code/train/C/0142320_smttimer.c b/code/train/C/0142320_smttimer.c
new file mode 100644
index 0000000000000000000000000000000000000000..74b9401e592ac28281fe8702e0f9034ba42a5a4d
--- /dev/null
+++ b/code/train/C/0142320_smttimer.c
@@ -0,0 +1,188 @@
+/******************************************************************************
+ *
+ *	(C)Copyright 1998,1999 SysKonnect,
+ *	a business unit of Schneider & Koch & Co. Datensysteme GmbH.
+ *
+ *	See the file "skfddi.c" for further information.
+ *
+ *	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.
+ *
+ *	The information in this file is provided "AS IS" without warranty.
+ *
+ ******************************************************************************/
+
+/*
+	SMT timer
+*/
+
+#include "h/types.h"
+#include "h/fddi.h"
+#include "h/smc.h"
+
+#ifndef	lint
+	static const char ID_sccs[] = "@(#)smttimer.c	2.4 97/08/04 (C) SK " ;
+#endif
+
+static void timer_done(struct s_smc *smc, int restart);
+
+void smt_timer_init(struct s_smc *smc)
+{
+	smc->t.st_queue = NULL;
+	smc->t.st_fast.tm_active = FALSE ;
+	smc->t.st_fast.tm_next = NULL;
+	hwt_init(smc) ;
+}
+
+void smt_timer_stop(struct s_smc *smc, struct smt_timer *timer)
+{
+	struct smt_timer	**prev ;
+	struct smt_timer	*tm ;
+
+	/*
+	 * remove timer from queue
+	 */
+	timer->tm_active = FALSE ;
+
+	if (smc->t.st_queue == timer && !timer->tm_next)
+	{
+		hwt_stop(smc) ;
+	}
+
+	for (prev = &smc->t.st_queue ; (tm = *prev) ; prev = &tm->tm_next )
+	{
+		if (tm == timer)
+		{
+			*prev = tm->tm_next ;
+
+			if (tm->tm_next)
+			{
+				tm->tm_next->tm_delta += tm->tm_delta ;
+			}
+
+			return ;
+		}
+	}
+}
+
+void smt_timer_start(struct s_smc *smc, struct smt_timer *timer, u_long time,
+					 u_long token)
+{
+	struct smt_timer	**prev ;
+	struct smt_timer	*tm ;
+	u_long			delta = 0 ;
+
+	time /= 16 ;		/* input is uS, clock ticks are 16uS */
+
+	if (!time)
+	{
+		time = 1 ;
+	}
+
+	smt_timer_stop(smc, timer) ;
+	timer->tm_smc = smc ;
+	timer->tm_token = token ;
+	timer->tm_active = TRUE ;
+
+	if (!smc->t.st_queue)
+	{
+		smc->t.st_queue = timer ;
+		timer->tm_next = NULL;
+		timer->tm_delta = time ;
+		hwt_start(smc, time) ;
+		return ;
+	}
+
+	/*
+	 * timer correction
+	 */
+	timer_done(smc, 0) ;
+
+	/*
+	 * find position in queue
+	 */
+	delta = 0 ;
+
+	for (prev = &smc->t.st_queue ; (tm = *prev) ; prev = &tm->tm_next )
+	{
+		if (delta + tm->tm_delta > time)
+		{
+			break ;
+		}
+
+		delta += tm->tm_delta ;
+	}
+
+	/* insert in queue */
+	*prev = timer ;
+	timer->tm_next = tm ;
+	timer->tm_delta = time - delta ;
+
+	if (tm)
+	{
+		tm->tm_delta -= timer->tm_delta ;
+	}
+
+	/*
+	 * start new with first
+	 */
+	hwt_start(smc, smc->t.st_queue->tm_delta) ;
+}
+
+void smt_force_irq(struct s_smc *smc)
+{
+	smt_timer_start(smc, &smc->t.st_fast, 32L, EV_TOKEN(EVENT_SMT, SM_FAST));
+}
+
+void smt_timer_done(struct s_smc *smc)
+{
+	timer_done(smc, 1) ;
+}
+
+static void timer_done(struct s_smc *smc, int restart)
+{
+	u_long			delta ;
+	struct smt_timer	*tm ;
+	struct smt_timer	*next ;
+	struct smt_timer	**last ;
+	int			done = 0 ;
+
+	delta = hwt_read(smc) ;
+	last = &smc->t.st_queue ;
+	tm = smc->t.st_queue ;
+
+	while (tm && !done)
+	{
+		if (delta >= tm->tm_delta)
+		{
+			tm->tm_active = FALSE ;
+			delta -= tm->tm_delta ;
+			last = &tm->tm_next ;
+			tm = tm->tm_next ;
+		}
+		else
+		{
+			tm->tm_delta -= delta ;
+			delta = 0 ;
+			done = 1 ;
+		}
+	}
+
+	*last = NULL;
+	next = smc->t.st_queue ;
+	smc->t.st_queue = tm ;
+
+	for ( tm = next ; tm ; tm = next)
+	{
+		next = tm->tm_next ;
+		timer_event(smc, tm->tm_token) ;
+	}
+
+	if (restart && smc->t.st_queue)
+	{
+		hwt_start(smc, smc->t.st_queue->tm_delta) ;
+	}
+}
+
diff --git a/code/train/C/0142496_bpf_prog_linfo.c b/code/train/C/0142496_bpf_prog_linfo.c
new file mode 100644
index 0000000000000000000000000000000000000000..5c503096ef4349ee5a4e0dbec4c357ff40b0ada6
--- /dev/null
+++ b/code/train/C/0142496_bpf_prog_linfo.c
@@ -0,0 +1,246 @@
+// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
+/* Copyright (c) 2018 Facebook */
+
+#include <string.h>
+#include <stdlib.h>
+#include <linux/err.h>
+#include <linux/bpf.h>
+#include "libbpf.h"
+#include "libbpf_internal.h"
+
+struct bpf_prog_linfo {
+	void *raw_linfo;
+	void *raw_jited_linfo;
+	__u32 *nr_jited_linfo_per_func;
+	__u32 *jited_linfo_func_idx;
+	__u32 nr_linfo;
+	__u32 nr_jited_func;
+	__u32 rec_size;
+	__u32 jited_rec_size;
+};
+
+static int dissect_jited_func(struct bpf_prog_linfo *prog_linfo,
+			      const __u64 *ksym_func, const __u32 *ksym_len)
+{
+	__u32 nr_jited_func, nr_linfo;
+	const void *raw_jited_linfo;
+	const __u64 *jited_linfo;
+	__u64 last_jited_linfo;
+	/*
+	 * Index to raw_jited_linfo:
+	 *      i: Index for searching the next ksym_func
+	 * prev_i: Index to the last found ksym_func
+	 */
+	__u32 i, prev_i;
+	__u32 f; /* Index to ksym_func */
+
+	raw_jited_linfo = prog_linfo->raw_jited_linfo;
+	jited_linfo = raw_jited_linfo;
+	if (ksym_func[0] != *jited_linfo)
+		goto errout;
+
+	prog_linfo->jited_linfo_func_idx[0] = 0;
+	nr_jited_func = prog_linfo->nr_jited_func;
+	nr_linfo = prog_linfo->nr_linfo;
+
+	for (prev_i = 0, i = 1, f = 1;
+	     i < nr_linfo && f < nr_jited_func;
+	     i++) {
+		raw_jited_linfo += prog_linfo->jited_rec_size;
+		last_jited_linfo = *jited_linfo;
+		jited_linfo = raw_jited_linfo;
+
+		if (ksym_func[f] == *jited_linfo) {
+			prog_linfo->jited_linfo_func_idx[f] = i;
+
+			/* Sanity check */
+			if (last_jited_linfo - ksym_func[f - 1] + 1 >
+			    ksym_len[f - 1])
+				goto errout;
+
+			prog_linfo->nr_jited_linfo_per_func[f - 1] =
+				i - prev_i;
+			prev_i = i;
+
+			/*
+			 * The ksym_func[f] is found in jited_linfo.
+			 * Look for the next one.
+			 */
+			f++;
+		} else if (*jited_linfo <= last_jited_linfo) {
+			/* Ensure the addr is increasing _within_ a func */
+			goto errout;
+		}
+	}
+
+	if (f != nr_jited_func)
+		goto errout;
+
+	prog_linfo->nr_jited_linfo_per_func[nr_jited_func - 1] =
+		nr_linfo - prev_i;
+
+	return 0;
+
+errout:
+	return -EINVAL;
+}
+
+void bpf_prog_linfo__free(struct bpf_prog_linfo *prog_linfo)
+{
+	if (!prog_linfo)
+		return;
+
+	free(prog_linfo->raw_linfo);
+	free(prog_linfo->raw_jited_linfo);
+	free(prog_linfo->nr_jited_linfo_per_func);
+	free(prog_linfo->jited_linfo_func_idx);
+	free(prog_linfo);
+}
+
+struct bpf_prog_linfo *bpf_prog_linfo__new(const struct bpf_prog_info *info)
+{
+	struct bpf_prog_linfo *prog_linfo;
+	__u32 nr_linfo, nr_jited_func;
+	__u64 data_sz;
+
+	nr_linfo = info->nr_line_info;
+
+	if (!nr_linfo)
+		return errno = EINVAL, NULL;
+
+	/*
+	 * The min size that bpf_prog_linfo has to access for
+	 * searching purpose.
+	 */
+	if (info->line_info_rec_size <
+	    offsetof(struct bpf_line_info, file_name_off))
+		return errno = EINVAL, NULL;
+
+	prog_linfo = calloc(1, sizeof(*prog_linfo));
+	if (!prog_linfo)
+		return errno = ENOMEM, NULL;
+
+	/* Copy xlated line_info */
+	prog_linfo->nr_linfo = nr_linfo;
+	prog_linfo->rec_size = info->line_info_rec_size;
+	data_sz = (__u64)nr_linfo * prog_linfo->rec_size;
+	prog_linfo->raw_linfo = malloc(data_sz);
+	if (!prog_linfo->raw_linfo)
+		goto err_free;
+	memcpy(prog_linfo->raw_linfo, (void *)(long)info->line_info, data_sz);
+
+	nr_jited_func = info->nr_jited_ksyms;
+	if (!nr_jited_func ||
+	    !info->jited_line_info ||
+	    info->nr_jited_line_info != nr_linfo ||
+	    info->jited_line_info_rec_size < sizeof(__u64) ||
+	    info->nr_jited_func_lens != nr_jited_func ||
+	    !info->jited_ksyms ||
+	    !info->jited_func_lens)
+		/* Not enough info to provide jited_line_info */
+		return prog_linfo;
+
+	/* Copy jited_line_info */
+	prog_linfo->nr_jited_func = nr_jited_func;
+	prog_linfo->jited_rec_size = info->jited_line_info_rec_size;
+	data_sz = (__u64)nr_linfo * prog_linfo->jited_rec_size;
+	prog_linfo->raw_jited_linfo = malloc(data_sz);
+	if (!prog_linfo->raw_jited_linfo)
+		goto err_free;
+	memcpy(prog_linfo->raw_jited_linfo,
+	       (void *)(long)info->jited_line_info, data_sz);
+
+	/* Number of jited_line_info per jited func */
+	prog_linfo->nr_jited_linfo_per_func = malloc(nr_jited_func *
+						     sizeof(__u32));
+	if (!prog_linfo->nr_jited_linfo_per_func)
+		goto err_free;
+
+	/*
+	 * For each jited func,
+	 * the start idx to the "linfo" and "jited_linfo" array,
+	 */
+	prog_linfo->jited_linfo_func_idx = malloc(nr_jited_func *
+						  sizeof(__u32));
+	if (!prog_linfo->jited_linfo_func_idx)
+		goto err_free;
+
+	if (dissect_jited_func(prog_linfo,
+			       (__u64 *)(long)info->jited_ksyms,
+			       (__u32 *)(long)info->jited_func_lens))
+		goto err_free;
+
+	return prog_linfo;
+
+err_free:
+	bpf_prog_linfo__free(prog_linfo);
+	return errno = EINVAL, NULL;
+}
+
+const struct bpf_line_info *
+bpf_prog_linfo__lfind_addr_func(const struct bpf_prog_linfo *prog_linfo,
+				__u64 addr, __u32 func_idx, __u32 nr_skip)
+{
+	__u32 jited_rec_size, rec_size, nr_linfo, start, i;
+	const void *raw_jited_linfo, *raw_linfo;
+	const __u64 *jited_linfo;
+
+	if (func_idx >= prog_linfo->nr_jited_func)
+		return errno = ENOENT, NULL;
+
+	nr_linfo = prog_linfo->nr_jited_linfo_per_func[func_idx];
+	if (nr_skip >= nr_linfo)
+		return errno = ENOENT, NULL;
+
+	start = prog_linfo->jited_linfo_func_idx[func_idx] + nr_skip;
+	jited_rec_size = prog_linfo->jited_rec_size;
+	raw_jited_linfo = prog_linfo->raw_jited_linfo +
+		(start * jited_rec_size);
+	jited_linfo = raw_jited_linfo;
+	if (addr < *jited_linfo)
+		return errno = ENOENT, NULL;
+
+	nr_linfo -= nr_skip;
+	rec_size = prog_linfo->rec_size;
+	raw_linfo = prog_linfo->raw_linfo + (start * rec_size);
+	for (i = 0; i < nr_linfo; i++) {
+		if (addr < *jited_linfo)
+			break;
+
+		raw_linfo += rec_size;
+		raw_jited_linfo += jited_rec_size;
+		jited_linfo = raw_jited_linfo;
+	}
+
+	return raw_linfo - rec_size;
+}
+
+const struct bpf_line_info *
+bpf_prog_linfo__lfind(const struct bpf_prog_linfo *prog_linfo,
+		      __u32 insn_off, __u32 nr_skip)
+{
+	const struct bpf_line_info *linfo;
+	__u32 rec_size, nr_linfo, i;
+	const void *raw_linfo;
+
+	nr_linfo = prog_linfo->nr_linfo;
+	if (nr_skip >= nr_linfo)
+		return errno = ENOENT, NULL;
+
+	rec_size = prog_linfo->rec_size;
+	raw_linfo = prog_linfo->raw_linfo + (nr_skip * rec_size);
+	linfo = raw_linfo;
+	if (insn_off < linfo->insn_off)
+		return errno = ENOENT, NULL;
+
+	nr_linfo -= nr_skip;
+	for (i = 0; i < nr_linfo; i++) {
+		if (insn_off < linfo->insn_off)
+			break;
+
+		raw_linfo += rec_size;
+		linfo = raw_linfo;
+	}
+
+	return raw_linfo - rec_size;
+}
diff --git a/code/train/C/0142607_gtcmd_rundown.c b/code/train/C/0142607_gtcmd_rundown.c
new file mode 100644
index 0000000000000000000000000000000000000000..c3a81a55646e8523196f770ed36161d36701baa5
--- /dev/null
+++ b/code/train/C/0142607_gtcmd_rundown.c
@@ -0,0 +1,123 @@
+/****************************************************************
+ *								*
+ *	Copyright 2001, 2012 Fidelity Information Services, Inc	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+
+#include "mdef.h"
+
+#include "gtm_time.h"
+
+#include "hashtab_mname.h"
+#include "cmidef.h"
+#include "cmmdef.h"
+#include "gdsroot.h"
+#include "gdsbt.h"
+#include "gtm_facility.h"
+#include "fileinfo.h"
+#include "gdsblk.h"
+#include "gdsfhead.h"
+#include "filestruct.h"
+#include "jnl.h"
+#include "change_reg.h"
+#include "gds_rundown.h"
+#include "dpgbldir.h"
+#include "wcs_timer_start.h"
+#include "gtcmd.h"
+#include "send_msg.h"
+#include "targ_alloc.h"
+
+GBLREF	cm_region_head		*reglist;
+GBLREF	gd_region		*gv_cur_region;
+GBLREF	sgmnt_addrs		*cs_addrs;
+GBLREF	sgmnt_data_ptr_t	cs_data;
+GBLREF	jnl_gbls_t		jgbl;
+
+error_def(ERR_NOTALLDBRNDWN);
+
+#ifdef VMS
+GBLREF short		gtcm_ast_avail;
+#endif
+
+void gtcmd_rundown(connection_struct *cnx, bool clean_exit)
+{
+	int4			link;
+	cm_region_list		*ptr, *last, *que_next, *que_last;
+	cm_region_head		*region;
+	uint4			jnl_status;
+	jnl_private_control	*jpc;
+	jnl_buffer_ptr_t	jbp;
+	int			refcnt;
+	boolean_t		was_crit;
+	int4			rundown_status = EXIT_NRM;			/* if gds_rundown went smoothly */
+
+	for (ptr = cnx->region_root;  ptr;)
+	{
+		region = ptr->reghead;
+		TP_CHANGE_REG(region->reg);
+		jpc = cs_addrs->jnl;
+		if (ptr->pini_addr && clean_exit && JNL_ENABLED(cs_data) && (NOJNL != jpc->channel))
+		{
+			was_crit = cs_addrs->now_crit;
+			if (!was_crit)
+				grab_crit(gv_cur_region);
+			if (JNL_ENABLED(cs_data))
+			{
+				jpc->pini_addr = ptr->pini_addr;
+				SET_GBL_JREC_TIME; /* jnl_ensure_open/jnl_put_jrt_pfin needs this to be set */
+				jbp = jpc->jnl_buff;
+				/* Before writing to jnlfile, adjust jgbl.gbl_jrec_time if needed to maintain time order
+				 * of jnl records.  This needs to be done BEFORE the jnl_ensure_open as that could write
+				 * journal records (if it decides to switch to a new journal file).
+				 */
+				ADJUST_GBL_JREC_TIME(jgbl, jbp);
+				jnl_status = jnl_ensure_open();
+				if (0 == jnl_status)
+				{
+					if (0 != jpc->pini_addr)
+						jnl_put_jrt_pfin(cs_addrs);
+				} else
+					send_msg(VARLSTCNT(6) jnl_status, 4, JNL_LEN_STR(cs_data), DB_LEN_STR(gv_cur_region));
+			}
+			if (!was_crit)
+				rel_crit(gv_cur_region);
+		}
+		refcnt = --region->refcnt;
+		/* Dont know how refcnt can become negative but in pro handle it by bypassing this region. The reason is the
+		 * following. refcnt should have originally been a positive value. Every time this function is invoked, it would
+		 * be decremented by one. There should have been one invocation that saw refcnt to be zero. That would have
+		 * done the rundown of the region or if it is still in the stack the rundown is still in progress. Therefore
+		 * it is not a good idea to try running down this region when we see refcnt to be negative (as otherwise we
+		 * will get confused and could potentially end up with SIG-11 or ACCVIO errors). The worst case is that we
+		 * would not have rundown the region in which case an externally issued MUPIP RUNDOWN would be enough.
+		 */
+		assert(0 <= refcnt);
+		if (0 == refcnt)
+		{	/* free up only as little as needed to facilitate structure reuse when the region is opened again */
+			assert(region->head.fl == region->head.bl);
+			VMS_ONLY(gtcm_ast_avail++);
+			if (JNL_ALLOWED(cs_data))
+				jpc->pini_addr = 0;
+			UNIX_ONLY(rundown_status |=) gds_rundown();
+			gd_ht_kill(region->reg_hash, TRUE);	/* TRUE to free up the table and the gv_targets it holds too */
+			FREE_CSA_DIR_TREE(cs_addrs);
+			cm_del_gdr_ptr(gv_cur_region);
+		}
+		que_next = (cm_region_list *)((unsigned char *)ptr + ptr->regque.fl);
+		que_last = (cm_region_list *)((unsigned char *)ptr + ptr->regque.bl);
+		link = (int4)((unsigned char *)que_next - (unsigned char *)que_last);
+		que_last->regque.fl = link;
+		que_next->regque.bl = -link;
+		last = ptr;
+		ptr = ptr->next;
+		free(last);
+	}
+
+	if (EXIT_NRM != rundown_status)
+		rts_error(VARLSTCNT(1) ERR_NOTALLDBRNDWN);
+}
diff --git a/code/train/C/0142667_testenc_uwb.c b/code/train/C/0142667_testenc_uwb.c
new file mode 100644
index 0000000000000000000000000000000000000000..9c144fd0c1e1a7f4f50442f84bf5e4d4ddcdfe37
--- /dev/null
+++ b/code/train/C/0142667_testenc_uwb.c
@@ -0,0 +1,133 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "speex/speex_callbacks.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef FIXED_DEBUG
+extern long long spx_mips;
+#endif
+
+#define FRAME_SIZE 640
+#include <math.h>
+int main(int argc, char **argv)
+{
+   char *inFile, *outFile, *bitsFile;
+   FILE *fin, *fout, *fbits=NULL;
+   short in_short[FRAME_SIZE];
+   short out_short[FRAME_SIZE];
+   float sigpow,errpow,snr, seg_snr=0;
+   int snr_frames = 0;
+   char cbits[200];
+   int nbBits;
+   int i;
+   void *st;
+   void *dec;
+   SpeexBits bits;
+   spx_int32_t tmp;
+   int bitCount=0;
+   spx_int32_t skip_group_delay;
+   SpeexCallback callback;
+
+   sigpow = 0;
+   errpow = 0;
+
+   st = speex_encoder_init(speex_lib_get_mode(SPEEX_MODEID_UWB));
+   dec = speex_decoder_init(speex_lib_get_mode(SPEEX_MODEID_UWB));
+
+   callback.callback_id = SPEEX_INBAND_CHAR;
+   callback.func = speex_std_char_handler;
+   callback.data = stderr;
+   speex_decoder_ctl(dec, SPEEX_SET_HANDLER, &callback);
+
+   callback.callback_id = SPEEX_INBAND_MODE_REQUEST;
+   callback.func = speex_std_mode_request_handler;
+   callback.data = st;
+   speex_decoder_ctl(dec, SPEEX_SET_HANDLER, &callback);
+
+   tmp=0;
+   speex_decoder_ctl(dec, SPEEX_SET_ENH, &tmp);
+   tmp=0;
+   speex_encoder_ctl(st, SPEEX_SET_VBR, &tmp);
+   tmp=7;
+   speex_encoder_ctl(st, SPEEX_SET_QUALITY, &tmp);
+   tmp=1;
+   speex_encoder_ctl(st, SPEEX_SET_COMPLEXITY, &tmp);
+
+   speex_encoder_ctl(st, SPEEX_GET_LOOKAHEAD, &skip_group_delay);
+   speex_decoder_ctl(dec, SPEEX_GET_LOOKAHEAD, &tmp);
+   skip_group_delay += tmp;
+
+
+   if (argc != 4 && argc != 3)
+   {
+      fprintf (stderr, "Usage: encode [in file] [out file] [bits file]\nargc = %d", argc);
+      exit(1);
+   }
+   inFile = argv[1];
+   fin = fopen(inFile, "rb");
+   outFile = argv[2];
+   fout = fopen(outFile, "wb+");
+   if (argc==4)
+   {
+      bitsFile = argv[3];
+      fbits = fopen(bitsFile, "wb");
+   }
+   speex_bits_init(&bits);
+   while (!feof(fin))
+   {
+      fread(in_short, sizeof(short), FRAME_SIZE, fin);
+      if (feof(fin))
+         break;
+      speex_bits_reset(&bits);
+
+      speex_encode_int(st, in_short, &bits);
+      nbBits = speex_bits_write(&bits, cbits, 200);
+      bitCount+=bits.nbBits;
+
+      if (argc==4)
+         fwrite(cbits, 1, nbBits, fbits);
+      speex_bits_rewind(&bits);
+
+      speex_decode_int(dec, &bits, out_short);
+      speex_bits_reset(&bits);
+
+      fwrite(&out_short[skip_group_delay], sizeof(short), FRAME_SIZE-skip_group_delay, fout);
+      skip_group_delay = 0;
+   }
+   fprintf (stderr, "Total encoded size: %d bits\n", bitCount);
+   speex_encoder_destroy(st);
+   speex_decoder_destroy(dec);
+
+   rewind(fin);
+   rewind(fout);
+
+   while ( FRAME_SIZE == fread(in_short, sizeof(short), FRAME_SIZE, fin)
+           &&
+           FRAME_SIZE ==  fread(out_short, sizeof(short), FRAME_SIZE,fout) )
+   {
+	float s=0, e=0;
+        for (i=0;i<FRAME_SIZE;++i) {
+            s += (float)in_short[i] * in_short[i];
+            e += ((float)in_short[i]-out_short[i]) * ((float)in_short[i]-out_short[i]);
+        }
+	seg_snr += 10*log10((s+1)/(e+1));
+	sigpow += s;
+	errpow += e;
+	snr_frames++;
+   }
+   fclose(fin);
+   fclose(fout);
+
+   snr = 10 * log10( sigpow / errpow );
+   seg_snr /= snr_frames;
+   fprintf(stderr,"SNR = %f\nsegmental SNR = %f\n",snr, seg_snr);
+
+#ifdef FIXED_DEBUG
+   printf ("Total: %f MIPS\n", (float)(1e-6*50*spx_mips/snr_frames));
+#endif
+
+   return 1;
+}
diff --git a/code/train/C/0142674_draw_pt_emit.c b/code/train/C/0142674_draw_pt_emit.c
new file mode 100644
index 0000000000000000000000000000000000000000..ae357b512262ccf08584a6eb7fdda863766e2553
--- /dev/null
+++ b/code/train/C/0142674_draw_pt_emit.c
@@ -0,0 +1,317 @@
+/**************************************************************************
+ *
+ * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ *
+ * 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, sub license, 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 (including the
+ * next paragraph) 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 NON-INFRINGEMENT.
+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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 "util/u_memory.h"
+#include "draw/draw_context.h"
+#include "draw/draw_private.h"
+#include "draw/draw_vbuf.h"
+#include "draw/draw_vertex.h"
+#include "draw/draw_pt.h"
+#include "translate/translate.h"
+#include "translate/translate_cache.h"
+
+struct pt_emit {
+   struct draw_context *draw;
+
+   struct translate *translate;
+
+   struct translate_cache *cache;
+   unsigned prim;
+
+   const struct vertex_info *vinfo;
+};
+
+void draw_pt_emit_prepare( struct pt_emit *emit,
+			   unsigned prim,
+                           unsigned *max_vertices )
+{
+   struct draw_context *draw = emit->draw;
+   const struct vertex_info *vinfo;
+   unsigned dst_offset;
+   struct translate_key hw_key;
+   unsigned i;
+   boolean ok;
+   
+   /* XXX: need to flush to get prim_vbuf.c to release its allocation?? 
+    */
+   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
+
+
+   /* XXX: may need to defensively reset this later on as clipping can
+    * clobber this state in the render backend.
+    */
+   emit->prim = prim;
+
+   ok = draw->render->set_primitive(draw->render, emit->prim);
+   if (!ok) {
+      assert(0);
+      return;
+   }
+
+   /* Must do this after set_primitive() above:
+    */
+   emit->vinfo = vinfo = draw->render->get_vertex_info(draw->render);
+
+
+   /* Translate from pipeline vertices to hw vertices.
+    */
+   dst_offset = 0;
+   for (i = 0; i < vinfo->num_attribs; i++) {
+      unsigned emit_sz = 0;
+      unsigned src_buffer = 0;
+      unsigned output_format;
+      unsigned src_offset = (vinfo->attrib[i].src_index * 4 * sizeof(float) );
+
+
+         
+      switch (vinfo->attrib[i].emit) {
+      case EMIT_4F:
+	 output_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
+	 emit_sz = 4 * sizeof(float);
+	 break;
+      case EMIT_3F:
+	 output_format = PIPE_FORMAT_R32G32B32_FLOAT;
+	 emit_sz = 3 * sizeof(float);
+	 break;
+      case EMIT_2F:
+	 output_format = PIPE_FORMAT_R32G32_FLOAT;
+	 emit_sz = 2 * sizeof(float);
+	 break;
+      case EMIT_1F:
+	 output_format = PIPE_FORMAT_R32_FLOAT;
+	 emit_sz = 1 * sizeof(float);
+	 break;
+      case EMIT_1F_PSIZE:
+	 output_format = PIPE_FORMAT_R32_FLOAT;
+	 emit_sz = 1 * sizeof(float);
+	 src_buffer = 1;
+	 src_offset = 0;
+	 break;
+      case EMIT_4UB:
+	 output_format = PIPE_FORMAT_A8R8G8B8_UNORM;
+	 emit_sz = 4 * sizeof(ubyte);
+         break;
+      default:
+	 assert(0);
+	 output_format = PIPE_FORMAT_NONE;
+	 emit_sz = 0;
+	 break;
+      }
+
+      hw_key.element[i].type = TRANSLATE_ELEMENT_NORMAL;
+      hw_key.element[i].input_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
+      hw_key.element[i].input_buffer = src_buffer;
+      hw_key.element[i].input_offset = src_offset;
+      hw_key.element[i].instance_divisor = 0;
+      hw_key.element[i].output_format = output_format;
+      hw_key.element[i].output_offset = dst_offset;
+
+      dst_offset += emit_sz;
+   }
+
+   hw_key.nr_elements = vinfo->num_attribs;
+   hw_key.output_stride = vinfo->size * 4;
+
+   if (!emit->translate ||
+       translate_key_compare(&emit->translate->key, &hw_key) != 0)
+   {
+      translate_key_sanitize(&hw_key);
+      emit->translate = translate_cache_find(emit->cache, &hw_key);
+   }
+
+   *max_vertices = (draw->render->max_vertex_buffer_bytes / 
+                    (vinfo->size * 4));
+
+   /* even number */
+   *max_vertices = *max_vertices & ~1;
+}
+
+
+void draw_pt_emit( struct pt_emit *emit,
+		   const float (*vertex_data)[4],
+		   unsigned vertex_count,
+		   unsigned stride,
+		   const ushort *elts,
+		   unsigned count )
+{
+   struct draw_context *draw = emit->draw;
+   struct translate *translate = emit->translate;
+   struct vbuf_render *render = draw->render;
+   void *hw_verts;
+
+   /* XXX: need to flush to get prim_vbuf.c to release its allocation?? 
+    */
+   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
+
+   if (vertex_count == 0)
+      return;
+
+   if (vertex_count >= UNDEFINED_VERTEX_ID) {
+      assert(0);
+      return;
+   }
+
+   /* XXX: and work out some way to coordinate the render primitive
+    * between vbuf.c and here...
+    */
+   if (!draw->render->set_primitive(draw->render, emit->prim)) {
+      assert(0);
+      return;
+   }
+
+   render->allocate_vertices(render,
+                             (ushort)translate->key.output_stride,
+                             (ushort)vertex_count);
+
+   hw_verts = render->map_vertices( render );
+   if (!hw_verts) {
+      assert(0);
+      return;
+   }
+
+   translate->set_buffer(translate, 
+			 0, 
+			 vertex_data,
+			 stride );
+
+   translate->set_buffer(translate, 
+			 1, 
+			 &draw->rasterizer->point_size,
+			 0);
+
+   translate->run( translate,
+		   0, 
+		   vertex_count,
+                   draw->instance_id,
+		   hw_verts );
+
+   render->unmap_vertices( render, 
+                           0, 
+                           vertex_count - 1 );
+
+   render->draw(render,
+		elts,
+		count);
+
+   render->release_vertices(render);
+}
+
+
+void draw_pt_emit_linear(struct pt_emit *emit,
+                         const float (*vertex_data)[4],
+                         unsigned stride,
+                         unsigned count)
+{
+   struct draw_context *draw = emit->draw;
+   struct translate *translate = emit->translate;
+   struct vbuf_render *render = draw->render;
+   void *hw_verts;
+
+#if 0
+   debug_printf("Linear emit\n");
+#endif
+   /* XXX: need to flush to get prim_vbuf.c to release its allocation?? 
+    */
+   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
+
+   if (count >= UNDEFINED_VERTEX_ID)
+      goto fail;
+
+   /* XXX: and work out some way to coordinate the render primitive
+    * between vbuf.c and here...
+    */
+   if (!draw->render->set_primitive(draw->render, emit->prim)) 
+      goto fail;
+
+   if (!render->allocate_vertices(render,
+                                  (ushort)translate->key.output_stride,
+                                  (ushort)count))
+      goto fail;
+
+   hw_verts = render->map_vertices( render );
+   if (!hw_verts)
+      goto fail;
+
+   translate->set_buffer(translate, 0,
+			 vertex_data, stride);
+
+   translate->set_buffer(translate, 1,
+			 &draw->rasterizer->point_size,
+			 0);
+
+   translate->run(translate,
+                  0,
+                  count,
+                  draw->instance_id,
+                  hw_verts);
+
+   if (0) {
+      unsigned i;
+      for (i = 0; i < count; i++) {
+         debug_printf("\n\n%s vertex %d:\n", __FUNCTION__, i);
+         draw_dump_emitted_vertex( emit->vinfo, 
+                                   (const uint8_t *)hw_verts + 
+                                   translate->key.output_stride * i );
+      }
+   }
+
+   render->unmap_vertices( render, 0, count - 1 );
+
+   render->draw_arrays(render, 0, count);
+
+   render->release_vertices(render);
+
+   return;
+
+fail:
+   assert(0);
+   return;
+}
+
+struct pt_emit *draw_pt_emit_create( struct draw_context *draw )
+{
+   struct pt_emit *emit = CALLOC_STRUCT(pt_emit);
+   if (!emit)
+      return NULL;
+
+   emit->draw = draw;
+   emit->cache = translate_cache_create();
+   if (!emit->cache) {
+      FREE(emit);
+      return NULL;
+   }
+
+   return emit;
+}
+
+void draw_pt_emit_destroy( struct pt_emit *emit )
+{
+   if (emit->cache)
+      translate_cache_destroy(emit->cache);
+
+   FREE(emit);
+}
diff --git a/code/train/C/0142869_xapp_region.c b/code/train/C/0142869_xapp_region.c
new file mode 100644
index 0000000000000000000000000000000000000000..dc4d50acab46b9a42b35e85266e714406e1b9bd7
--- /dev/null
+++ b/code/train/C/0142869_xapp_region.c
@@ -0,0 +1,163 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <errno.h>
+#include <time.h>
+#include <string.h>
+#include <mpi.h>
+
+void doflop(int n,double *x);
+
+
+int main(int argc, char **argv) {
+
+  int    	size,rank, left, right, you, ndata=127,ndata_max=127,seed;
+  int           rv, nsec=0, ireg, nreg=255;
+  long long int i,j,k;
+  unsigned long long int  nflop=0,nmem=1,nsleep=0,nrep=1;
+  char 		*env_ptr;
+  double 	*sbuf, *rbuf,*x;
+  MPI_Status    *s;
+  MPI_Request   *r;
+  time_t	ts;
+  char		reg_name[21], pcmd[80];
+
+
+  while(--argc && argv++) {
+   if(!strcmp("-r",*argv)) {
+    --argc; argv++;
+    nreg = atol(*argv);
+   }
+ }
+ 
+  MPI_Init(&argc,&argv);
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+ 
+ for(ireg = 0; ireg < nreg ; ireg++) {
+
+  nrep = ireg;
+  sprintf(pcmd,"enter_region(abcdefghijklmnop%4.4d)", ireg);
+  MPI_Pcontrol(0,pcmd);
+
+ if(nsec > 0) {
+  sleep(nsec);
+ }
+
+ if(nflop) {
+  x = (double *)malloc((size_t)(10*sizeof(double)));
+  j = k = 0;
+  for(i=0;i<10;i++) {
+   x[i] = 1.0;
+  }
+
+  for(i=0;i<nflop;i++) {
+   x[j] = x[j]*x[k];
+   j = ((i%9)?(j+1):(0));
+   k = ((i%8)?(k+1):(0));
+  }
+  free((char *)x);
+ }
+
+ if(nsleep) {
+  sleep(nsleep);
+ }
+ 
+ if(nmem<nflop) nmem=nflop;
+ 
+ if(nflop>1) printf("FLOPS = %lld BYTES = %lld\n", nflop, nmem);
+ 
+ fflush(stdout);
+ 
+  s = (MPI_Status *)malloc((size_t)(sizeof(MPI_Status)*2*size));
+  r = (MPI_Request *)malloc((size_t)(sizeof(MPI_Request)*2*size));
+
+
+  sbuf = (double *)malloc((size_t)(ndata_max*sizeof(double)));
+  rbuf = (double *)malloc((size_t)(ndata_max*sizeof(double)));
+  for(i=0;i<ndata_max;i++) { sbuf[i] = rbuf[i] = i; }
+
+  MPI_Bcast(&seed,1,MPI_INT,0,MPI_COMM_WORLD);
+  srand48(seed);
+
+  for(i=0;i<nrep;i++) {
+   MPI_Bcast(sbuf,ndata_max,MPI_DOUBLE,0,MPI_COMM_WORLD);
+  }
+
+  if(size>1) {
+  if(!rank) {left=size-1;} else { left = rank-1;}
+  if(rank == size-1) { right=0;} else {right=rank+1;}
+  you =  (rank < size/2)?(rank+size/2):(rank-size/2);
+  } else  {
+   you = left = right = rank;
+  }
+ 
+
+
+  for(i=0;i<nrep;i++) {
+   ndata = (long int)(drand48()*ndata_max)+1;
+   MPI_Sendrecv(sbuf,ndata,MPI_DOUBLE,right,1,rbuf,ndata,MPI_DOUBLE,left,1,MPI_COMM_WORLD,s);
+   MPI_Sendrecv(sbuf,ndata,MPI_DOUBLE,left,1,rbuf,ndata,MPI_DOUBLE,right,1,MPI_COMM_WORLD,s);
+  MPI_Barrier(MPI_COMM_WORLD);
+  MPI_Sendrecv(sbuf,ndata,MPI_DOUBLE,left,1,rbuf,ndata,MPI_DOUBLE,right,1,MPI_COMM_WORLD,s);
+  MPI_Reduce(sbuf,rbuf,ndata,MPI_DOUBLE, MPI_SUM, 0,  MPI_COMM_WORLD);
+
+  MPI_Isend(sbuf,ndata,MPI_DOUBLE,you,0,MPI_COMM_WORLD, r);
+  MPI_Recv(rbuf,ndata,MPI_DOUBLE,MPI_ANY_SOURCE,0,MPI_COMM_WORLD, s);
+  MPI_Wait(r,s);
+
+  MPI_Irecv(rbuf,ndata,MPI_DOUBLE,MPI_ANY_SOURCE,0,MPI_COMM_WORLD,r);
+  MPI_Send(sbuf,ndata,MPI_DOUBLE,you,0,MPI_COMM_WORLD);
+  MPI_Wait(r,s);
+
+  
+  for(j=0;j<size;j++) {
+   MPI_Isend(sbuf+j%ndata_max,1,MPI_DOUBLE,j,4,MPI_COMM_WORLD, r+j);
+   MPI_Irecv(rbuf+j%ndata_max,1,MPI_DOUBLE,j,4,MPI_COMM_WORLD,r+size+j);
+  }
+  MPI_Waitall(2*size,r,s);
+/*
+  for(j=0;j<size;j++) {
+   printf("rep %d stat %d %d %d\n",i, j, s[j].MPI_SOURCE, s[j+size].MPI_SOURCE);
+  }
+*/
+
+  MPI_Allreduce(sbuf,rbuf,ndata,MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
+  MPI_Reduce(sbuf,rbuf,ndata,MPI_DOUBLE, MPI_SUM, 0,  MPI_COMM_WORLD);
+  MPI_Reduce(sbuf,rbuf,ndata-1,MPI_DOUBLE, MPI_SUM, 0,  MPI_COMM_WORLD);
+ }
+
+
+
+  MPI_Barrier(MPI_COMM_WORLD);
+
+  MPI_Pcontrol(0,"get_region()",reg_name);
+  printf("%d in  region = %s\n", rank,reg_name);
+  sprintf(pcmd,"exit_region(abcdefghijklmnop%4.4d)", ireg);
+  MPI_Pcontrol(0,pcmd);
+ }
+
+
+  MPI_Finalize();
+  return 0;   
+}
+
+
+void doflop(int n, double *x) {
+ int i;
+ double y=0.1;
+ 
+ y = 1.0/n;
+ 
+ for(i=0;i<n;i++) {
+  x[i] += y*x[i];
+ }
+ printf("%.3e \n", *x);
+ 
+}
+ 
+
diff --git a/code/train/C/0143060_skkdic.c b/code/train/C/0143060_skkdic.c
new file mode 100644
index 0000000000000000000000000000000000000000..f00a38408ba6b5736b525dedf3a08c497f49ecd6
--- /dev/null
+++ b/code/train/C/0143060_skkdic.c
@@ -0,0 +1,261 @@
+/** ext/skkdic.c --- rskkserv module for skkdic.
+
+ * Copyright (C) 2001-2005 YAMASHITA Junji
+
+ * Author:	YAMASHITA Junji <ysjj@unixuser.org>
+ * Version:	0.11
+
+ * This file is part of rskkserv.
+
+ * 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, 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.
+**/
+
+#define USE_MMAP 0
+#define PROFILING 0
+
+#if USE_MMAP
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#else
+#include <stdio.h>
+#endif /* USE_MMAP */
+
+#if PROFILING
+#include <sys/time.h>
+#include <unistd.h>
+#endif /* PROFILING */
+
+#include <assert.h>
+#include <string.h>
+#include <ruby.h>
+
+#if USE_MMAP
+typedef char *JISYO;
+#else
+typedef FILE *JISYO;
+#endif
+
+struct skkdic_data {
+  struct skkdic_tbl {
+    int *ptr;
+    int len;
+  } a_tbl, n_tbl;
+  int bufsize;
+  JISYO jisyo;
+#if USE_MMAP
+  JISYO pos;
+  off_t len;
+  int fd;
+#endif
+};
+
+#if USE_MMAP
+#define skkdic_open(d,p) \
+  do {\
+    struct stat jisyo_stat;\
+    (d)->fd = open(p, O_RDONLY);\
+    fstat((d)->fd, &jisyo_stat);\
+    (d)->len = jisyo_stat.st_size;\
+    (d)->jisyo = (JISYO)mmap(0, (d)->len, PROT_READ, MAP_PRIVATE, (d)->fd, 0);\
+  } while (0)
+
+#define skkdic_close(d) \
+  do {munmap((d)->jisyo, (d)->len); close((d)->fd);} while (0)
+
+#define skkdic_seek(d,p) (d)->pos = (d)->jisyo + (p)
+#define skkdic_getc(d) *((d)->pos++)
+
+static inline int
+skkdic_cmp(struct skkdic_data *skkdic, char *kana, int len)
+{
+  int result = strncmp(skkdic->pos, kana, len);
+  skkdic->pos += len;
+  return result;
+}
+
+#else /* ! USE_MMAP */
+#define skkdic_open(d,p) (d)->jisyo = fopen(p, "r")
+#define skkdic_close(d) fclose((d)->jisyo)
+#define skkdic_seek(d,p) fseek((d)->jisyo, p, SEEK_SET)
+#define skkdic_getc(d) fgetc((d)->jisyo)
+
+static inline int
+skkdic_cmp(struct skkdic_data *skkdic, char *kana, int len)
+{
+  unsigned char *p = (unsigned char*)kana;
+  int c = EOF, n = 0, i = 0;
+  while (len > i && (c=skkdic_getc(skkdic)) != EOF && (n=c-p[i++]) == 0)
+    /* void */;
+  if (c == EOF)
+    return -1;
+  return n;
+}
+#endif /* USE_MMAP */
+
+static VALUE cSKKDic;
+
+static VALUE fskkdic_s_data(VALUE, VALUE, VALUE, VALUE);
+static VALUE fskkdic_s_search(VALUE, VALUE, VALUE);
+
+#if PROFILING
+static FILE *profile;
+#endif
+
+void Init_skkdic()
+{
+#if PROFILING
+  profile = fopen("skkdic-mon.out", "w");
+#endif
+
+  rb_require("skkserv/skkdic.rb");
+
+  cSKKDic = rb_define_class("SKKDic", rb_cObject);
+
+  rb_define_singleton_method(cSKKDic, "data", fskkdic_s_data, 3);
+  rb_define_singleton_method(cSKKDic, "search", fskkdic_s_search, 2);
+}
+
+#define FALSE 0
+#define TRUE  1
+
+static void fskkdic_data_free(struct skkdic_data *data)
+{
+  free(data->a_tbl.ptr);
+  free(data->n_tbl.ptr);
+  skkdic_close(data);
+}
+
+static VALUE
+fskkdic_s_data(VALUE self, VALUE path, VALUE a_tbl, VALUE n_tbl)
+{
+  struct skkdic_data *data;
+  VALUE retval;
+
+  retval = Data_Make_Struct(rb_cData, struct skkdic_data, 0,
+			    fskkdic_data_free, data);
+
+  data->a_tbl.len = RSTRING_LEN(a_tbl) / sizeof(int);
+  data->a_tbl.ptr = ALLOC_N(int, data->a_tbl.len);
+  memcpy(data->a_tbl.ptr, RSTRING_PTR(a_tbl), RSTRING_LEN(a_tbl));
+
+  data->n_tbl.len = RSTRING_LEN(n_tbl) / sizeof(int);
+  data->n_tbl.ptr = ALLOC_N(int, data->n_tbl.len);
+  memcpy(data->n_tbl.ptr, RSTRING_PTR(n_tbl), RSTRING_LEN(n_tbl));
+  skkdic_open(data, StringValuePtr(path));
+  data->bufsize = 16;
+
+  return retval;
+}
+
+static int
+is_okuri_ari(const char *kana, int len)
+{
+  const char c = kana[len-2];
+
+  return (kana[0] & 0x80) && (c >= 'a' && c <= 'z');
+}
+
+static VALUE
+fskkdic_s_search(VALUE self, VALUE vkana, VALUE vdata)
+{
+  char *kana = StringValuePtr(vkana);
+  int kana_len = strlen(kana);
+  int pos, left, right;
+  int found;
+
+  struct skkdic_data *skkdic;
+  struct skkdic_tbl tbl;
+  VALUE retval = rb_ary_new();
+
+#if PROFILING
+  struct timeval start_time, found_time, end_time;
+  int loop_count = 0;
+  gettimeofday(&start_time, NULL);
+#endif
+
+  Data_Get_Struct(vdata, struct skkdic_data, skkdic);
+
+  tbl = is_okuri_ari(kana, kana_len) ? skkdic->a_tbl : skkdic->n_tbl;
+
+  found = FALSE;
+  left = 0;
+  right = tbl.len - 1;
+
+  while (left <= right) {
+    int cmp;
+#if PROFILING
+    loop_count++;
+#endif
+
+    pos = (left + right) / 2;
+
+    skkdic_seek(skkdic, tbl.ptr[pos]);
+    cmp = skkdic_cmp(skkdic, kana, kana_len);
+    if (cmp == 0) {
+      found = TRUE;
+      break;
+    } else if (cmp > 0) {
+      right = pos - 1;
+    } else /* if (cmp < 0) */ {
+      left = pos + 1;
+    }
+  }
+
+#if PROFILING
+  gettimeofday(&found_time, NULL);
+#endif
+
+  if (found) {
+    int c = skkdic_getc(skkdic);
+
+    assert(c == '/');
+    for (c = skkdic_getc(skkdic); c != EOF && c != '\n'; c = skkdic_getc(skkdic)) {
+      char *p = ALLOCA_N(char, skkdic->bufsize);
+      int i = 0;
+      p[i++] = c;
+      while ((c=skkdic_getc(skkdic)) != '/') {
+	if (i >= skkdic->bufsize) {
+	  skkdic->bufsize *= 2;
+	  p = memcpy(ALLOCA_N(char, skkdic->bufsize), p, i);
+	}
+	p[i++] = c;
+      }
+      rb_ary_push(retval, rb_str_new(p, i));
+    }
+  }
+
+#if PROFILING
+  {
+    long search_usec, push_usec;
+
+    gettimeofday(&end_time, NULL);
+
+    search_usec = found_time.tv_usec - start_time.tv_usec;
+    push_usec = end_time.tv_usec - found_time.tv_usec;
+    if (search_usec < 0)
+      search_usec += 1000 * 1000 * 1000;
+    if (push_usec < 0)
+      push_usec += 1000 * 1000 * 1000;
+
+    fprintf(profile, "found: %3s, search usec (loop): %6d (%2d), ",
+	    found ? "YES" : "NO", search_usec, loop_count);
+    fprintf(profile, "build result: %3d\n", push_usec);
+    fflush(profile);
+  }
+#endif
+
+  return retval;
+}
+
+/** ext/skkdic.c ends here **/
diff --git a/code/train/C/0143222_read.c b/code/train/C/0143222_read.c
new file mode 100644
index 0000000000000000000000000000000000000000..06aa1085bfac9cdec0af826f227f0434623971da
--- /dev/null
+++ b/code/train/C/0143222_read.c
@@ -0,0 +1,207 @@
+/*
+ * Copyright (C) 2006 by Latchesar Ionkov <lucho@ionkov.net>
+ *
+ * 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 (including the next
+ * paragraph) 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
+ * PRECISION INSIGHT AND/OR ITS SUPPLIERS 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 <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include "npfs.h"
+#include "npclient.h"
+#include "npcimpl.h"
+
+typedef struct Npcrcall Npcrcall;
+typedef struct Npcread Npcread;
+
+struct Npcrcall {
+	Npcread*	r;
+	char*		ename;
+	u32		ecode;
+	u32		count;
+};
+	
+struct Npcread
+{
+	pthread_mutex_t	lock;
+	int		err;
+	u32		iounit;
+	int		nreq;
+	int		nresp;
+	Npcrcall*	calls;
+	void		(*cb)(void *, u32);
+	void*		cba;
+};
+
+int
+npc_read(Npcfid *fid, u8 *buf, u32 count, u64 offset)
+{
+	u32 l;
+	Npfcall *tc, *rc;
+
+	if (count > (fid->fsys->msize - IOHDRSZ))
+		count = fid->fsys->msize - IOHDRSZ;
+
+	tc = np_create_tread(fid->fid, offset, count);
+	if (npc_rpc(fid->fsys, tc, &rc) < 0) {
+		free(tc);
+		return -1;
+	}
+
+	l = rc->count;
+	if (l > count)
+		l = count;
+	memmove(buf, rc->data, l);
+	free(rc);
+	free(tc);
+	return (int)l;
+}
+
+int
+npc_readn(Npcfid *fid, u8 *buf, u32 count, u64 offset)
+{
+	u32 n;
+	int l;
+
+	n = 0;
+	while (n < count) {
+		l = npc_read(fid, buf + n, count - n, offset + n);
+		if (l < 0)
+			return -1;
+		if (!l)
+			break;
+		n += l;
+	}
+	return (int)n;
+}
+
+static void 
+npc_read_cb(Npcreq *req, void *cba)
+{
+	int i, nocount, count;
+	Npcrcall *rc;
+	Npcread *r;
+
+	rc = cba;
+	r = rc->r;
+
+	rc->ename = req->ename;
+	rc->ecode = req->ecode;
+	if (req->rc)
+		rc->count = req->rc->count;
+	free(req->rc);
+
+	pthread_mutex_lock(&r->lock);
+	r->nresp++;
+	free(req->tc);
+
+	/* if there are more read requests, return */
+	if (r->nreq-r->nresp > 0) {
+		pthread_mutex_unlock(&r->lock);
+		return;
+	}
+
+	/* if there was an error while sending the requests, don't call the callback */
+	if (r->err) 
+		goto done;
+
+	nocount = 0;
+	count = 0;
+	for(i = 0; i < r->nreq; i++) {
+		if (r->calls[i].ename) {
+			np_werror(r->calls[i].ename, r->calls[i].ecode);
+			(*r->cb)(r->cba, -1);
+			goto done;
+		}
+
+		if (nocount) {
+			if (r->calls[i].count != 0) {
+				np_werror("invalid read", EIO);
+				(*r->cb)(r->cba, -1);
+				goto done;
+			}
+		} else {
+			count += r->calls[i].count;
+			if (r->calls[i].count < r->iounit)
+				nocount = 1;
+		}
+	}
+
+	(*r->cb)(r->cba, count);
+
+done:
+	for(i = 0; i < r->nreq; i++)
+		if (r->calls[i].ename)
+			free(r->calls[i].ename);
+
+	pthread_mutex_unlock(&r->lock);
+	pthread_mutex_destroy(&r->lock);
+	free(r);
+}
+
+int
+npc_readnb(Npcfid *fid, u8 *buf, u32 count, u64 offset, 
+	void (*cb)(void *cba, u32 count), void *cba)
+{
+	int i, n, nreq, iounit;
+	Npcread *r;
+	Npfcall *tc;
+
+	iounit = fid->iounit;
+	nreq = count/iounit + (count%iounit?1:0);
+	r = malloc(sizeof(*r) + nreq*sizeof(Npcrcall));
+	if (!r) {
+		np_werror(Ennomem, ENOMEM);
+		return -1;
+	}
+
+	pthread_mutex_init(&r->lock, NULL);
+	r->nreq = nreq;
+	r->nresp = 0;
+	r->iounit = iounit;
+	r->err = 0;
+	r->calls = (Npcrcall *) ((char *)r + sizeof(*r));
+	r->cb = cb;
+	r->cba = cba;
+
+	for(i = 0; i < nreq; i++) {
+		r->calls[i].r = r;
+		r->calls[i].ename = NULL;
+		r->calls[i].ecode = 0;
+		r->calls[i].count = 0;
+	}
+
+	for(i = 0; i < nreq; i++) {
+		n = iounit;
+		if ((i+1)*iounit > count)
+			n = count - i*iounit;
+
+		tc = np_create_tread(fid->fid, offset + i*iounit, n);
+		if (npc_rpcnb(fid->fsys, tc, npc_read_cb, &r->calls[i]) < 0) {
+			pthread_mutex_lock(&r->lock);
+			r->nreq = i;
+			r->err = 1;
+			pthread_mutex_lock(&r->lock);
+			return -1;
+		}
+	}
+
+	return 0;
+}
diff --git a/code/train/C/0143514_audriv_a.c b/code/train/C/0143514_audriv_a.c
new file mode 100644
index 0000000000000000000000000000000000000000..722e29f75a66b69bc4ef9e8a9c145c91381cedb8
--- /dev/null
+++ b/code/train/C/0143514_audriv_a.c
@@ -0,0 +1,262 @@
+/*
+    TiMidity++ -- MIDI to WAVE converter and player
+    Copyright (C) 1999-2002 Masanao Izumo <mo@goice.co.jp>
+    Copyright (C) 1995 Tuukka Toivonen <tt@cgs.fi>
+
+    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
+
+    audriv_audio.c
+
+    Functions to play sound on audriv_*.
+    Written by Masanao Izumo <mo@goice.co.jp>
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif /* HAVE_CONFIG_H */
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif /* HAVE_UNISTD_H */
+#include <fcntl.h>
+#include <stdio.h>
+#ifdef HAVE_SYS_IOCTL_H
+#include <sys/ioctl.h>
+#endif /* HAVE_SYS_IOCTL_H */
+#ifndef NO_STRING_H
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+
+#include "timidity.h"
+#include "common.h"
+#include "output.h"
+#include "controls.h"
+#include "aenc.h"
+#include "audriv.h"
+#include "instrum.h"
+#include "playmidi.h"
+#include "miditrace.h"
+
+static int open_output(void); /* 0=success, 1=warning, -1=fatal error */
+static void close_output(void);
+static int output_data(char *buf, int32 nbytes);
+static int acntl(int request, void *arg);
+
+/* export the playback mode */
+
+#define dpm audriv_play_mode
+PlayMode dpm = {
+  DEFAULT_RATE, PE_16BIT|PE_SIGNED, PF_PCM_STREAM|PF_CAN_TRACE,
+  -1,
+  {0,0,0,0,0}, /* no extra parameters so far */
+
+#if defined(AU_DEC)
+  "DEC audio device",
+#elif defined(sgi)
+  "SGI audio device",
+#elif defined(AU_NONE)
+  "Psedo audio device (No audio)",
+#else
+  "Audriv audio device",
+#endif
+
+  'd', "",
+  open_output,
+  close_output,
+  output_data,
+  acntl
+};
+
+/********** Audio_Init **********************
+  This just does some generic initialization.  The actual audio
+  output device open is done in the Audio_On routine so that we
+  can get a device which matches the requested sample rate & format
+ *****/
+
+static int Audio_Init(void)
+{
+    static int init_flag = False;
+
+    if(init_flag)
+	return 0;
+    if(!audriv_setup_audio())
+    {
+	ctl->cmsg(CMSG_FATAL, VERB_NORMAL, "%s", audriv_errmsg);
+	return -1;
+    }
+    audriv_set_noblock_write(0);
+    init_flag = True;
+    return 0;
+}
+
+static int audio_init_open(void)
+{
+    int ch, enc;
+
+    if(audriv_set_play_sample_rate(dpm.rate) == False)
+    {
+	ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
+		  "Sample rate %d is not supported", dpm.rate);
+	return -1;
+    }
+
+    if(dpm.encoding & PE_MONO)/* Mono samples */
+	ch = 1;
+    else
+	ch = 2;
+
+    if(audriv_set_play_channels(ch) == False)
+    {
+	ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
+		  "Channel %d is not supported", ch);
+	return -1;
+    }
+
+    if(dpm.encoding & PE_ULAW)
+    {
+	enc = AENC_G711_ULAW;
+	dpm.encoding &= ~PE_16BIT;
+    }
+    else if(dpm.encoding & PE_ALAW)
+    {
+	enc = AENC_G711_ALAW;
+	dpm.encoding &= ~PE_16BIT;
+    }
+    else if(dpm.encoding & PE_16BIT)
+    {
+#if defined(LITTLE_ENDIAN)
+	if(dpm.encoding & PE_BYTESWAP)
+	    if(dpm.encoding & PE_SIGNED)
+		enc = AENC_SIGWORDB;
+	    else
+		enc = AENC_UNSIGWORDL;
+	else
+	    if(dpm.encoding & PE_SIGNED)
+		enc = AENC_SIGWORDL;
+	    else
+		enc = AENC_UNSIGWORDL;
+#else /* BIG_ENDIAN */
+	if(dpm.encoding & PE_BYTESWAP)
+	    if(dpm.encoding & PE_SIGNED)
+		enc = AENC_SIGWORDL;
+	    else
+		enc = AENC_UNSIGWORDB;
+	else
+	    if(dpm.encoding & PE_SIGNED)
+		enc = AENC_SIGWORDB;
+	    else
+		enc = AENC_UNSIGWORDB;
+#endif
+    }
+    else
+    {
+	/* 8 bit */
+	if(dpm.encoding & PE_SIGNED)
+	    enc = AENC_SIGBYTE;
+	else
+	    enc = AENC_UNSIGBYTE;
+    }
+
+    if(audriv_set_play_encoding(enc) == False)
+    {
+	ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
+		  "Output format is not supported: %s", AENC_NAME(enc));
+	return -1;
+    }
+
+    return 0;
+}
+
+/********** Audio_On **********************
+ * Turn On Audio Stream.
+ *
+ *****/
+int Audio_On(void)
+{
+    static int init_flag = 0;
+
+    if(!init_flag)
+    {
+	int i;
+
+	i = audio_init_open();
+	if(i)
+	    return i;
+	init_flag = 1;
+    }
+
+    if(!audriv_play_open())
+    {
+	ctl->cmsg(CMSG_FATAL, VERB_NORMAL, "%s", audriv_errmsg);
+	ctl->close();
+	exit(1);
+    }
+
+    return 0;
+}
+
+/* Open the audio device */
+static int open_output(void)
+{
+    int i;
+    if((i = Audio_Init()) != 0)
+	return i;
+    if((i = Audio_On()) != 0)
+	return i;
+    dpm.fd = 0;
+    return 0;
+}
+
+/* Output of audio data from timidity */
+static int output_data(char *buf, int32 nbytes)
+{
+    int n;
+
+    while(nbytes > 0)
+    {
+	if((n = audriv_write(buf, nbytes)) == -1)
+	    return -1;
+	buf += n;
+	nbytes -= n;
+    }
+    return 0;
+}
+
+/* close output device */
+static void close_output(void)
+{
+    if(dpm.fd != -1)
+    {
+	audriv_play_close();
+	dpm.fd = -1;
+    }
+}
+
+static int acntl(int request, void *arg)
+{
+    switch(request)
+    {
+      case PM_REQ_DISCARD:
+	audriv_play_stop(); /* Reset audriv's sample counter */
+	Audio_On();
+	return 0;
+
+      case PM_REQ_PLAY_START: /* Called just before playing */
+      case PM_REQ_PLAY_END: /* Called just after playing */
+        return 0;
+    }
+    return -1;
+}
diff --git a/code/train/C/0143552_k_nonneg_solve.c b/code/train/C/0143552_k_nonneg_solve.c
new file mode 100644
index 0000000000000000000000000000000000000000..82268f432a6bfdbbb4cc1e31c024ccfc7914f864
--- /dev/null
+++ b/code/train/C/0143552_k_nonneg_solve.c
@@ -0,0 +1,136 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <kcorrect.h>
+
+/*
+ * k_nonneg_solve.c
+ *
+ * solve a nonnegative chi^2 problem using the multiplication update 
+ * technique
+ *  From some starting point, iterates to convergence a
+ *  box-constrained QP problem: 
+ *
+ *     F(v) = (1/2) v^T.A.v + b^T.v for v_i >= 0 for all i.
+ *
+ *  Uses the method of Sha, Saul, & Lee (2002), "Multiplicative
+ *  updates for nonnegative quadratic programming in support vector
+ *  machines" (UPenn Tech Report MS-CIS-02-19). Look on google.
+ *
+ *  It requires the user to supply a matrix A (called invcovar in the
+ *  code), which gets turned into A+ and A- where:
+ *  
+ *     A+_ij = A_ij for A_ij>0.
+ *             0.   otherwise
+ *
+ *     A-_ij = |A_ij|  for A_ij<0.
+ *             0.      otherwise
+ *
+ * Inputs are:
+ *   invcovar  --> "A" (square matrix)
+ *   bb        --> "b"
+ *   offset    --> offset term to convert F(v) to a reasonable chi^2
+ *   nn        --> number params in "b"
+ *   tolerance --> convergence criterion in chi^2
+ *   maxiter   --> maximum number of iters
+ *   verbose   --> make noise?
+ * Output are:
+ *   xx        --> best fit "v"
+ *   niter     --> number of iters
+ *   chi2      --> chi^2 of output
+ *
+ * Mike Blanton
+ * 5/2003 */
+ 
+#define FREEVEC(a) {if((a)!=NULL) free((char *) (a)); (a)=NULL;}
+
+static float *invcovar_pos=NULL;
+static float *invcovar_neg=NULL;
+
+/* update at each iteration step */
+IDL_LONG k_nonneg_update(float *xx,
+												 float *invcovar,
+												 float *bb,
+												 IDL_LONG nn)
+{
+	IDL_LONG i,j;
+
+	for(i=0;i<nn;i++) {
+		invcovar_pos[i]=0.;
+		invcovar_neg[i]=0.;
+		for(j=0;j<nn;j++) 
+			if(invcovar[i*nn+j]>0.) 
+				invcovar_pos[i]+=invcovar[i*nn+j]*xx[j];
+			else 
+				invcovar_neg[i]-=invcovar[i*nn+j]*xx[j];
+	} /* end for i */
+
+	for(i=0;i<nn;i++) 
+		if(xx[i]>0.) 
+			xx[i]*=(-bb[i]+sqrt(bb[i]*bb[i]+4.*invcovar_pos[i]*invcovar_neg[i]))/ 
+				(2.*invcovar_pos[i]);
+
+	return(1);
+} /* end k_nonneg_update */
+
+/* calculate chi^2 */ 
+float k_nonneg_chi2(float *xx,
+										 float *invcovar,
+										 float *bb,
+										 float offset,
+										 IDL_LONG nn)
+{
+	IDL_LONG i,j;
+	float chi2;
+
+	chi2=0.;
+	for(i=0;i<nn;i++) 
+		for(j=0;j<nn;j++) 
+			chi2+=invcovar[i*nn+j]*xx[i]*xx[j];
+	for(i=0;i<nn;i++) 
+		chi2+=2.*xx[i]*bb[i];
+	chi2+=2.*offset;
+
+	return(chi2);
+} /* end k_nonneg_update */
+
+/* perform the iteration */
+IDL_LONG k_nonneg_solve(float *xx,
+												float *invcovar,
+												float *bb,
+												float offset,
+												IDL_LONG nn,
+												float tolerance, 
+												IDL_LONG maxiter,
+												IDL_LONG *niter,
+												float *chi2,
+												IDL_LONG verbose)
+{
+	float diff,oldval,newval;
+	IDL_LONG skip=1000;
+
+	invcovar_pos=(float *) malloc(nn*nn*sizeof(float));
+	invcovar_neg=(float *) malloc(nn*nn*sizeof(float));
+	diff=tolerance*2.;
+	newval=k_nonneg_chi2(xx,invcovar,bb,offset,nn);
+	oldval=newval+diff;
+	(*niter)=0;
+	while((*niter)<maxiter && diff>tolerance) {
+		k_nonneg_update(xx,invcovar,bb,nn);
+		if((*niter)%skip == 0 && verbose) {
+			newval=k_nonneg_chi2(xx,invcovar,bb,offset,nn);
+			printf("niter=%d ; chi2=%e\n",*niter,newval);
+			diff=oldval-newval;
+			oldval=newval;
+		} /* end if */
+		(*niter)++;
+	} /* end while*/
+	newval=k_nonneg_chi2(xx,invcovar,bb,offset,nn);
+	if(verbose) printf("niter=%d ; chi2=%e\n",*niter,newval);
+	(*chi2)=newval;
+	FREEVEC(invcovar_pos);
+	FREEVEC(invcovar_neg);
+
+	return(1);
+} /* end k_nonneg_solve */
diff --git a/code/train/C/0143746_process.c b/code/train/C/0143746_process.c
new file mode 100644
index 0000000000000000000000000000000000000000..b7075bcdca6c35b73405b1abaf3056aed1d0f13e
--- /dev/null
+++ b/code/train/C/0143746_process.c
@@ -0,0 +1,243 @@
+/*
+ * drivers/power/process.c - Functions for starting/stopping processes on 
+ *                           suspend transitions.
+ *
+ * Originally from swsusp.
+ */
+
+
+#undef DEBUG
+
+#include <linux/interrupt.h>
+#include <linux/oom.h>
+#include <linux/suspend.h>
+#include <linux/module.h>
+#include <linux/syscalls.h>
+#include <linux/freezer.h>
+#include <linux/delay.h>
+#include <linux/workqueue.h>
+#include <linux/kmod.h>
+#include <linux/wakelock.h>
+#include "power.h"
+
+/* 
+ * Timeout for stopping processes
+ */
+#define TIMEOUT	(20 * HZ)
+
+static int try_to_freeze_tasks(bool user_only)
+{
+	struct task_struct *g, *p;
+	unsigned long end_time;
+	unsigned int todo;
+	bool wq_busy = false;
+	struct timeval start, end;
+	u64 elapsed_csecs64;
+	unsigned int elapsed_csecs;
+	bool wakeup = false;
+	int sleep_usecs = USEC_PER_MSEC;
+
+	do_gettimeofday(&start);
+
+	end_time = jiffies + TIMEOUT;
+
+	if (!user_only)
+		freeze_workqueues_begin();
+
+	while (true) {
+		todo = 0;
+		read_lock(&tasklist_lock);
+		do_each_thread(g, p) {
+			if (p == current || !freeze_task(p))
+				continue;
+
+			/*
+			 * Now that we've done set_freeze_flag, don't
+			 * perturb a task in TASK_STOPPED or TASK_TRACED.
+			 * It is "frozen enough".  If the task does wake
+			 * up, it will immediately call try_to_freeze.
+			 *
+			 * Because freeze_task() goes through p's scheduler lock, it's
+			 * guaranteed that TASK_STOPPED/TRACED -> TASK_RUNNING
+			 * transition can't race with task state testing here.
+			 */
+			if (!task_is_stopped_or_traced(p) &&
+			    !freezer_should_skip(p))
+				todo++;
+		} while_each_thread(g, p);
+		read_unlock(&tasklist_lock);
+
+		if (!user_only) {
+			wq_busy = freeze_workqueues_busy();
+			todo += wq_busy;
+		}
+
+		if (!todo || time_after(jiffies, end_time))
+			break;
+
+		if (pm_wakeup_pending()) {
+			wakeup = true;
+			break;
+		}
+
+		/*
+		 * We need to retry, but first give the freezing tasks some
+		 * time to enter the refrigerator.  Start with an initial
+		 * 1 ms sleep followed by exponential backoff until 8 ms.
+		 */
+		usleep_range(sleep_usecs / 2, sleep_usecs);
+		if (sleep_usecs < 8 * USEC_PER_MSEC)
+			sleep_usecs *= 2;
+	}
+
+	do_gettimeofday(&end);
+	elapsed_csecs64 = timeval_to_ns(&end) - timeval_to_ns(&start);
+	do_div(elapsed_csecs64, NSEC_PER_SEC / 100);
+	elapsed_csecs = elapsed_csecs64;
+
+	if (todo) {
+		/* This does not unfreeze processes that are already frozen
+		 * (we have slightly ugly calling convention in that respect,
+		 * and caller must call thaw_processes() if something fails),
+		 * but it cleans up leftover PF_FREEZE requests.
+		 */
+		if(wakeup) {
+			printk("\n");
+			printk(KERN_ERR "Freezing of %s aborted\n",
+					user_only ? "user space " : "tasks ");
+#ifdef CONFIG_VENDOR_EDIT
+//Shu.Liu@OnlineRd.Driver, 2014/02/24, modified for sleep debug
+			print_active_wakeup_sources();
+#endif /* CONFIG_VENDOR_EDIT */
+		}
+		else {
+			printk("\n");
+			printk(KERN_ERR "Freezing of tasks %s after %d.%02d seconds "
+			       "(%d tasks refusing to freeze, wq_busy=%d):\n",
+			       wakeup ? "aborted" : "failed",
+			       elapsed_csecs / 100, elapsed_csecs % 100,
+			       todo - wq_busy, wq_busy);
+		}
+
+		if (!wakeup) {
+			read_lock(&tasklist_lock);
+			do_each_thread(g, p) {
+				if (p != current && !freezer_should_skip(p)
+				    && freezing(p) && !frozen(p) &&
+				    elapsed_csecs > 100)
+					sched_show_task(p);
+			} while_each_thread(g, p);
+			read_unlock(&tasklist_lock);
+		}
+	} else {
+		printk("(elapsed %d.%02d seconds) ", elapsed_csecs / 100,
+			elapsed_csecs % 100);
+	}
+
+	return todo ? -EBUSY : 0;
+}
+
+/**
+ * freeze_processes - Signal user space processes to enter the refrigerator.
+ *
+ * On success, returns 0.  On failure, -errno and system is fully thawed.
+ */
+int freeze_processes(void)
+{
+	int error;
+
+	error = __usermodehelper_disable(UMH_FREEZING);
+	if (error)
+		return error;
+
+	if (!pm_freezing)
+		atomic_inc(&system_freezing_cnt);
+
+	printk("Freezing user space processes ... ");
+	pm_freezing = true;
+	error = try_to_freeze_tasks(true);
+	if (!error) {
+		printk("done.");
+		__usermodehelper_set_disable_depth(UMH_DISABLED);
+		oom_killer_disable();
+	}
+	printk("\n");
+	BUG_ON(in_atomic());
+
+	if (error)
+		thaw_processes();
+	return error;
+}
+
+/**
+ * freeze_kernel_threads - Make freezable kernel threads go to the refrigerator.
+ *
+ * On success, returns 0.  On failure, -errno and only the kernel threads are
+ * thawed, so as to give a chance to the caller to do additional cleanups
+ * (if any) before thawing the userspace tasks. So, it is the responsibility
+ * of the caller to thaw the userspace tasks, when the time is right.
+ */
+int freeze_kernel_threads(void)
+{
+	int error;
+
+	printk("Freezing remaining freezable tasks ... ");
+	pm_nosig_freezing = true;
+	error = try_to_freeze_tasks(false);
+	if (!error)
+		printk("done.");
+
+	printk("\n");
+	BUG_ON(in_atomic());
+
+	if (error)
+		thaw_kernel_threads();
+	return error;
+}
+
+void thaw_processes(void)
+{
+	struct task_struct *g, *p;
+
+	if (pm_freezing)
+		atomic_dec(&system_freezing_cnt);
+	pm_freezing = false;
+	pm_nosig_freezing = false;
+
+	oom_killer_enable();
+
+	printk("Restarting tasks ... ");
+
+	thaw_workqueues();
+
+	read_lock(&tasklist_lock);
+	do_each_thread(g, p) {
+		__thaw_task(p);
+	} while_each_thread(g, p);
+	read_unlock(&tasklist_lock);
+
+	usermodehelper_enable();
+
+	schedule();
+	printk("done.\n");
+}
+
+void thaw_kernel_threads(void)
+{
+	struct task_struct *g, *p;
+
+	pm_nosig_freezing = false;
+	printk("Restarting kernel threads ... ");
+
+	thaw_workqueues();
+
+	read_lock(&tasklist_lock);
+	do_each_thread(g, p) {
+		if (p->flags & (PF_KTHREAD | PF_WQ_WORKER))
+			__thaw_task(p);
+	} while_each_thread(g, p);
+	read_unlock(&tasklist_lock);
+
+	schedule();
+	printk("done.\n");
+}
diff --git a/code/train/C/0143827_main.c b/code/train/C/0143827_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..be9ef4f741837ea59a2b49244ec8610fcfe33cea
--- /dev/null
+++ b/code/train/C/0143827_main.c
@@ -0,0 +1,106 @@
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define DEBUG       0
+#define MAX_LEN     500001
+
+char s[MAX_LEN * 2];
+int radius[MAX_LEN * 4 + 4];
+
+void manacher(char *str, int * out) {
+    // # - pre process
+    char * tmp = (char *)malloc(2 * strlen(str) + 2);
+
+    memset(tmp, 0, 2 * strlen(str) + 2);
+
+    size_t j = 0;
+    for (size_t i = 0; i < strlen(str); i++) {
+        tmp[j++] = '#';
+        tmp[j++] = str[i];
+    }
+    tmp[j] = '#';
+
+    int max_right = 0, pos = 0;
+    int len_tmp = strlen(tmp);
+
+    for (int i = 0; i < len_tmp; i++) {
+        if (i < max_right) {
+            out[i] = out[2 * pos - i] > (max_right - i) ? (max_right - i) : out[2 * pos - i];
+        }
+        else {
+            out[i] = 1;
+        }
+
+        while (i - out[i] >= 0 && i + out[i] < len_tmp && tmp[i - out[i]] == tmp[i + out[i]]) {
+            out[i] ++;
+        }
+
+        if (i + out[i] - 1 > max_right) {
+            max_right = i + out[i] - 1;
+            pos = i;
+        }
+    }
+
+	free(tmp);
+}
+
+int main() {
+    int n;
+
+#if DEBUG
+    FILE * fp = fopen("input.txt", "r");
+    FILE * fp_out = fopen("output.txt", "w");
+    fscanf(fp, "%d", &n);
+    fscanf(fp, "%s", s);
+#else
+    scanf("%d", &n);
+    scanf("%s", s);
+#endif
+
+    // copy
+    for (size_t i = 0; i < n; i++) {
+        s[i + n] = s[i];
+    }
+
+    manacher(s, radius);
+
+    for (size_t start = 1; start < 2 * n; start += 2) {
+        int max = 0;
+
+        for (size_t j = start; j < start + 2 * n; j ++) {
+            int r = radius[j];
+            int left = j + 1 - radius[j];
+            int right = j - 1 + radius[j];
+
+            if (left < (start - 1)) {
+                r = j - (start - 1) + 1;
+            }
+
+            if (right >= start + 2 * n) {
+                if (r > (start + 2 * n - j)) {
+                    r = start + 2 * n - j;
+                }
+            }
+
+            if ((r - 1) > max) {
+                max = r - 1;
+            }
+        }
+
+#if DEBUG
+        fprintf(fp_out, "%d\n", max);
+#else
+        printf("%d\n", max);
+#endif
+    }
+
+#if DEBUG
+    fclose(fp);
+    fclose(fp_out);
+#endif
+
+    return 0;
+}
diff --git a/code/train/C/0143834_master.c b/code/train/C/0143834_master.c
new file mode 100644
index 0000000000000000000000000000000000000000..911a97ede98137532031eb2a1aadc38b8f892fed
--- /dev/null
+++ b/code/train/C/0143834_master.c
@@ -0,0 +1,82 @@
+/*
+* Copyright (c) 2015, Severin Kacianka (severin at kacianka dot at)
+* All rights reserved.
+* 
+* Licensed under the BSD 2-Clause License
+* See license.txt or http://opensource.org/licenses/BSD-2-Clause
+*
+* This work was done at the Alpen-Adria-University Klagenfurt (http://www.aau.at)
+*/
+
+#include "common.h"
+static uint8_t tx_buffer[TR_BUFF_SIZE];
+static uint8_t rx_buffer[TR_BUFF_SIZE];
+
+int main()
+{
+	uint32_t rx_sum = 0;
+	uint32_t tx_crc = 0;
+	uint32_t tx_crc_old = 0;
+	uint32_t a = 364;
+	uint32_t b = 53457;
+	uint32_t c = 976;
+	uint32_t d = 66;
+
+
+	init();
+	// initialize buffers with some known value
+	memset(tx_buffer,0x33,sizeof(tx_buffer));
+	memset(rx_buffer,0x44,sizeof(rx_buffer));
+
+	// wait for keystroke: this gives the user time to start the slave
+    Report("Start the slave and press any key to transmit data....\n\r");
+    MAP_UARTCharGet(UARTA0_BASE);
+	
+	// configure SPI channel
+	MAP_SPIReset(GSPI_BASE);
+    MAP_SPIConfigSetExpClk(GSPI_BASE,MAP_PRCMPeripheralClockGet(PRCM_GSPI),
+                     SPI_IF_BIT_RATE,SPI_MODE_MASTER,SPI_SUB_MODE_0,
+                     (SPI_SW_CTRL_CS |
+                     SPI_4PIN_MODE |
+                     SPI_TURBO_OFF |
+                     SPI_CS_ACTIVEHIGH |
+                     SPI_WL_8));	
+	MAP_SPIEnable(GSPI_BASE);
+	
+	tx_crc = fill_buffer(tx_buffer,TR_BUFF_SIZE,"TX");
+
+	while(1)
+	{
+		tx_crc_old = tx_crc;
+		change_seed(a++,b++,c++,d++);
+		tx_crc = fill_buffer(tx_buffer,TR_BUFF_SIZE,"TX");
+		Message("Sending...");
+
+		SPICSEnable(GSPI_BASE);
+		for(int i = 0; i < TR_BUFF_SIZE; i++)
+		{
+			SPIDataPut(GSPI_BASE,tx_buffer[i]);
+			SPIDataGet(GSPI_BASE,&rx_buffer[i]);
+		}
+		Message("Transfer complete!\n\r");
+		SPICSDisable(GSPI_BASE);
+		// we could also use SPITransfer instead:
+		// MAP_SPITransfer(GSPI_BASE,tx_buffer,rx_buffer, TR_BUFF_SIZE,
+		//		SPI_CS_ENABLE|SPI_CS_DISABLE);
+
+		rx_sum = 0;
+		for(int i = 0; i < TR_BUFF_SIZE; i++)
+		{
+			rx_sum += rx_buffer[i];
+		}
+		Report("\n\rChecksum in the RX buffer was: 0x%02x, we send 0x%02x\n\r\n\r",crc(rx_buffer),tx_crc_old);
+		Message("TX-");
+		print_buffer(tx_buffer,TR_BUFF_SIZE);
+		Message("RX-");
+		print_buffer(rx_buffer,TR_BUFF_SIZE);		
+		Report("Press any key to transmit again\n\r");
+		MAP_UARTCharGet(UARTA0_BASE);
+	}
+	return 0;
+}
+
diff --git a/code/train/C/0143894_main.c b/code/train/C/0143894_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..68e14606716a951f55e2726c7055db7213d47b15
--- /dev/null
+++ b/code/train/C/0143894_main.c
@@ -0,0 +1,140 @@
+/*
+	Adrenaline
+	Copyright (C) 2016-2018, TheFloW
+
+	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 <common.h>
+#include <vshctrl.h>
+
+#include "main.h"
+#include "menu.h"
+
+PSP_MODULE_INFO("VshCtrlSatelite", 0, 1, 0);
+
+char *cpuspeeds[] = { "Default", "20/10", "75/37", "100/50", "133/66", "222/111", "266/133", "300/150", "333/166" };
+char *umdmodes[] = { "Inferno", "M33 Driver", "Sony NP9660" };
+
+AdrenalineConfig config;
+
+void SuspendDevice();
+void RecoveryMenu();
+void RestartVSH();
+
+Entry entries[] = {
+	{ "CPU CLOCK XMB", NULL, cpuspeeds, sizeof(cpuspeeds), &config.vshcpuspeed, 0 },
+	{ "CPU CLOCK GAME", NULL, cpuspeeds, sizeof(cpuspeeds), &config.umdisocpuspeed, 0 },
+	{ "UMD ISO MODE", NULL, umdmodes, sizeof(umdmodes), &config.umdmode, 0 },
+	{ "SUSPEND DEVICE", SuspendDevice, NULL, 0, NULL, 1 },
+	{ "RECOVERY MENU", RecoveryMenu, NULL, 0, NULL, 1 },
+	{ "RESTART VSH", RestartVSH, NULL, 0, NULL, 1 },
+	{ "EXIT", NULL, NULL, 0, NULL, 1 },
+};
+
+int exit_mode = -1;
+
+u32 cur_buttons = -1, button_on = 0;
+
+SceUID vshmenu_thid;
+
+int ctrl_handler(SceCtrlData *pad_data, int count) {
+	button_on = pad_data->Buttons & ~cur_buttons;
+	cur_buttons = pad_data->Buttons;
+
+	int i;
+	for (i = 0; i < count; i++) {
+		pad_data[i].Buttons &= ~ALL_CTRL;
+	}
+
+	return 0;
+}
+
+void RecoveryMenu() {
+	sctrlSESetBootConfFileIndex(BOOT_RECOVERY);
+	sctrlKernelExitVSH(NULL);
+}
+
+void SuspendDevice() {
+	scePowerRequestSuspend();
+}
+
+void RestartVSH() {
+	sctrlKernelExitVSH(NULL);
+}
+
+int VshMenu_Thread() {
+	sceKernelChangeThreadPriority(0, 8);
+	sctrlSEGetConfig(&config);
+	vctrlVSHRegisterVshMenu(ctrl_handler);
+
+	int exit_sel = 0, menu_mode = 0;
+
+	MenuReset(entries, sizeof(entries));
+
+	while (exit_mode < 0) {
+		sceDisplayWaitVblankStart();
+
+		if (menu_mode > 0) {
+			MenuDisplay();
+		}
+
+		switch(menu_mode) {
+			case 0:
+				if (!(cur_buttons & ALL_CTRL)) {
+					menu_mode++;
+				}
+				break;
+
+			case 1:
+				exit_sel = MenuCtrl();
+				if (exit_sel >= 0) {
+					menu_mode++;
+				}
+				break;
+
+			case 2:
+				if (!(cur_buttons & ALL_CTRL)) {
+					exit_mode = exit_sel;
+				}
+				break;
+		}
+	}
+
+	sctrlSESetConfig(&config);
+
+	MenuExitFunction(exit_mode);
+
+	vctrlVSHExitVSHMenu(&config);
+
+	return sceKernelExitDeleteThread(0);
+}
+
+int module_start() {
+	vshmenu_thid = sceKernelCreateThread("VshMenu_Thread", VshMenu_Thread, 0x10, 0x1000, 0, NULL);
+	if (vshmenu_thid >= 0)
+		sceKernelStartThread(vshmenu_thid, 0, NULL);
+
+	return 0;
+}
+
+int module_stop() {
+	exit_mode = 0;
+
+	SceUInt timeout = 100000;
+	if (sceKernelWaitThreadEnd(vshmenu_thid, &timeout) < 0)
+		sceKernelTerminateDeleteThread(vshmenu_thid);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/code/train/C/0143929_process.c b/code/train/C/0143929_process.c
new file mode 100644
index 0000000000000000000000000000000000000000..e04f0f1397522d52b32062fd1aa5e655f98ae730
--- /dev/null
+++ b/code/train/C/0143929_process.c
@@ -0,0 +1,249 @@
+/*
+ * drivers/power/process.c - Functions for starting/stopping processes on 
+ *                           suspend transitions.
+ *
+ * Originally from swsusp.
+ */
+
+
+#undef DEBUG
+
+#include <linux/interrupt.h>
+#include <linux/oom.h>
+#include <linux/suspend.h>
+#include <linux/module.h>
+#include <linux/syscalls.h>
+#include <linux/freezer.h>
+#include <linux/delay.h>
+#include <linux/workqueue.h>
+#include <linux/kmod.h>
+#include <linux/wakelock.h>
+#include "power.h"
+
+/* 
+ * Timeout for stopping processes
+ */
+#define TIMEOUT	(20 * HZ)
+
+static int try_to_freeze_tasks(bool user_only)
+{
+	struct task_struct *g, *p;
+	unsigned long end_time;
+	unsigned int todo;
+	bool wq_busy = false;
+	struct timeval start, end;
+	u64 elapsed_msecs64;
+	unsigned int elapsed_msecs;
+	bool wakeup = false;
+	int sleep_usecs = USEC_PER_MSEC;
+
+	do_gettimeofday(&start);
+
+	end_time = jiffies + TIMEOUT;
+
+	if (!user_only)
+		freeze_workqueues_begin();
+
+	while (true) {
+		todo = 0;
+		read_lock(&tasklist_lock);
+		do_each_thread(g, p) {
+			if (p == current || !freeze_task(p))
+				continue;
+
+			/*
+			 * Now that we've done set_freeze_flag, don't
+			 * perturb a task in TASK_STOPPED or TASK_TRACED.
+			 * It is "frozen enough".  If the task does wake
+			 * up, it will immediately call try_to_freeze.
+			 *
+			 * Because freeze_task() goes through p's scheduler lock, it's
+			 * guaranteed that TASK_STOPPED/TRACED -> TASK_RUNNING
+			 * transition can't race with task state testing here.
+			 */
+			if (!task_is_stopped_or_traced(p) &&
+			    !freezer_should_skip(p))
+				todo++;
+		} while_each_thread(g, p);
+		read_unlock(&tasklist_lock);
+
+		if (!user_only) {
+			wq_busy = freeze_workqueues_busy();
+			todo += wq_busy;
+		}
+
+		if (todo && has_wake_lock(WAKE_LOCK_SUSPEND)) {
+			wakeup = 1;
+			break;
+		}
+		if (!todo || time_after(jiffies, end_time))
+			break;
+
+		if (pm_wakeup_pending()) {
+			wakeup = true;
+			break;
+		}
+
+		/*
+		 * We need to retry, but first give the freezing tasks some
+		 * time to enter the regrigerator.
+		 */
+		usleep_range(sleep_usecs / 2, sleep_usecs);
+		if (sleep_usecs < 8 * USEC_PER_MSEC)
+			sleep_usecs *= 2;
+	}
+
+	do_gettimeofday(&end);
+	elapsed_msecs64 = timeval_to_ns(&end) - timeval_to_ns(&start);
+	do_div(elapsed_msecs64, NSEC_PER_MSEC);
+	elapsed_msecs = elapsed_msecs64;
+
+	if (todo) {
+		/* This does not unfreeze processes that are already frozen
+		 * (we have slightly ugly calling convention in that respect,
+		 * and caller must call thaw_processes() if something fails),
+		 * but it cleans up leftover PF_FREEZE requests.
+		 */
+		if(wakeup) {
+			printk("\n");
+			printk(KERN_ERR "Freezing of %s aborted\n",
+					user_only ? "user space " : "tasks ");
+		}
+		else {
+			printk("\n");
+		printk(KERN_ERR "Freezing of tasks %s after %d.%03d seconds "
+			       "(%d tasks refusing to freeze, wq_busy=%d):\n",
+			       wakeup ? "aborted" : "failed",
+			       elapsed_msecs / 1000, elapsed_msecs % 1000,
+			       todo - wq_busy, wq_busy);
+		}
+/* OPPO 2013-06-07 huanggd Delete begin for too many printk info lead to system hungup */
+#if 0
+		if (!wakeup) {
+			read_lock(&tasklist_lock);
+			do_each_thread(g, p) {
+				if (p != current && !freezer_should_skip(p)
+				    && freezing(p) && !frozen(p) &&
+				    elapsed_msecs > 1000)
+					sched_show_task(p);
+			} while_each_thread(g, p);
+			read_unlock(&tasklist_lock);
+		}
+#endif	
+/* OPPO 2013-06-07 huanggd Delete end */
+	} else {
+		printk("(elapsed %d.%03d seconds) ", elapsed_msecs / 1000,
+			elapsed_msecs % 1000);
+	}
+
+	return todo ? -EBUSY : 0;
+}
+
+/**
+ * freeze_processes - Signal user space processes to enter the refrigerator.
+ *
+ * On success, returns 0.  On failure, -errno and system is fully thawed.
+ */
+int freeze_processes(void)
+{
+	int error;
+
+	error = __usermodehelper_disable(UMH_FREEZING);
+	if (error)
+		return error;
+
+	if (!pm_freezing)
+		atomic_inc(&system_freezing_cnt);
+
+	printk("Freezing user space processes ... ");
+	pm_freezing = true;
+	error = try_to_freeze_tasks(true);
+	if (!error) {
+		printk("done.");
+		__usermodehelper_set_disable_depth(UMH_DISABLED);
+		oom_killer_disable();
+	}
+	printk("\n");
+	BUG_ON(in_atomic());
+
+	if (error)
+		thaw_processes();
+	return error;
+}
+
+/**
+ * freeze_kernel_threads - Make freezable kernel threads go to the refrigerator.
+ *
+ * On success, returns 0.  On failure, -errno and only the kernel threads are
+ * thawed, so as to give a chance to the caller to do additional cleanups
+ * (if any) before thawing the userspace tasks. So, it is the responsibility
+ * of the caller to thaw the userspace tasks, when the time is right.
+ */
+int freeze_kernel_threads(void)
+{
+	int error;
+
+	error = suspend_sys_sync_wait();
+	if (error)
+		return error;
+
+	printk("Freezing remaining freezable tasks ... ");
+	pm_nosig_freezing = true;
+	error = try_to_freeze_tasks(false);
+	if (!error)
+		printk("done.");
+
+	printk("\n");
+	BUG_ON(in_atomic());
+
+	if (error)
+		thaw_kernel_threads();
+	return error;
+}
+
+void thaw_processes(void)
+{
+	struct task_struct *g, *p;
+
+	if (pm_freezing)
+		atomic_dec(&system_freezing_cnt);
+	pm_freezing = false;
+	pm_nosig_freezing = false;
+
+	oom_killer_enable();
+
+	printk("Restarting tasks ... ");
+
+	thaw_workqueues();
+
+	read_lock(&tasklist_lock);
+	do_each_thread(g, p) {
+		__thaw_task(p);
+	} while_each_thread(g, p);
+	read_unlock(&tasklist_lock);
+
+	usermodehelper_enable();
+
+	schedule();
+	printk("done.\n");
+}
+
+void thaw_kernel_threads(void)
+{
+	struct task_struct *g, *p;
+
+	pm_nosig_freezing = false;
+	printk("Restarting kernel threads ... ");
+
+	thaw_workqueues();
+
+	read_lock(&tasklist_lock);
+	do_each_thread(g, p) {
+		if (p->flags & (PF_KTHREAD | PF_WQ_WORKER))
+			__thaw_task(p);
+	} while_each_thread(g, p);
+	read_unlock(&tasklist_lock);
+
+	schedule();
+	printk("done.\n");
+}
diff --git a/code/train/C/0144106_sf_snort_plugin_rc4.c b/code/train/C/0144106_sf_snort_plugin_rc4.c
new file mode 100644
index 0000000000000000000000000000000000000000..ff11fa69a1f68d1b2b5b3fd2296af1fae4f34d9f
--- /dev/null
+++ b/code/train/C/0144106_sf_snort_plugin_rc4.c
@@ -0,0 +1,105 @@
+/*
+ *  sf_snort_plugin_rc4.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License Version 2 as
+ * published by the Free Software Foundation.  You may not use, modify or
+ * distribute this program under any other version of the GNU General
+ * Public License.
+ *
+ * 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.
+ *
+ * Copyright (C) 2014-2015 Cisco and/or its affiliates. All rights reserved.
+ * Copyright (C) 2006-2013 Sourcefire, Inc.
+ *
+ * Author: Lurene Grunier
+ *         Andy Mullican
+ *
+ * Date: 4/2006
+ *
+ *
+ * RC4 Option operations for dynamic rule engine
+ */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "sf_dynamic_define.h"
+#include "sf_snort_packet.h"
+#include "sf_snort_plugin_api.h"
+#include "sfghash.h"
+
+#include "sf_dynamic_engine.h"
+
+#define BYTESWAP(x,y) tmp = x; x = y; y = tmp;
+
+/* Artificially limit decrypted data size to 1024, for now */
+#define MAX_DATA_LEN    1024
+
+/* Decode RC4 data. Return 1 if data matches decoded data. */
+int MatchDecryptedRC4(
+    const u_int8_t *key, u_int16_t keylen, const u_int8_t *encrypted_data,
+    u_int8_t *match_data, u_int16_t datalen
+) {
+    u_int16_t   i;
+    u_int8_t    t, tmp;
+    static char decrypted_data[MAX_DATA_LEN];
+    u_int8_t s[256] = {
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
+        0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+        0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
+        0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
+        0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+        0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53,
+        0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+        0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b,
+        0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
+        0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83,
+        0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
+        0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+        0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
+        0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+        0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb,
+        0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+        0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3,
+        0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+        0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb,
+        0xfc, 0xfd, 0xfe, 0xff
+    };
+
+    /* Make sure our buffer is big enough to do the decode */
+    if ( datalen > MAX_DATA_LEN )
+        return 0;
+
+    /* Initialize the state array with given key */
+    t = 0;
+    for(i = 0; i < 256; i++) {
+        t += s[i] + key[i % keylen];
+        BYTESWAP(s[i], s[t])
+    }
+
+    /* Decrypt data */
+    t = 0;
+    for (i = 0; i < datalen; i++) {
+        int idx = (i+1)%256;
+        t += s[idx];
+        BYTESWAP(s[idx], s[t])
+        decrypted_data[i] = encrypted_data[i] ^ s[((s[idx] + s[t]) % 256)];
+    }
+
+    /* Check for data match */
+    if (!memcmp(match_data, decrypted_data, datalen)) {
+        return 1;
+    }
+
+    return 0;
+}
diff --git a/code/train/C/0144423_os_maild_client.c b/code/train/C/0144423_os_maild_client.c
new file mode 100644
index 0000000000000000000000000000000000000000..a25f572e56efbb39c25bdecb1a896f64288b49b2
--- /dev/null
+++ b/code/train/C/0144423_os_maild_client.c
@@ -0,0 +1,289 @@
+/* @(#) $Id: ./src/os_maild/os_maild_client.c, 2011/09/08 dcid Exp $
+ */
+
+/* Copyright (C) 2009 Trend Micro Inc.
+ * All rights reserved.
+ *
+ * This program is a free software; you can redistribute it
+ * and/or modify it under the terms of the GNU General Public
+ * License (version 2) as published by the FSF - Free Software
+ * Foundation
+ */
+
+
+#include "shared.h"
+#include "maild.h"
+
+
+/* OS_RecvMailQ, 
+ * v0.1, 2005/03/15
+ * Receive a Message on the Mail queue
+ * v0,2: Using the new file-queue.
+ */
+MailMsg *OS_RecvMailQ(file_queue *fileq, struct tm *p, 
+                      MailConfig *Mail, MailMsg **msg_sms)
+{
+    int i = 0, body_size = OS_MAXSTR -3, log_size, sms_set = 0,donotgroup = 0;
+    char logs[OS_MAXSTR + 1];
+    char *subject_host;
+    
+    MailMsg *mail;
+    alert_data *al_data;
+
+    Mail->priority = 0;
+
+
+    /* Get message if available */
+    al_data = Read_FileMon(fileq, p, mail_timeout);
+    if(!al_data)
+        return(NULL);
+
+
+    /* If e-mail came correctly, generate the e-mail body/subject */
+    os_calloc(1,sizeof(MailMsg), mail);
+    os_calloc(BODY_SIZE, sizeof(char), mail->body);
+    os_calloc(SUBJECT_SIZE, sizeof(char), mail->subject);
+
+
+    /* Generating the logs */
+    logs[0] = '\0';
+    logs[OS_MAXSTR] = '\0';
+    
+    while(al_data->log[i])
+    {
+        log_size = strlen(al_data->log[i]) + 4;
+        
+        /* If size left is small than the size of the log, stop it */
+        if(body_size <= log_size)
+        {
+            break;
+        }
+        
+        strncat(logs, al_data->log[i], body_size);
+        strncat(logs, "\r\n", body_size);
+        body_size -= log_size;
+        i++;
+    }
+
+
+    /* Subject */
+    subject_host = strchr(al_data->location, '>');
+    if(subject_host)
+    {
+        subject_host--;
+        *subject_host = '\0';
+    }
+
+    /* We have two subject options - full and normal */
+    if(Mail->subject_full)
+    {
+        /* Option for a clean full subject (without ossec in the name) */
+        #ifdef CLEANFULL
+        snprintf(mail->subject, SUBJECT_SIZE -1, MAIL_SUBJECT_FULL2, 
+                                al_data->level,
+                                al_data->comment,
+                                al_data->location);
+        #else
+        snprintf(mail->subject, SUBJECT_SIZE -1, MAIL_SUBJECT_FULL, 
+                                al_data->location,
+                                al_data->level,
+                                al_data->comment);
+        #endif
+    }
+    else
+    {
+        snprintf(mail->subject, SUBJECT_SIZE -1, MAIL_SUBJECT, 
+                                             al_data->location,
+                                             al_data->level);
+    }
+
+    
+    /* fixing subject back */
+    if(subject_host)
+    {
+        *subject_host = '-';
+    }
+
+    
+    /* Body */
+    snprintf(mail->body, BODY_SIZE -1, MAIL_BODY,
+            al_data->date,
+            al_data->location,
+            al_data->rule,
+            al_data->level,
+            al_data->comment,
+            logs);
+
+
+    /* Checking for granular email configs */
+    if(Mail->gran_to)
+    {
+        i = 0;
+        while(Mail->gran_to[i] != NULL)
+        {
+            int gr_set = 0;
+            
+            /* Looking if location is set */
+            if(Mail->gran_location[i])
+            {
+                if(OSMatch_Execute(al_data->location,
+                                   strlen(al_data->location),
+                                   Mail->gran_location[i]))
+                {
+                    gr_set = 1;
+                }
+                else
+                {
+                    i++;
+                    continue;
+                }
+            }
+            
+            /* Looking for the level */
+            if(Mail->gran_level[i])
+            {
+                if(al_data->level >= Mail->gran_level[i])
+                {
+                    gr_set = 1;
+                }
+                else
+                {
+                    i++;
+                    continue;
+                }
+            }
+
+
+            /* Looking for rule id */
+            if(Mail->gran_id[i])
+            {
+                int id_i = 0;
+                while(Mail->gran_id[i][id_i] != 0)
+                {
+                    if(Mail->gran_id[i][id_i] == al_data->rule)
+                    {
+                        break;
+                    }
+                    id_i++;
+                }
+
+                /* If we found, id is going to be a valid rule */
+                if(Mail->gran_id[i][id_i])
+                {
+                    gr_set = 1;
+                }
+                else
+                {
+                    i++;
+                    continue;
+                }
+            }
+            
+
+            /* Looking for the group */
+            if(Mail->gran_group[i])
+            {
+                if(OSMatch_Execute(al_data->group,
+                                   strlen(al_data->group),
+                                   Mail->gran_group[i]))
+                {
+                    gr_set = 1;
+                }
+                else
+                {
+                    i++;
+                    continue;
+                }
+            }
+
+
+            /* If we got in here, it is because everything
+             * matched. Set this e-mail to be used.
+             */
+            if(gr_set)
+            {
+                if(Mail->gran_format[i] == SMS_FORMAT)
+                {
+                    Mail->gran_set[i] = SMS_FORMAT;
+
+                    /* Setting the SMS flag */
+                    sms_set = 1;
+                }
+                else
+                {
+                    /* Options */
+                    if(Mail->gran_format[i] == FORWARD_NOW)
+                    {
+                        Mail->priority = 1;
+                        Mail->gran_set[i] = FULL_FORMAT;
+                    }
+                    else if(Mail->gran_format[i] == DONOTGROUP)
+                    {
+                        Mail->priority = DONOTGROUP;
+                        Mail->gran_set[i] = DONOTGROUP;
+                        donotgroup = 1;
+                    }
+                    else
+                    {
+                        Mail->gran_set[i] = FULL_FORMAT;
+                    }
+                }
+            }
+            i++;
+        }
+    }
+
+
+    /* If DONOTGROUP is set, we can't assign the new subject */
+    if(!donotgroup)
+    {
+        /* Getting highest level for alert */
+        if(_g_subject[0] != '\0')
+        {
+            if(_g_subject_level < al_data->level)
+            {
+                strncpy(_g_subject, mail->subject, SUBJECT_SIZE);
+                _g_subject_level = al_data->level;
+            }
+        }
+        else
+        {
+            strncpy(_g_subject, mail->subject, SUBJECT_SIZE);
+            _g_subject_level = al_data->level;
+        }
+    }
+    
+    
+    /* If sms is set, create the sms output */
+    if(sms_set)
+    {
+        MailMsg *msg_sms_tmp;
+        
+        /* Allocate memory for sms */
+        os_calloc(1,sizeof(MailMsg), msg_sms_tmp);
+        os_calloc(BODY_SIZE, sizeof(char), msg_sms_tmp->body);
+        os_calloc(SUBJECT_SIZE, sizeof(char), msg_sms_tmp->subject);
+
+        snprintf(msg_sms_tmp->subject, SUBJECT_SIZE -1, SMS_SUBJECT,
+                                      al_data->level,
+                                      al_data->rule,
+                                      al_data->comment);
+
+
+        strncpy(msg_sms_tmp->body, logs, 128);
+        msg_sms_tmp->body[127] = '\0';
+        
+        /* Assigning msg_sms */
+        *msg_sms = msg_sms_tmp;
+    }
+    
+    
+    
+    /* Clearing the memory */
+    FreeAlertData(al_data);
+
+    
+    return(mail);
+
+}
+/* EOF */
diff --git a/code/train/C/0144574_coredump.c b/code/train/C/0144574_coredump.c
new file mode 100644
index 0000000000000000000000000000000000000000..eea120229cdbc800a9540f534e49978adb0a446c
--- /dev/null
+++ b/code/train/C/0144574_coredump.c
@@ -0,0 +1,250 @@
+/*
+ * SPU core dump code
+ *
+ * (C) Copyright 2006 IBM Corp.
+ *
+ * Author: Dwayne Grant McConnell <decimal@us.ibm.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 2, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/elf.h>
+#include <linux/file.h>
+#include <linux/fdtable.h>
+#include <linux/fs.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/syscalls.h>
+
+#include <asm/uaccess.h>
+
+#include "spufs.h"
+
+static ssize_t do_coredump_read(int num, struct spu_context *ctx, void *buffer,
+				size_t size, loff_t *off)
+{
+	u64 data;
+	int ret;
+
+	if (spufs_coredump_read[num].read)
+		return spufs_coredump_read[num].read(ctx, buffer, size, off);
+
+	data = spufs_coredump_read[num].get(ctx);
+	ret = snprintf(buffer, size, "0x%.16llx", data);
+	if (ret >= size)
+		return size;
+	return ++ret; /* count trailing NULL */
+}
+
+/*
+ * These are the only things you should do on a core-file: use only these
+ * functions to write out all the necessary info.
+ */
+static int spufs_dump_write(struct file *file, const void *addr, int nr, loff_t *foffset)
+{
+	unsigned long limit = rlimit(RLIMIT_CORE);
+	ssize_t written;
+
+	if (*foffset + nr > limit)
+		return -EIO;
+
+	written = file->f_op->write(file, addr, nr, &file->f_pos);
+	*foffset += written;
+
+	if (written != nr)
+		return -EIO;
+
+	return 0;
+}
+
+static int spufs_dump_align(struct file *file, char *buf, loff_t new_off,
+			    loff_t *foffset)
+{
+	int rc, size;
+
+	size = min((loff_t)PAGE_SIZE, new_off - *foffset);
+	memset(buf, 0, size);
+
+	rc = 0;
+	while (rc == 0 && new_off > *foffset) {
+		size = min((loff_t)PAGE_SIZE, new_off - *foffset);
+		rc = spufs_dump_write(file, buf, size, foffset);
+	}
+
+	return rc;
+}
+
+static int spufs_ctx_note_size(struct spu_context *ctx, int dfd)
+{
+	int i, sz, total = 0;
+	char *name;
+	char fullname[80];
+
+	for (i = 0; spufs_coredump_read[i].name != NULL; i++) {
+		name = spufs_coredump_read[i].name;
+		sz = spufs_coredump_read[i].size;
+
+		sprintf(fullname, "SPU/%d/%s", dfd, name);
+
+		total += sizeof(struct elf_note);
+		total += roundup(strlen(fullname) + 1, 4);
+		total += roundup(sz, 4);
+	}
+
+	return total;
+}
+
+/*
+ * The additional architecture-specific notes for Cell are various
+ * context files in the spu context.
+ *
+ * This function iterates over all open file descriptors and sees
+ * if they are a directory in spufs.  In that case we use spufs
+ * internal functionality to dump them without needing to actually
+ * open the files.
+ */
+static struct spu_context *coredump_next_context(int *fd)
+{
+	struct fdtable *fdt = files_fdtable(current->files);
+	struct file *file;
+	struct spu_context *ctx = NULL;
+
+	for (; *fd < fdt->max_fds; (*fd)++) {
+		if (!FD_ISSET(*fd, fdt->open_fds))
+			continue;
+
+		file = fcheck(*fd);
+
+		if (!file || file->f_op != &spufs_context_fops)
+			continue;
+
+		ctx = SPUFS_I(file->f_dentry->d_inode)->i_ctx;
+		if (ctx->flags & SPU_CREATE_NOSCHED)
+			continue;
+
+		break;
+	}
+
+	return ctx;
+}
+
+int spufs_coredump_extra_notes_size(void)
+{
+	struct spu_context *ctx;
+	int size = 0, rc, fd;
+
+	fd = 0;
+	while ((ctx = coredump_next_context(&fd)) != NULL) {
+		rc = spu_acquire_saved(ctx);
+		if (rc)
+			break;
+		rc = spufs_ctx_note_size(ctx, fd);
+		spu_release_saved(ctx);
+		if (rc < 0)
+			break;
+
+		size += rc;
+
+		/* start searching the next fd next time */
+		fd++;
+	}
+
+	return size;
+}
+
+static int spufs_arch_write_note(struct spu_context *ctx, int i,
+				  struct file *file, int dfd, loff_t *foffset)
+{
+	loff_t pos = 0;
+	int sz, rc, nread, total = 0;
+	const int bufsz = PAGE_SIZE;
+	char *name;
+	char fullname[80], *buf;
+	struct elf_note en;
+
+	buf = (void *)get_zeroed_page(GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	name = spufs_coredump_read[i].name;
+	sz = spufs_coredump_read[i].size;
+
+	sprintf(fullname, "SPU/%d/%s", dfd, name);
+	en.n_namesz = strlen(fullname) + 1;
+	en.n_descsz = sz;
+	en.n_type = NT_SPU;
+
+	rc = spufs_dump_write(file, &en, sizeof(en), foffset);
+	if (rc)
+		goto out;
+
+	rc = spufs_dump_write(file, fullname, en.n_namesz, foffset);
+	if (rc)
+		goto out;
+
+	rc = spufs_dump_align(file, buf, roundup(*foffset, 4), foffset);
+	if (rc)
+		goto out;
+
+	do {
+		nread = do_coredump_read(i, ctx, buf, bufsz, &pos);
+		if (nread > 0) {
+			rc = spufs_dump_write(file, buf, nread, foffset);
+			if (rc)
+				goto out;
+			total += nread;
+		}
+	} while (nread == bufsz && total < sz);
+
+	if (nread < 0) {
+		rc = nread;
+		goto out;
+	}
+
+	rc = spufs_dump_align(file, buf, roundup(*foffset - total + sz, 4),
+			      foffset);
+
+out:
+	free_page((unsigned long)buf);
+	return rc;
+}
+
+int spufs_coredump_extra_notes_write(struct file *file, loff_t *foffset)
+{
+	struct spu_context *ctx;
+	int fd, j, rc;
+
+	fd = 0;
+	while ((ctx = coredump_next_context(&fd)) != NULL) {
+		rc = spu_acquire_saved(ctx);
+		if (rc)
+			return rc;
+
+		for (j = 0; spufs_coredump_read[j].name != NULL; j++) {
+			rc = spufs_arch_write_note(ctx, j, file, fd, foffset);
+			if (rc) {
+				spu_release_saved(ctx);
+				return rc;
+			}
+		}
+
+		spu_release_saved(ctx);
+
+		/* start searching the next fd next time */
+		fd++;
+	}
+
+	return 0;
+}
diff --git a/code/train/C/0144632_resourcemanager_RMSEG.c b/code/train/C/0144632_resourcemanager_RMSEG.c
new file mode 100644
index 0000000000000000000000000000000000000000..f8afe5ad9e660c7a4d12437217bf89f8504da65c
--- /dev/null
+++ b/code/train/C/0144632_resourcemanager_RMSEG.c
@@ -0,0 +1,288 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "envswitch.h"
+#include "dynrm.h"
+
+#include "resourcemanager/resourcemanager.h"
+#include "communication/rmcomm_AsyncComm.h"
+#include "communication/rmcomm_MessageHandler.h"
+#include "communication/rmcomm_MessageServer.h"
+#include "communication/rmcomm_RMSEG2RM.h"
+#include "resourceenforcer/resourceenforcer.h"
+#include "cdb/cdbtmpdir.h"
+
+int ResManagerMainSegment2ndPhase(void)
+{
+	int res = FUNC_RETURN_OK;
+
+	elog(DEBUG5, "HAWQ RM SEG is triggered.");
+
+	/* Register message handlers */
+	registerMessageHandler(REQUEST_QE_MOVETOCGROUP, handleQEMoveToCGroup);
+	registerMessageHandler(REQUEST_QE_MOVEOUTCGROUP, handleQEMoveOutCGroup);
+	registerMessageHandler(REQUEST_QE_SETWEIGHTCGROUP, handleQESetWeightCGroup);
+	registerMessageHandler(REQUEST_RM_INCREASE_MEMORY_QUOTA, handleRMIncreaseMemoryQuota);
+	registerMessageHandler(REQUEST_RM_DECREASE_MEMORY_QUOTA, handleRMDecreaseMemoryQuota);
+	registerMessageHandler(REQUEST_RM_RUALIVE, handleRMSEGRequestRUAlive);
+
+
+	/**************************************************************************
+	 * New socket facility poll based server.
+	 **************************************************************************/
+	res = initializeSocketServer_RMSEG();
+	if ( res != FUNC_RETURN_OK ) {
+		elog(FATAL, "Fail to initialize socket server.");
+	}
+
+	/*
+	 * Resource enforcement: initialize, cleanup, and rebuild CGroup hash table
+	 * when segment resource manager starts/restarts
+	 */
+	initCGroupThreads();
+
+	InitFileAccess();
+
+	/*
+	 * Notify postmaster that HAWQ RM is ready. Ignore the possible problem that
+	 * the parent process quits. HAWQ RM will automatically detect if its parent
+	 * dies, then HAWQ RM should exit normally.
+	 */
+	kill(DRMGlobalInstance->ParentPID, SIGUSR2);
+	elog(LOG, "HAWQ RM SEG process works now.");
+
+    /* Start request handler to provide services. */
+    res = MainHandlerLoop_RMSEG();
+
+    elog(RMLOG, "HAWQ RM SEG server goes into exit phase.");
+    return res;
+
+}
+
+int  initializeSocketServer_RMSEG(void)
+{
+	int 		res		= FUNC_RETURN_OK;
+	int 		netres 	= 0;
+	char 	   *allip   = "0.0.0.0";
+	pgsocket 	RMListenSocket[HAWQRM_SERVER_PORT_COUNT];
+
+	for ( int i = 0 ; i < HAWQRM_SERVER_PORT_COUNT ; ++i ) {
+		RMListenSocket[i] = PGINVALID_SOCKET;
+	}
+
+	/* Listen normal socket addresses. */
+	netres = StreamServerPort( AF_UNSPEC,
+							   allip,
+							   rm_segment_port,
+							   NULL,
+							   RMListenSocket,
+							   HAWQRM_SERVER_PORT_COUNT);
+
+	/* If there are multiple segments in one host, which is common in old imp.
+	 * We can not make all segments work. So, if HAWQ RM SEG fails to start
+	 * socket server by listening the port, we accept this case and make it
+	 * silent. HAWQ RM will not recognize this segment and will not assign
+	 * tasks. */
+	if ( netres != STATUS_OK ) {
+		res = REQUESTHANDLER_FAIL_START_SOCKET_SERVER;
+		elog( LOG,  "cannot create socket server. HostName=%s, Port=%d",
+				    allip,
+					rm_segment_port);
+		return res;
+	}
+
+	/* Initialize array for polling all file descriptors. */
+	initializeAsyncComm();
+	int 			validfdcount = 0;
+	AsyncCommBuffer newbuffer    = NULL;
+	for ( int i = 0 ; i < HAWQRM_SERVER_PORT_COUNT ; ++i ) {
+		if (RMListenSocket[i] != PGINVALID_SOCKET) {
+			netres = registerFileDesc(RMListenSocket[i],
+									  ASYNCCOMM_READ,
+									  &AsyncCommBufferHandlersMsgServer,
+									  NULL,
+									  &newbuffer);
+			if ( netres != FUNC_RETURN_OK ) {
+				res = REQUESTHANDLER_FAIL_START_SOCKET_SERVER;
+				elog(LOG, "Resource manager cannot track socket server.");
+				break;
+			}
+			validfdcount++;
+
+			InitHandler_Message(newbuffer);
+		}
+	}
+
+	if ( res != FUNC_RETURN_OK ) {
+		for ( int i = 0 ; i < HAWQRM_SERVER_PORT_COUNT ; ++i ) {
+			if ( RMListenSocket[i] != PGINVALID_SOCKET ) close(RMListenSocket[i]);
+		}
+		return res;
+	}
+
+	elog(DEBUG5, "HAWQ RM SEG :: Starts accepting resource request. "
+				 "Listening normal socket port %s:%d. "
+				 "Total listened %d FDs.",
+				allip,
+				rm_segment_port,
+				validfdcount);
+	return res;
+
+}
+
+int MainHandlerLoop_RMSEG(void)
+{
+	int 		res 	  = FUNC_RETURN_OK;
+	uint64_t    curtime   = 0;
+	int			errorcode = FUNC_RETURN_OK;
+	char		errorbuf[1024];
+
+	DRMGlobalInstance->ResourceManagerStartTime = gettime_microsec();
+	while( DRMGlobalInstance->ResManagerMainKeepRun ) {
+
+		if (!PostmasterIsAlive(true)) {
+			DRMGlobalInstance->ResManagerMainKeepRun = false;
+			elog(LOG, "Postmaster is not alive, resource manager exits");
+			break;
+		}
+
+		/* PART1. Handle socket server inputs. */
+		res = processAllCommFileDescs();
+		if ( res != FUNC_RETURN_OK ) {
+			/*
+			 * The possible error here is the failure of poll(), we won't keep
+			 * running HAWQ RM any longer, graceful quit is requested.
+			 */
+			DRMGlobalInstance->ResManagerMainKeepRun = false;
+			elog(LOG, "System error cause resource manager not possible to track "
+					  "network communications.");
+		}
+
+		/* PART2. Handle all BE submitted requests. */
+		processSubmittedRequests();
+
+		if ( curtime - DRMGlobalInstance->TmpDirLastCheckTime >
+			1000000LL * rm_segment_tmpdir_detect_interval )
+		{
+			checkAndBuildFailedTmpDirList();
+			DRMGlobalInstance->TmpDirLastCheckTime = gettime_microsec();
+		}
+
+		/* PART3. Fresh local host info and send IMAlive message to resource
+		 * 		  manager server.											  */
+		curtime = gettime_microsec();
+		if ( DRMGlobalInstance->LocalHostStat == NULL ||
+			 curtime - DRMGlobalInstance->LocalHostLastUpdateTime >
+			 1000000LL * rm_segment_config_refresh_interval )
+		{
+			refreshLocalHostInstance();
+			checkLocalPostmasterStatus();
+		}
+
+		if ( DRMGlobalInstance->SendIMAlive )
+		{
+			 if (DRMGlobalInstance->LocalHostStat != NULL &&
+			     curtime - DRMGlobalInstance->HeartBeatLastSentTime >
+				 1000000LL * rm_segment_heartbeat_interval )
+			 {
+				 sendIMAlive(&errorcode, errorbuf, sizeof(errorbuf));
+				 DRMGlobalInstance->HeartBeatLastSentTime = gettime_microsec();
+			 }
+		}
+
+		/* PART4. Send responses back to the clients. */
+		sendResponseToClients();
+
+		/* PART5. Resource enforcement work thread quit */
+		if (g_enforcement_thread_quited) {
+			elog(ERROR, "Resource enforcement thread quited");
+		}
+	}
+
+	elog(RMLOG, "Resource manager main event handler exits.");
+
+	return res;
+}
+
+/*
+ *  Check if this temporary directory is OK to read or write.
+ *  If not, it's probably due to disk error.
+ */
+bool CheckTmpDirAvailable(char *path)
+{
+	FILE  *tmp = NULL;
+	bool  ret = true;
+	char* fname = NULL;
+	char* testfile = "/checktmpdir.log";
+
+	/* open a file to check if
+	 * this temporary directory is OK.
+	 */
+	fname = palloc0(strlen(path) + strlen(testfile) + 1);
+	strncpy(fname, path, strlen(path));
+	strncpy(fname + strlen(path), testfile, strlen(testfile));
+	tmp = fopen(fname, "w");
+	if (tmp == NULL)
+	{
+		elog(LOG, "Can't open file:%s when check temporary directory: %s",
+				  fname,
+				  strerror(errno));
+		ret = false;
+	}
+
+	pfree(fname);
+	if (tmp != NULL)
+		fclose(tmp);
+	return ret;
+}
+
+/*
+ * Check the status of each temporary directory,
+ * and build a list of failed temporary directories.
+ */
+void checkAndBuildFailedTmpDirList(void)
+{
+	uint64_t starttime = gettime_microsec();
+	destroyTmpDirList(DRMGlobalInstance->LocalHostFailedTmpDirList);
+	DRMGlobalInstance->LocalHostFailedTmpDirList = NULL;
+
+	DQUEUE_LOOP_BEGIN(&DRMGlobalInstance->LocalHostTempDirectories, iter, SimpStringPtr, value)
+		if (!CheckTmpDirAvailable(value->Str))
+		{
+			char *failedDir = pstrdup(value->Str);
+			DRMGlobalInstance->LocalHostFailedTmpDirList =
+					lappend(DRMGlobalInstance->LocalHostFailedTmpDirList, failedDir);
+		}
+	DQUEUE_LOOP_END
+	uint64_t endtime = gettime_microsec();
+	elog(LOG, "checkAndBuildFailedTmpDirList finished checking temporary "
+			  "directory, which costs " UINT64_FORMAT " us",
+			  endtime - starttime);
+}
+
+void switchIMAliveSendingTarget(void)
+{
+	/* We switch to standby server only when it is correctly set. */
+	if (pg_strcasecmp(standby_addr_host, "none") != 0)
+	{
+		DRMGlobalInstance->SendToStandby = !DRMGlobalInstance->SendToStandby;
+		elog(LOG, "segment will send heart-beat to %s from now on",
+				  DRMGlobalInstance->SendToStandby ? "standby" : "master");
+	}
+}
diff --git a/code/train/C/0144792_net.c b/code/train/C/0144792_net.c
new file mode 100644
index 0000000000000000000000000000000000000000..8d07a302c07394bae95c733dc7a18033fbd211f7
--- /dev/null
+++ b/code/train/C/0144792_net.c
@@ -0,0 +1,274 @@
+/*****************************************************************************\
+ *  net.c - basic network communications for user application I/O
+ *****************************************************************************
+ *  Copyright (C) 2002 The Regents of the University of California.
+ *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
+ *  Written by Mark Grondona <grondona1@llnl.gov>, Kevin Tew <tew1@llnl.gov>,
+ *  et. al.
+ *  CODE-OCEC-09-009. All rights reserved.
+ *
+ *  This file is part of SLURM, a resource management program.
+ *  For details, see <http://slurm.schedmd.com/>.
+ *  Please also read the included file: DISCLAIMER.
+ *
+ *  SLURM 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.
+ *
+ *  In addition, as a special exception, the copyright holders give permission
+ *  to link the code of portions of this program with the OpenSSL library under
+ *  certain conditions as described in each individual source file, and
+ *  distribute linked combinations including the two. You must obey the GNU
+ *  General Public License in all respects for all of the code used other than
+ *  OpenSSL. If you modify file(s) with this exception, you may extend this
+ *  exception to your version of the file(s), but you are not obligated to do
+ *  so. If you do not wish to do so, delete this exception statement from your
+ *  version.  If you delete this exception statement from all source files in
+ *  the program, then also delete it here.
+ *
+ *  SLURM 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 SLURM; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA.
+\*****************************************************************************/
+
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <sys/select.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdint.h>
+
+#if defined(__FreeBSD__) || defined(__NetBSD__)
+#define	SOL_TCP		IPPROTO_TCP
+#endif
+
+#include "src/common/log.h"
+#include "src/common/macros.h"
+#include "src/common/net.h"
+#include "src/common/slurm_protocol_api.h"
+
+/*
+ * Define slurm-specific aliases for use by plugins, see slurm_xlator.h
+ * for details.
+ */
+strong_alias(net_stream_listen,		slurm_net_stream_listen);
+strong_alias(net_accept_stream,		slurm_net_accept_stream);
+strong_alias(net_set_low_water,		slurm_net_set_low_water);
+
+#ifndef NET_DEFAULT_BACKLOG
+#  define NET_DEFAULT_BACKLOG	1024
+#endif
+
+/*
+ * Returns the port number in host byte order.
+ */
+static short _sock_bind_wild(int sockfd)
+{
+	socklen_t len;
+	struct sockaddr_in sin;
+
+	slurm_setup_sockaddr(&sin, 0); /* bind ephemeral port */
+
+	if (bind(sockfd, (struct sockaddr *) &sin, sizeof(sin)) < 0)
+		return (-1);
+	len = sizeof(sin);
+	if (getsockname(sockfd, (struct sockaddr *) &sin, &len) < 0)
+		return (-1);
+	return ntohs(sin.sin_port);
+}
+
+/* open a stream socket on an ephemereal port and put it into
+ * the listen state. fd and port are filled in with the new
+ * socket's file descriptor and port #.
+ *
+ * OUT fd - listening socket file descriptor number
+ * OUT port - TCP port number in host byte order
+ */
+int net_stream_listen(int *fd, uint16_t *port)
+{
+	int rc, val;
+
+	if ((*fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
+		return -1;
+
+	val = 1;
+	rc = setsockopt(*fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(int));
+	if (rc < 0)
+		goto cleanup;
+
+	*port = _sock_bind_wild(*fd);
+#undef SOMAXCONN
+#define SOMAXCONN	1024
+	rc = listen(*fd, NET_DEFAULT_BACKLOG);
+	if (rc < 0)
+		goto cleanup;
+
+	return 1;
+
+  cleanup:
+	close(*fd);
+	return -1;
+}
+
+
+int net_accept_stream(int fd)
+{
+	int sd;
+
+	while ((sd = accept(fd, NULL, NULL)) < 0) {
+		if (errno == EINTR)
+			continue;
+		if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
+			return -1;
+		if (errno == ECONNABORTED)
+			return -1;
+		error("Unable to accept new connection");
+	}
+
+	return sd;
+}
+
+int readn(int fd, void *buf, size_t nbytes)
+{
+	int n = 0;
+	char *pbuf = (char *)buf;
+	size_t nleft = nbytes;
+
+	while (nleft > 0) {
+		n = read(fd, (void *)pbuf, nleft);
+		if (n > 0) {
+			pbuf+=n;
+			nleft-=n;
+		} else if (n == 0) 	/* EOF */
+			break;
+		else if (errno == EINTR)
+			continue;
+		else {
+			debug("read error: %m");
+			break;
+		}
+	}
+	return(n);
+}
+
+int net_set_low_water(int sock, socklen_t size)
+{
+	if (setsockopt(sock, SOL_SOCKET, SO_RCVLOWAT,
+		       (const void *) &size, sizeof(size)) < 0) {
+		error("Unable to set low water socket option: %m");
+		return -1;
+	}
+
+	return 0;
+}
+
+/* set keep alive time on socket */
+extern int net_set_keep_alive(int sock)
+{
+	int opt_int;
+	socklen_t opt_len;
+	struct linger opt_linger;
+	static bool keep_alive_set  = false;
+	static int  keep_alive_time = (uint16_t) NO_VAL;
+
+	if (!keep_alive_set) {
+		keep_alive_time = slurm_get_keep_alive_time();
+		keep_alive_set = true;
+	}
+
+	if (keep_alive_time == (uint16_t) NO_VAL)
+		return 0;
+
+	opt_len = sizeof(struct linger);
+	opt_linger.l_onoff = 1;
+	opt_linger.l_linger = keep_alive_time;
+	if (setsockopt(sock, SOL_SOCKET, SO_LINGER, &opt_linger, opt_len) < 0)
+		error("Unable to set linger socket option: %m");
+
+	opt_len = sizeof(int);
+	opt_int = 1;
+	if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &opt_int, opt_len) < 0) {
+		error("Unable to set keep alive socket option: %m");
+		return -1;
+	}
+
+/*
+ * TCP_KEEPIDLE used to be defined in FreeBSD, then went away, then came
+ * back in 9.0.
+ *
+ * Removing this call might decrease the robustness of communications,
+ * but will probably have no noticable effect.
+ */
+#if !defined (__APPLE__) && (! defined(__FreeBSD__) || (__FreeBSD_version > 900000))
+	opt_int = keep_alive_time;
+	if (setsockopt(sock, SOL_TCP, TCP_KEEPIDLE, &opt_int, opt_len) < 0) {
+		error("Unable to set keep alive socket time: %m");
+		return -1;
+	}
+#endif
+
+#if 0
+	/* Used to validate above operations for testing purposes */
+	opt_linger.l_onoff = 0;
+	opt_linger.l_linger = 0;
+	opt_len = sizeof(struct linger);
+	getsockopt(sock, SOL_SOCKET, SO_LINGER, &opt_linger, &opt_len);
+	info("got linger time of %d:%d on fd %d", opt_linger.l_onoff,
+	     opt_linger.l_linger, sock);
+
+	opt_len = sizeof(int);
+	getsockopt(sock, SOL_TCP, TCP_KEEPIDLE, &opt_int, &opt_len);
+	info("got keep_alive time is %d on fd %d", opt_int, sock);
+#endif
+
+	return 0;
+}
+
+/* net_stream_listen_ports()
+ */
+int
+net_stream_listen_ports(int *fd, uint16_t *port, uint16_t *ports)
+{
+	int cc;
+	int val;
+
+	if ((*fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
+		return -1;
+
+	val = 1;
+	cc = setsockopt(*fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(int));
+	if (cc < 0) {
+		close(*fd);
+		return -1;
+	}
+
+	cc = sock_bind_range(*fd, ports);
+	if (cc < 0) {
+		close(*fd);
+		return -1;
+	}
+	*port = cc;
+#undef SOMAXCONN
+#define SOMAXCONN	1024
+	cc = listen(*fd, NET_DEFAULT_BACKLOG);
+	if (cc < 0) {
+		close(*fd);
+		return -1;
+	}
+
+	return *fd;
+}
diff --git a/code/train/C/0144832_Problem24.c b/code/train/C/0144832_Problem24.c
new file mode 100644
index 0000000000000000000000000000000000000000..69f4193a23fe5641bdb5bfee33e03d0f9b081eaa
--- /dev/null
+++ b/code/train/C/0144832_Problem24.c
@@ -0,0 +1,130 @@
+/*
+ ============================================================================
+ Name        : Euler.c
+ Author      : Jonathan Rivas
+ Version     :
+ Copyright   : 
+ Description : Problem #24
+ ============================================================================
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void printArray(int numbers[], int length){
+	int i;
+	for(i=0; i<length; i++){
+		printf("%d", numbers[i]);
+	}
+	printf("\n");
+}
+
+void swap(int *number1, int* number2){
+	int temp;
+	temp = *number1;
+	*number1 = *number2;
+	*number2 = temp;
+}
+
+int getLowerValuePosition(int numbers[], int referenceNumber, int length){
+	int position = 0, i;
+	for(i = 1; i < length; i++){
+		if(numbers[i] < numbers[position] && numbers[i]>referenceNumber){
+			position = i;
+		}
+	}
+	return position;
+}
+
+void quicksort(int numbers[], int first,int last){
+	int pivot,j,i;
+	int temp;
+
+	if(first<last){
+		pivot=first;
+		i=first;
+		j=last;
+
+		while(i<j){
+			while( numbers[i] <= numbers[pivot] && i<last)
+				i++;
+			while(numbers[j]>numbers[pivot])
+				j--;
+			if(i<j){
+				temp=numbers[i];
+				numbers[i]=numbers[j];
+				numbers[j]=temp;
+			}
+		}
+
+	 temp=numbers[pivot];
+	 numbers[pivot]=numbers[j];
+	 numbers[j]=temp;
+	 quicksort(numbers,first,j-1);
+	 quicksort(numbers,j+1,last);
+
+    }
+}
+
+int isScrambled(int numbers[], int lenght){
+	int i = lenght -2 ,islastnumber = 1;
+	if (lenght == 1){
+		return 1;
+	}
+	while(islastnumber && i >= 0){
+		if(numbers[i] < numbers[i+1]){
+			islastnumber = 0;
+		}
+		i--;
+	}
+	return islastnumber;
+}
+
+int getScrambledSize(int numbers[], int lenght){
+	int size=1, scrambled=0, len = lenght - 1;
+	while(!scrambled){
+		if(numbers[len] > numbers[len - 1]){
+			scrambled = 1;
+		}
+		else{
+			len--;
+			size++;
+		}
+	}
+	return size;
+}
+
+void getCombination(int numbers[], int lenght, int combination){
+	int j, end, size, position;
+	end = lenght-1;
+	size = getScrambledSize(numbers,lenght);
+	j = lenght-size;
+	combination--;
+	while(combination){
+		if (isScrambled(numbers+j, size)){
+			position = getLowerValuePosition(numbers+j, numbers[j-1],size);
+			swap(&numbers[j-1],&numbers[j+position]);
+			quicksort(numbers,j,end);
+		}
+		size = getScrambledSize(numbers,lenght);
+		j = lenght-size;
+		combination--;
+	}
+
+}
+
+#define LENGHT 10
+int main(void) {
+	struct timeval stop, start;
+	gettimeofday(&start, NULL);
+
+	int numbers[LENGHT] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+
+	getCombination(numbers,LENGHT,1000000);
+	printArray(numbers,LENGHT);
+
+	gettimeofday(&stop, NULL);
+	printf("\ntook %lu usec\n", stop.tv_usec - start.tv_usec);
+	return 0;
+}
diff --git a/code/train/C/0144840_arpping.c b/code/train/C/0144840_arpping.c
new file mode 100644
index 0000000000000000000000000000000000000000..b029af9bf77882102f6668d4803d9b7e91a0926c
--- /dev/null
+++ b/code/train/C/0144840_arpping.c
@@ -0,0 +1,105 @@
+/*
+ * arpping.c
+ *
+ * Mostly stolen from: dhcpcd - DHCP client daemon
+ * by Yoichi Hariguchi <yoichi@fore.com>
+ */
+
+#include <time.h>
+#include <sys/socket.h>
+#include <netinet/if_ether.h>
+#include <net/if_arp.h>
+#include <netinet/in.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include "dhcpd.h"
+#include "arpping.h"
+#include "common.h"
+
+/* args:	yiaddr - what IP to ping
+ *		ip - our ip
+ *		mac - our arp address
+ *		interface - interface to use
+ * retn:	1 addr free
+ *		0 addr used
+ *		-1 error
+ */
+
+/* FIXME: match response against chaddr */
+int arpping(uint32_t yiaddr, uint32_t ip, uint8_t *mac, char *interface)
+{
+
+	int	timeout = 2;
+	int	optval = 1;
+	int	s;			/* socket */
+	int	rv = 1;			/* return value */
+	struct sockaddr addr;		/* for interface name */
+	struct arpMsg	arp;
+	fd_set		fdset;
+	struct timeval	tm;
+	time_t		prevTime;
+
+
+	if ((s = socket (PF_PACKET, SOCK_PACKET, htons(ETH_P_ARP))) == -1) {
+#ifdef IN_BUSYBOX
+		LOG(LOG_ERR, bb_msg_can_not_create_raw_socket);
+#else
+		LOG(LOG_ERR, "Could not open raw socket");
+#endif
+		return -1;
+	}
+
+	if (setsockopt(s, SOL_SOCKET, SO_BROADCAST, &optval, sizeof(optval)) == -1) {
+		LOG(LOG_ERR, "Could not setsocketopt on raw socket");
+		close(s);
+		return -1;
+	}
+
+	/* send arp request */
+	memset(&arp, 0, sizeof(arp));
+	memcpy(arp.h_dest, MAC_BCAST_ADDR, 6);		/* MAC DA */
+	memcpy(arp.h_source, mac, 6);			/* MAC SA */
+	arp.h_proto = htons(ETH_P_ARP);			/* protocol type (Ethernet) */
+	arp.htype = htons(ARPHRD_ETHER);		/* hardware type */
+	arp.ptype = htons(ETH_P_IP);			/* protocol type (ARP message) */
+	arp.hlen = 6;					/* hardware address length */
+	arp.plen = 4;					/* protocol address length */
+	arp.operation = htons(ARPOP_REQUEST);		/* ARP op code */
+	memcpy(arp.sInaddr, &ip, sizeof(ip));		/* source IP address */
+	memcpy(arp.sHaddr, mac, 6);			/* source hardware address */
+	memcpy(arp.tInaddr, &yiaddr, sizeof(yiaddr));	/* target IP address */
+
+	memset(&addr, 0, sizeof(addr));
+	strcpy(addr.sa_data, interface);
+	if (sendto(s, &arp, sizeof(arp), 0, &addr, sizeof(addr)) < 0)
+		rv = 0;
+
+	/* wait arp reply, and check it */
+	tm.tv_usec = 0;
+	prevTime = uptime();
+	while (timeout > 0) {
+		FD_ZERO(&fdset);
+		FD_SET(s, &fdset);
+		tm.tv_sec = timeout;
+		if (select(s + 1, &fdset, (fd_set *) NULL, (fd_set *) NULL, &tm) < 0) {
+			DEBUG(LOG_ERR, "Error on ARPING request: %m");
+			if (errno != EINTR) rv = 0;
+		} else if (FD_ISSET(s, &fdset)) {
+			if (recv(s, &arp, sizeof(arp), 0) < 0 ) rv = 0;
+			if (arp.operation == htons(ARPOP_REPLY) &&
+			    memcmp(arp.tHaddr, mac, 6) == 0 &&
+			    *((uint32_t *) arp.sInaddr) == yiaddr) {
+				DEBUG(LOG_INFO, "Valid arp reply receved for this address");
+				rv = 0;
+				break;
+			}
+		}
+		timeout -= uptime() - prevTime;
+		prevTime = uptime();
+	}
+	close(s);
+	DEBUG(LOG_INFO, "%salid arp replies for this address", rv ? "No v" : "V");
+	return rv;
+}
diff --git a/code/train/C/0144915_sweep_filter.c b/code/train/C/0144915_sweep_filter.c
new file mode 100644
index 0000000000000000000000000000000000000000..028e5cb74ff68e7f99beea68a2da55bb71e0d21b
--- /dev/null
+++ b/code/train/C/0144915_sweep_filter.c
@@ -0,0 +1,208 @@
+/*
+ * Sweep, a sound wave editor.
+ *
+ * Copyright (C) 2000 Conrad Parker
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+
+#include <sweep/sweep_i18n.h>
+#include <sweep/sweep_types.h>
+#include <sweep/sweep_typeconvert.h>
+#include <sweep/sweep_undo.h>
+#include <sweep/sweep_filter.h>
+#include <sweep/sweep_sounddata.h>
+#include <sweep/sweep_sample.h>
+
+#include "sweep_app.h"
+#include "edit.h"
+
+
+static void
+do_filter_regions (sw_sample * sample, SweepFilterRegion func,
+		   sw_param_set pset, gpointer custom_data)
+{
+  sw_sounddata * sounddata = sample->sounddata;
+  sw_format * f = sounddata->format;
+  GList * gl;
+  sw_sel * sel;
+  sw_framecount_t sel_total, run_total;
+  sw_framecount_t offset, remaining, n;
+  gpointer d;
+  gint percent;
+
+  gboolean active = TRUE;
+
+  sel_total = sounddata_selection_nr_frames (sounddata) / 100;
+  if (sel_total == 0) sel_total = 1;
+  run_total = 0;
+
+  for (gl = sounddata->sels; active && gl; gl = gl->next) {
+    sel = (sw_sel *)gl->data;
+
+    offset = 0;
+    remaining = sel->sel_end - sel->sel_start;
+
+    while (active && remaining > 0) {
+      g_mutex_lock (&sample->ops_mutex);
+
+      if (sample->edit_state == SWEEP_EDIT_STATE_CANCEL) {
+	active = FALSE;
+      } else {
+	d = sounddata->data + (int)frames_to_bytes (f, sel->sel_start + offset);
+
+	n = MIN(remaining, 1024);
+
+	func (d, sounddata->format, n, pset, custom_data);
+
+	remaining -= n;
+	offset += n;
+
+	run_total += n;
+	percent = run_total / sel_total;
+	sample_set_progress_percent (sample, percent);
+
+#ifdef DEBUG
+	g_print ("completed %d / %d frames, %d%%\n", run_total, sel_total,
+		 percent);
+#endif
+      }
+
+      g_mutex_unlock (&sample->ops_mutex);
+    }
+  }
+}
+
+static void
+do_filter_regions_thread (sw_op_instance * inst)
+{
+  sw_sample * sample = inst->sample;
+  sw_perform_data * pd = (sw_perform_data *)inst->do_data;
+
+  sw_edit_buffer * old_eb;
+  paste_over_data * p;
+
+  if (sample == NULL || sample->sounddata == NULL ||
+      sample->sounddata->sels == NULL) goto noop;
+
+  old_eb = edit_buffer_from_sample (sample);
+
+  p = paste_over_data_new (old_eb, old_eb);
+  inst->redo_data = inst->undo_data = p;
+  set_active_op (sample, inst);
+
+  do_filter_regions (sample, (SweepFilterRegion)pd->func, pd->pset,
+		     pd->custom_data);
+
+  if (sample->edit_state == SWEEP_EDIT_STATE_BUSY) {
+    p->new_eb = edit_buffer_from_sample (sample);
+
+    register_operation (sample, inst);
+  }
+
+  return;
+
+ noop:
+  sample_set_tmp_message (sample, _("No selection to process"));
+}
+
+static sw_operation filter_regions_op = {
+  SWEEP_EDIT_MODE_FILTER,
+  (SweepCallback)do_filter_regions_thread,
+  (SweepFunction)g_free,
+  (SweepCallback)undo_by_paste_over,
+  (SweepFunction)paste_over_data_destroy,
+  (SweepCallback)redo_by_paste_over,
+  (SweepFunction)paste_over_data_destroy
+};
+
+sw_op_instance *
+perform_filter_region_op (sw_sample * sample, char * desc,
+			  SweepFilterRegion func,
+			  sw_param_set pset, gpointer custom_data)
+{
+  sw_perform_data * pd = (sw_perform_data *)g_malloc (sizeof(*pd));
+
+  pd->func = (SweepFunction)func;
+  pd->pset = pset;
+  pd->custom_data = custom_data;
+
+  schedule_operation (sample, desc, &filter_regions_op, pd);
+
+  return NULL;
+}
+
+static void
+do_filter_thread (sw_op_instance * inst)
+{
+  sw_sample * sample = inst->sample;
+  sw_perform_data * pd = (sw_perform_data *)inst->do_data;
+
+  SweepFilter func = (SweepFilter)pd->func;
+  sw_param_set pset = pd->pset;
+  void * custom_data = pd->custom_data;
+
+  sw_edit_buffer * old_eb;
+  paste_over_data * p;
+  sw_sample * out;
+
+  old_eb = edit_buffer_from_sample (sample);
+
+  p = paste_over_data_new (old_eb, old_eb);
+  inst->redo_data = inst->undo_data = p;
+  set_active_op (sample, inst);
+
+  out = func (sample, pset, custom_data);
+
+  /* XXX: this is all kinda assuming out == sample if out != NULL */
+  if (out != NULL && sample->edit_state == SWEEP_EDIT_STATE_BUSY) {
+    p->new_eb = edit_buffer_from_sample (sample);
+
+    register_operation (sample, inst);
+  }
+}
+
+static sw_operation filter_op = {
+  SWEEP_EDIT_MODE_FILTER,
+  (SweepCallback)do_filter_thread,
+  (SweepFunction)g_free,
+  (SweepCallback)undo_by_paste_over,
+  (SweepFunction)paste_over_data_destroy,
+  (SweepCallback)redo_by_paste_over,
+  (SweepFunction)paste_over_data_destroy
+};
+
+
+sw_op_instance *
+perform_filter_op (sw_sample * sample, char * desc, SweepFilter func,
+		   sw_param_set pset, gpointer custom_data)
+{
+  sw_perform_data * pd = (sw_perform_data *)g_malloc (sizeof(*pd));
+
+  pd->func = (SweepFunction)func;
+  pd->pset = pset;
+  pd->custom_data = custom_data;
+
+  schedule_operation (sample, desc, &filter_op, pd);
+
+  return NULL;
+}
diff --git a/code/train/C/0144921_remote_cid.c b/code/train/C/0144921_remote_cid.c
new file mode 100644
index 0000000000000000000000000000000000000000..31317d470c1476be11ca50472ea8a8b2edb5495a
--- /dev/null
+++ b/code/train/C/0144921_remote_cid.c
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) 2020 Fastly, Inc.
+ *
+ * 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 <assert.h>
+#include "quicly/constants.h"
+#include "quicly/remote_cid.h"
+
+void quicly_remote_cid_init_set(quicly_remote_cid_set_t *set, ptls_iovec_t *initial_cid, void (*random_bytes)(void *, size_t))
+{
+    set->cids[0] = (quicly_remote_cid_t){
+        .is_active = 1,
+        .sequence = 0,
+    };
+    if (initial_cid != NULL) {
+        quicly_set_cid(&set->cids[0].cid, *initial_cid);
+    } else {
+        random_bytes(set->cids[0].cid.cid, QUICLY_MIN_INITIAL_DCID_LEN);
+        set->cids[0].cid.len = QUICLY_MIN_INITIAL_DCID_LEN;
+    }
+    random_bytes(set->cids[0].stateless_reset_token, sizeof(set->cids[0].stateless_reset_token));
+
+    for (size_t i = 1; i < PTLS_ELEMENTSOF(set->cids); i++)
+        set->cids[i] = (quicly_remote_cid_t){
+            .is_active = 0,
+            .sequence = i,
+        };
+
+    set->_largest_sequence_expected = PTLS_ELEMENTSOF(set->cids) - 1;
+}
+
+/**
+ * promote CID at idx_to_promote as the current CID for communication
+ * i.e. swap cids[idx_to_promote] and cids[0]
+ */
+static void promote_cid(quicly_remote_cid_set_t *set, size_t idx_to_promote)
+{
+    uint64_t seq_tmp = set->cids[0].sequence;
+
+    assert(idx_to_promote > 0);
+    assert(!set->cids[0].is_active);
+
+    set->cids[0] = set->cids[idx_to_promote];
+    set->cids[idx_to_promote].is_active = 0;
+    set->cids[idx_to_promote].sequence = seq_tmp;
+}
+
+static int do_register(quicly_remote_cid_set_t *set, uint64_t sequence, const uint8_t *cid, size_t cid_len,
+                       const uint8_t srt[QUICLY_STATELESS_RESET_TOKEN_LEN])
+{
+    int was_stored = 0;
+
+    if (set->_largest_sequence_expected < sequence)
+        return QUICLY_TRANSPORT_ERROR_CONNECTION_ID_LIMIT;
+
+    for (size_t i = 0; i < PTLS_ELEMENTSOF(set->cids); i++) {
+        if (set->cids[i].is_active) {
+            /* compare newly received CID against what we already have, to see if there is duplication/conflicts */
+
+            /* If an endpoint receives a NEW_CONNECTION_ID frame that repeats a previously issued connection ID with
+             * a different Stateless Reset Token or a different sequence number, or if a sequence number is used for
+             * different connection IDs, the endpoint MAY treat that receipt as a connection error of type PROTOCOL_VIOLATION.
+             * (19.15)
+             */
+            if (quicly_cid_is_equal(&set->cids[i].cid, ptls_iovec_init(cid, cid_len))) {
+                if (set->cids[i].sequence == sequence &&
+                    memcmp(set->cids[i].stateless_reset_token, srt, QUICLY_STATELESS_RESET_TOKEN_LEN) == 0) {
+                    /* likely a duplicate due to retransmission */
+                    return 0;
+                } else {
+                    /* received a frame that carries conflicting information */
+                    return QUICLY_TRANSPORT_ERROR_PROTOCOL_VIOLATION;
+                }
+            }
+            /* here we know CID is not equal */
+            if (set->cids[i].sequence == sequence)
+                return QUICLY_TRANSPORT_ERROR_PROTOCOL_VIOLATION;
+        } else if (set->cids[i].sequence == sequence) {
+            assert(!was_stored);
+            set->cids[i].sequence = sequence;
+            quicly_set_cid(&set->cids[i].cid, ptls_iovec_init(cid, cid_len));
+            memcpy(set->cids[i].stateless_reset_token, srt, QUICLY_STATELESS_RESET_TOKEN_LEN);
+            set->cids[i].is_active = 1;
+            was_stored = 1;
+            if (i > 0 && !set->cids[0].is_active) {
+                /* promote this CID for communication */
+                promote_cid(set, i);
+            }
+        }
+    }
+
+    /* execution reaches here in two cases, 1) normal path, i.e. new CID was successfully registered, and 2) new CID was already
+     * retired (was_stored == 0). */
+    return 0;
+}
+
+static void do_unregister(quicly_remote_cid_set_t *set, size_t idx_to_unreg)
+{
+    assert(set->cids[idx_to_unreg].is_active);
+
+    set->cids[idx_to_unreg].is_active = 0;
+    set->cids[idx_to_unreg].sequence = ++set->_largest_sequence_expected;
+}
+
+int quicly_remote_cid_unregister(quicly_remote_cid_set_t *set, uint64_t sequence)
+{
+    uint64_t min_seq = UINT64_MAX;
+    size_t min_seq_idx = SIZE_MAX;
+    for (size_t i = 0; i < PTLS_ELEMENTSOF(set->cids); i++) {
+        if (sequence == set->cids[i].sequence) {
+            do_unregister(set, i);
+            if (i != 0)
+                return 0; /* if not retiring idx=0 (current in-use CID), simply return */
+        }
+        if (set->cids[i].is_active && min_seq > set->cids[i].sequence) {
+            /* find a CID with minimum sequence number, while iterating over the array */
+            min_seq = set->cids[i].sequence;
+            min_seq_idx = i;
+        }
+    }
+
+    if (!set->cids[0].is_active) {
+        /* we have retired the current CID (idx=0) */
+        if (min_seq_idx != SIZE_MAX)
+            promote_cid(set, min_seq_idx);
+        return 0;
+    } else {
+        /* we did not unregister any slot */
+        return 1;
+    }
+}
+
+static size_t unregister_prior_to(quicly_remote_cid_set_t *set, uint64_t seq_unreg_prior_to,
+                                  uint64_t unregistered_seqs[QUICLY_LOCAL_ACTIVE_CONNECTION_ID_LIMIT])
+{
+    uint64_t min_seq = UINT64_MAX, min_seq_idx = UINT64_MAX;
+    size_t num_unregistered = 0;
+    for (size_t i = 0; i < PTLS_ELEMENTSOF(set->cids); i++) {
+        if (set->cids[i].is_active) {
+            if (set->cids[i].sequence < seq_unreg_prior_to) {
+                unregistered_seqs[num_unregistered++] = set->cids[i].sequence;
+                do_unregister(set, i);
+                continue;
+            }
+            if (min_seq > set->cids[i].sequence) {
+                /* find a CID with minimum sequence number, while iterating over the array */
+                min_seq = set->cids[i].sequence;
+                min_seq_idx = i;
+            }
+        }
+    }
+
+    if (!set->cids[0].is_active) {
+        /* we have retired the current CID (idx=0) */
+        if (min_seq_idx != UINT64_MAX)
+            promote_cid(set, min_seq_idx);
+    }
+
+    return num_unregistered;
+}
+
+int quicly_remote_cid_register(quicly_remote_cid_set_t *set, uint64_t sequence, const uint8_t *cid, size_t cid_len,
+                               const uint8_t srt[QUICLY_STATELESS_RESET_TOKEN_LEN], uint64_t retire_prior_to,
+                               uint64_t unregistered_seqs[QUICLY_LOCAL_ACTIVE_CONNECTION_ID_LIMIT], size_t *num_unregistered_seqs)
+{
+    quicly_remote_cid_t backup_cid = set->cids[0]; // preserve one valid entry in cids[0] to handle protocol violation
+    int ret;
+
+    assert(sequence >= retire_prior_to);
+
+    /* First, handle retire_prior_to. This order is important as it is possible to receive a NEW_CONNECTION_ID frame such that it
+     * retires active_connection_id_limit CIDs and then installs one new CID. */
+    *num_unregistered_seqs = unregister_prior_to(set, retire_prior_to, unregistered_seqs);
+
+    /* Then, register given value. */
+    if ((ret = do_register(set, sequence, cid, cid_len, srt)) != 0) {
+        /* restore the backup and send the error */
+        if (!set->cids[0].is_active)
+            set->cids[0] = backup_cid;
+        return ret;
+    }
+
+    return ret;
+}
diff --git a/code/train/C/0144977_list.c b/code/train/C/0144977_list.c
new file mode 100644
index 0000000000000000000000000000000000000000..dd534fcca7d511086a811e43e1c20bf17d95bc15
--- /dev/null
+++ b/code/train/C/0144977_list.c
@@ -0,0 +1,412 @@
+/*
+  $Log: list.c,v $
+  Revision 1.5  2003/07/14 13:36:58  ivo
+  use vrna_alloc() instead of malloc
+
+  Revision 1.4  2000/10/10 08:53:52  ivo
+  include dmalloc.h header if DMALLOC defined
+
+  Revision 1.4  2000/10/10 08:04:34  ivo
+  include dmalloc header id DMALLOC defined
+
+  Revision 1.3  1998/03/30 14:24:51  ivo
+  use RNA package utils.h
+
+  Revision 1.2  1997/10/09  19:01:50  steve
+  *** empty log message ***
+
+  Revision 1.1  1997/08/04 21:05:32  walter
+  Initial revision
+
+*/
+/*
+   (C) 1991 Kendall Bennett.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "utils.h"
+#include "list.h"
+
+#define PUBLIC
+PUBLIC void *
+lst_newnode (int size)
+/****************************************************************************
+*
+* Function:	lst_newnode
+* Parameters:	size - Amount of memory to allocate for node
+* Returns:      Pointer to the allocated node's user space.
+*
+* Description:	Allocates the memory required for a node, adding a small
+*		header at the start of the node. We return a reference to
+*		the user space of the node, as if it had been allocated via
+*		malloc().
+*
+****************************************************************************/
+{
+  LST_BUCKET *node;
+
+  node = (LST_BUCKET *) vrna_alloc(size + sizeof (LST_BUCKET));
+
+  return LST_USERSPACE (node);	/* Return pointer to user space */
+}
+
+PUBLIC void
+lst_freenode (void *node)
+/****************************************************************************
+*
+* Function:	lst_freenode
+* Parameters:	node - Node to free.
+*
+* Description:  Frees a node previously allocated with lst_newnode().
+*
+****************************************************************************/
+{
+  free (LST_HEADER (node));
+}
+
+PUBLIC LIST *
+lst_init (void)
+/****************************************************************************
+*
+* Function:	lst_init
+* Returns:      Pointer to a newly created list.
+*
+* Description:	Initialises a list and returns a pointer to it.
+*
+****************************************************************************/
+{
+  LIST *l;
+
+  if ((l = (LIST *) vrna_alloc(sizeof (LIST))) != NULL)
+    {
+      l->count = 0;
+      l->head = &(l->hz[0]);
+      l->z = &(l->hz[1]);
+      l->head->next = l->z->next = l->z;
+    }
+
+  return l;
+}
+
+PUBLIC void
+lst_kill (LIST * l, void (*freeNode) (void *node))
+/****************************************************************************
+*
+* Function:	lst_kill
+* Parameters:	l - List to kill
+*		freeNode - Pointer to user routine to free a node
+*
+* Description:	Kills the list l, by deleting all of the elements contained
+*		within the list one by one and then deleting the list
+*		itself. Note that we call the user supplied routine
+*		(*freeNode)() to free each list node. This allows the user
+*		program to perform any extra processing needed to kill each
+*		node (if each node contains pointers to other items on the
+*		heap for example). If no extra processing is required, just
+*		pass the address of lst_freenode(), ie:
+*
+*		lst_kill(myList,lst_freenode);
+*
+****************************************************************************/
+{
+  LST_BUCKET *n, *p;
+
+  n = l->head->next;
+  while (n != l->z)
+    {				/* Free all nodes in list  */
+      p = n;
+      n = n->next;
+      (*freeNode) (LST_USERSPACE (p));
+    }
+  free (l);			/* Free the list itself    */
+}
+
+PUBLIC void
+lst_insertafter (LIST * l, void *node, void *after)
+/****************************************************************************
+*
+* Function:	lst_insertafter
+* Parameters:	l - List to insert node into
+*		node - Pointer to user space of node to insert
+*		after - Pointer to user space of node to insert node after
+*
+* Description:	Inserts a new node into the list after the node 'after'. To
+*		insert a new node at the beginning of the list, user the
+*		macro LST_HEAD in place of 'after'. ie:
+*
+*		lst_insertafter(mylist,node,LST_HEAD(mylist));
+*
+****************************************************************************/
+{
+  LST_BUCKET *n = LST_HEADER (node), *a = LST_HEADER (after);
+
+  n->next = a->next;
+  a->next = n;
+  l->count++;
+}
+
+PUBLIC void *
+lst_deletenext (LIST * l, void *node)
+/****************************************************************************
+*
+* Function:	lst_deletenext
+* Parameters:	l - List to delete node from.
+*		node - Node to delete the next node from
+* Returns:	Pointer to the deleted node's userspace.
+*
+* Description:	Removes the node AFTER 'node' from the list l.
+*
+****************************************************************************/
+{
+  LST_BUCKET *n = LST_HEADER (node);
+
+  node = LST_USERSPACE (n->next);
+  n->next = n->next->next;
+  l->count--;
+  return node;
+}
+
+PUBLIC void *
+lst_first (LIST * l)
+/****************************************************************************
+*
+* Function:	lst_first
+* Parameters:	l - List to obtain first node from
+* Returns:	Pointer to first node in list, NULL if list is empty.
+*
+* Description:	Returns a pointer to the user space of the first node in
+*		the list. If the list is empty, we return NULL.
+*
+****************************************************************************/
+{
+  LST_BUCKET *n;
+
+  n = l->head->next;
+  return (n == l->z ? NULL : LST_USERSPACE (n));
+}
+
+PUBLIC void *
+lst_next (void *prev)
+/****************************************************************************
+*
+* Function:	lst_next
+* Parameters:	prev - Previous node in list to obtain next node from
+* Returns:	Pointer to the next node in the list, NULL at end of list.
+*
+* Description:	Returns a pointer to the user space of the next node in the
+*		list given a pointer to the user space of the previous node.
+*		If we have reached the end of the list, we return NULL. The
+*		end of the list is detected when the next pointer of a node
+*		points back to itself, as does the dummy last node's next
+*		pointer. This enables us to detect the end of the list
+*		without needed access to the list data structure itself.
+*
+*		NOTE:	We do no checking to ensure that 'prev' is NOT a
+*			NULL pointer.
+*
+****************************************************************************/
+{
+  LST_BUCKET *n = LST_HEADER (prev);
+
+  n = n->next;
+  return (n == n->next ? NULL : LST_USERSPACE (n));
+}
+
+/* Static globals required by merge()   */
+
+static LST_BUCKET *z;
+static int (*cmp) (void *, void *);
+
+static LST_BUCKET *
+merge (LST_BUCKET * a, LST_BUCKET * b, LST_BUCKET ** end)
+/****************************************************************************
+*
+* Function:	merge
+* Parameters:	a,b - Sublist's to merge
+* Returns:	Pointer to the merged sublists.
+*
+* Description:	Merges two sorted lists of nodes together into a single
+*		sorted list.
+*
+****************************************************************************/
+{
+  LST_BUCKET *c;
+
+  /* Go through the lists, merging them together in sorted order  */
+
+  c = z;
+  while (a != z && b != z)
+    {
+      if ((*cmp) (LST_USERSPACE (a), LST_USERSPACE (b)) <= 0)
+	{
+	  c->next = a;
+	  c = a;
+	  a = a->next;
+	}
+      else
+	{
+	  c->next = b;
+	  c = b;
+	  b = b->next;
+	}
+    };
+
+  /* If one of the lists is not exhausted, then re-attach it to the end
+   * of the newly merged list
+   */
+
+  if (a != z)
+    c->next = a;
+  if (b != z)
+    c->next = b;
+
+  /* Set *end to point to the end of the newly merged list        */
+
+  while (c->next != z)
+    c = c->next;
+  *end = c;
+
+  /* Determine the start of the merged lists, and reset z to point to
+   * itself
+   */
+
+  c = z->next;
+  z->next = z;
+  return c;
+}
+
+PUBLIC void
+lst_mergesort (LIST * l, int (*cmp_func) (void *, void *))
+/****************************************************************************
+*
+* Function:	lst_mergesort
+* Parameters:	l - List to merge sort
+*		cmp_func - Function to compare two user spaces
+*
+* Description:	Mergesort's all the nodes in the list. 'cmp' must point to
+*		a comparison function that can compare the user spaces of
+*		two different nodes. 'cmp' should work the same as
+*		strcmp(), in terms of the values it returns.
+*
+****************************************************************************/
+{
+  int i, N;
+  LST_BUCKET *a, *b;		/* Pointers to sublists to merge                */
+  LST_BUCKET *c;		/* Pointer to end of sorted sublists            */
+  LST_BUCKET *head;		/* Pointer to dummy head node for list          */
+  LST_BUCKET *todo;		/* Pointer to sublists yet to be sorted         */
+  LST_BUCKET *t;		/* Temporary                                                            */
+
+  /* Set up globals required by merge() and pointer to head       */
+
+  z = l->z;
+  cmp = cmp_func;
+  head = l->head;
+
+  for (N = 1, a = z; a != head->next; N = N + N)
+    {
+      todo = head->next;
+      c = head;
+      while (todo != z)
+	{
+
+	  /* Build first sublist to be merged, and splice from main list
+	   */
+
+	  a = t = todo;
+	  for (i = 1; i < N; i++)
+	    t = t->next;
+	  b = t->next;
+	  t->next = z;
+	  t = b;
+
+	  /* Build second sublist to be merged and splice from main list
+	   */
+
+	  for (i = 1; i < N; i++)
+	    t = t->next;
+	  todo = t->next;
+	  t->next = z;
+
+	  /* Merge the two sublists created, and set 'c' to point to the
+	   * end of the newly merged sublists.
+	   */
+
+	  c->next = merge (a, b, &t);
+	  c = t;
+	}
+    }
+}
+
+#ifdef LIST_TEST
+
+/*---------------------------------------------------------------*/
+/*---------------------------------------------------------------*/
+
+/* Simple program to test the list routines */
+
+typedef struct
+{
+  char name[40];
+  int age;
+}
+REC;
+
+/*---------------------------------------------------------------*/
+
+int
+my_cmp (REC * r1, REC * r2)
+{
+  return strcmp (r1->name, r2->name);
+}
+
+/*---------------------------------------------------------------*/
+
+void
+main (void)
+{
+  LIST *list;
+  int done = 0;
+  REC *rec;
+  char line[80];
+
+  list = lst_init ();
+
+  printf ("Type a list of names and ages. Empty line quits\n\n");
+
+  while (!done)
+    {
+      rec = lst_newnode (sizeof (REC));
+      gets (line);
+      if ((done = (line[0] == '\0')) != 1)
+	{
+	  strcpy (rec->name, line);
+	  gets (line);
+	  rec->age = atoi (line);
+	  lst_insertafter (list, rec, LST_HEAD (list));
+	}
+    };
+
+  printf ("\nThe list you typed in was:\n\n");
+
+  for (rec = lst_first (list); rec; rec = lst_next (rec))
+    printf ("Name: %s, Age: %d\n", rec->name, rec->age);
+
+  printf ("\nSorting the list...\n\n");
+
+  lst_mergesort (list, my_cmp);
+
+  for (rec = lst_first (list); rec; rec = lst_next (rec))
+    printf ("Name: %s, Age: %d\n", rec->name, rec->age);
+
+  lst_kill (list, lst_freenode);
+}
+
+/*---------------------------------------------------------------*/
+
+#endif
diff --git a/code/train/C/0148010_navi.c b/code/train/C/0148010_navi.c
new file mode 100644
index 0000000000000000000000000000000000000000..40e7bdd590505d9ba540c49f6219ed238cc126af
--- /dev/null
+++ b/code/train/C/0148010_navi.c
@@ -0,0 +1,89 @@
+/* navi.c */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "navi.h"
+
+void dijkstra( int start, int end )
+{
+  struct edge *ptr;
+  int u, x;
+  int nex;
+  
+  node_dat[start].flag = 1;
+  for( ptr = list[start]; ptr != NULL; ptr = ptr->next )
+  
+  if( ptr->weight < node_dat[ptr->dst].dist ) {
+    node_dat[ptr->dst].dist = ptr->weight;
+    node_dat[ptr->dst].path = start;
+  }
+  
+  node_dat[start].dist = 0;
+  node_dat[start].path = EOP;
+  u = start;
+  while( u != end ) {
+    nex = INF;
+    for(x = 0; x < nodes; x++) {
+      if(node_dat[x].flag != 1 && nex > node_dat[x].dist ) {
+        nex =  node_dat[x].dist;
+        u   =  x;
+      }
+    }
+    
+    node_dat[u].flag = 1;
+    for( ptr = list[u]; ptr != NULL; ptr = ptr->next ) {
+      if( node_dat[ptr->dst].dist > node_dat[u].dist + ptr->weight ) {
+        node_dat[ptr->dst].dist = node_dat[u].dist + ptr->weight;
+        node_dat[ptr->dst].path = u;
+      }
+    }
+  }
+}
+
+void make_path( struct edge **ptr, int start, int end )
+{
+  struct edge *path, *tmp;
+  int min;
+  int i;
+  
+  *ptr = NULL;
+  insert_cell( ptr, end, 0, NULL);
+  for(i = end; node_dat[i].path != EOP; i = node_dat[i].path) {
+    min = INF;
+    for(path = list[i]; path != NULL; path = path->next) {
+      if( min > node_dat[path->dst].dist && node_dat[i].path == path->dst ) {
+        min = node_dat[path->dst].dist;
+        tmp = path;
+      }
+    }
+    if( insert_cell( ptr, tmp->dst, tmp->weight, tmp->line ) == -1)
+      return;
+  }  
+}
+
+int check_point(char *name)
+{
+  int i;
+  
+  for(i = 0; i < nodes; i++) {
+    if( strcmp(node_dat[i].name, name) == 0 )
+      return i;
+  }
+  
+  return INF;
+}
+
+void output(struct edge *path, int start, int end)
+{
+  struct edge *ptr, *tmp;
+  
+  printf("The shortest path from %s to %s\n", node_dat[start].name, node_dat[end].name);
+  
+  for( ptr = path; ptr->next != NULL; ptr = ptr->next ) {
+    tmp = ptr->next;
+    printf(" %17s -> %17s ", node_dat[ptr->dst].name, node_dat[tmp->dst].name);
+    printf("by %19s for %3d [min.]\n", ptr->line, ptr->weight);
+  }
+  
+  printf("Total time required ... %d[min.]\n", node_dat[ptr->dst].dist );
+}
diff --git a/code/train/C/0148185_ublas.c b/code/train/C/0148185_ublas.c
new file mode 100644
index 0000000000000000000000000000000000000000..de0ebc8d549542679b365aa042584ca7a7680cf6
--- /dev/null
+++ b/code/train/C/0148185_ublas.c
@@ -0,0 +1,184 @@
+#include <ublas.h>
+
+ublas_settings *_ub_settings;
+
+/*		UBLAS initialisation
+ *---------------------------------------------------------------------------*/
+void ublas_init(ublas_settings *settings) {
+	_ub_settings = settings;
+
+	settings->call = malloc(sizeof(func*)*UBL_COUNT);
+	settings->libctx = calloc(UBL_COUNT, sizeof(void*));
+
+#if defined(WITH_ATLAS)
+	settings->call[UBL_ATLAS] = ublas_load_driver("/panfs/panasas01/cosc/db0763/ublas/build/src/drivers/atlas/libublas-driver-atlas.so");
+	settings->call[UBL_ATLAS][UBF_INIT](&settings->libctx[UBL_ATLAS]);
+#endif
+#if defined(WITH_CUBLAS)
+	settings->call[UBL_CUBLAS] = ublas_load_driver("/panfs/panasas01/cosc/db0763/ublas/build/src/drivers/cublas/libublas-driver-cublas.so"); 
+	settings->call[UBL_CUBLAS][UBF_INIT](&settings->libctx[UBL_CUBLAS]);
+#endif
+#if defined(WITH_MKL)
+	settings->call[UBL_MKL] = ublas_load_driver("/panfs/panasas01/cosc/db0763/ublas/build/src/drivers/mkl/libublas-driver-mkl.so");
+	settings->call[UBL_MKL][UBF_INIT](&settings->libctx[UBL_MKL]);
+#endif
+#if defined(WITH_PLASMA)
+	settings->call[UBL_PLASMA] = ublas_load_driver("/panfs/panasas01/cosc/db0763/ublas/build/src/drivers/plasma/libublas-driver-plasma.so");
+	settings->call[UBL_PLASMA][UBF_INIT](&settings->libctx[UBL_PLASMA]);
+#endif
+
+	settings->ann = fann_create_from_file("/panfs/panasas01/cosc/db0763/ublas/neural.net");
+}
+
+/*		UBLAS clean up
+ *---------------------------------------------------------------------------*/
+void ublas_free() {
+	ublas_settings *settings = _ub_settings;
+
+#if defined(WITH_ATLAS)
+	settings->call[UBL_ATLAS][UBF_FREE](&settings->libctx[UBL_ATLAS]);
+#endif
+#if defined(WITH_CUBLAS)
+	settings->call[UBL_CUBLAS][UBF_FREE](&settings->libctx[UBL_CUBLAS]);
+#endif
+#if defined(WITH_MKL)
+	settings->call[UBL_MKL][UBF_FREE](&settings->libctx[UBL_MKL]);
+#endif
+#if defined(WITH_PLASMA)
+	settings->call[UBL_PLASMA][UBF_FREE](&settings->libctx[UBL_PLASMA]);
+#endif
+
+	// // free the driver context table
+	// for (int i=1; i<UBL_COUNT; i++) {
+	// 	free(settings->libctx[i]);
+	// }
+	// free(settings->libctx);
+
+	// // free the call table
+	// for (int i=1; i<(int)UBL_COUNT; i++) {
+	// 	for (int j=0; j<(int)UBF_COUNT; j++) {
+	// 		// free(settings->call[i][j]);
+	// 	}
+	// 	free(settings->call[i]);
+	// }
+}
+
+/******************************************************************************
+ *	BLAS		Level 3
+ *****************************************************************************/
+
+/*		GEMM
+ *---------------------------------------------------------------------------*/
+int ublas_gemm(ublas_matrix *a, ublas_matrix *b, ublas_matrix *c,
+		double alpha, double beta) {
+
+	if (a->cols != b->rows && a->rows != c->rows && b->cols != c->cols)
+		return (int)E_MISSMATCH_DIMENSIONS;
+	if (a->type != b->type && b->type != c->type)
+		return (int)E_MISSMATCH_TYPES;
+
+	int info, reset = 0, oops = 1;
+
+	if (_ub_settings->library == UBL_AUTO) {
+		reset = 1;
+		float input[3] = {c->cols, c->rows, a->cols};
+		_ub_settings->library = ublas_query_ann(input, 3);
+	}
+
+#if defined(WITH_ATLAS)
+	if (_ub_settings->library == UBL_ATLAS) {
+    	_ub_settings->call[UBL_ATLAS][UBF_GEMM](_ub_settings->libctx[UBL_ATLAS], a, b, c, alpha, beta);
+    	oops = 0;
+	}
+#endif
+#if defined(WITH_CUBLAS)
+	else if (_ub_settings->library == UBL_CUBLAS) {
+    	_ub_settings->call[UBL_CUBLAS][UBF_GEMM](_ub_settings->libctx[UBL_CUBLAS], a, b, c, alpha, beta);
+    	oops = 0;
+	}
+#endif
+#if defined(WITH_MKL)
+    else if (_ub_settings->library == UBL_MKL) {
+    	_ub_settings->call[UBL_MKL][UBF_GEMM](_ub_settings->libctx[UBL_MKL], a, b, c, alpha, beta);
+    	oops = 0;
+    }
+#endif
+#if defined(WITH_PLASMA)
+	else if (_ub_settings->library == UBL_PLASMA) {
+    	_ub_settings->call[UBL_PLASMA][UBF_GEMM](_ub_settings->libctx[UBL_PLASMA], a, b, c, alpha, beta);
+    	oops = 0;
+	}
+#endif
+
+	if (reset)
+		_ub_settings->library = UBL_AUTO;
+
+	if (oops > 0)
+		printf("FAILED TO USE A BLAS LIBRARY!!! WTF\n");
+	
+	return 0;
+}
+
+/*		Query ANN
+ * query the artificial neural network with some given inputs and get the
+ * library it would select for use.
+ *---------------------------------------------------------------------------*/
+ublas_library ublas_query_ann(float *input, size_t len) {
+	float prod = 1;
+	for (int i=0; i<len; ++i)
+		prod *= input[i];
+
+	if (prod < UBLAS_HEURISTIC_THRESHOLD) {
+		// if we are below some threshold where there is no point in using the
+		// neural network
+		return UBLAS_SMALL_MATRIX_LIB;
+	} else {
+		// otherwise use the neural network
+		ublas_library libbest = UBLAS_DEFAULT_LIB;
+		float out_best = -2.0f;
+
+		float *out = fann_run(_ub_settings->ann, input);
+		for (int i=1; i<(int)UBL_COUNT; i++) {
+			if (out[i-1] >= out_best) {
+				libbest = (ublas_library)i;
+				out_best = out[i-1];
+			}
+		}
+		return libbest;
+	}
+}
+
+/*		Fastest Floats
+ * returns the library with the fastest time in an array of floats representing
+ * execution time.
+ *---------------------------------------------------------------------------*/
+ublas_library ublas_ffastest(float *times) {
+	ublas_library libbest = UBL_AUTO;
+	float t_best = FLT_MAX;
+
+	for (int i=1; i<(int)UBL_COUNT; i++) {
+		if (times[i-1] < t_best) {
+			libbest = (ublas_library)i;
+			t_best = times[i-1];
+		}
+	}
+
+	return libbest;
+}
+
+/*		Fastest Floats
+ * returns the library with the fastest time in an array of doubles
+ * representing execution time.
+ *---------------------------------------------------------------------------*/
+ublas_library ublas_dfastest(double *times) {
+	ublas_library libbest = UBL_AUTO;
+	double t_best = DBL_MAX;
+
+	for (int i=1; i<(int)UBL_COUNT; i++)
+		if (times[i-1] < t_best) {
+			libbest = (ublas_library)i;
+			t_best = times[i-1];
+		}
+
+	return libbest;
+}
diff --git a/code/train/C/0148297_06.c b/code/train/C/0148297_06.c
new file mode 100644
index 0000000000000000000000000000000000000000..66656e50b1f32a4ff47d745954d65ac7d92143ea
--- /dev/null
+++ b/code/train/C/0148297_06.c
@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+
+int fuck[26];
+
+int is_prime (int shit) {
+	int i;
+	if ( !shit || shit == 1 ) return 0;
+	for ( i = 2; i < sqrt(shit); i++ ) {
+		if ( !( shit % i )) return 0;
+	}
+	return 1;
+}
+
+int main (int argc, char *args[]) {
+	char fucking[101];
+	int i, max = -1, min = 0xFFF;
+	scanf("%s", fucking);
+	for ( i = 0; i < strlen(fucking); ++i ) {
+		fuck[fucking[i] - 'a']++;
+	}
+//	for ( int j = 0; j < 26; ++j ) {
+//		printf("%c = %i\n", j + 'a', fuck[j]);
+//	}
+	for ( i = 0; i < 26; ++i ) {
+		if ( fuck[i] > max ) {
+			max = fuck[i];
+		}
+		if ( fuck[i] && fuck[i] < min ) {
+			min = fuck[i];
+		}
+	}
+	if ( is_prime(max - min)) {
+		printf("Lucky Word\n%i", max - min);
+	} else {
+		printf("No Answer\n0");
+	}
+	return 0;
+}
\ No newline at end of file
diff --git a/code/train/C/0148320_integrate.c b/code/train/C/0148320_integrate.c
new file mode 100644
index 0000000000000000000000000000000000000000..7ce9963824fb2da490a73d6e0e1dc4327bc90630
--- /dev/null
+++ b/code/train/C/0148320_integrate.c
@@ -0,0 +1,302 @@
+#include<stdio.h>
+#include<math.h>
+#include<string.h>
+#include<stdlib.h>
+
+/* Include Ian Bush's timing routines */
+#include<timer.h>
+
+/* Include OpenMP library routines */
+#include<omp.h>
+
+/* The constant M_PI isn't included in the C89 standard, so we define it here - checking first
+to see if it has already been defined (in case the code is compiled with a different C standard */
+#ifndef M_PI
+#    define M_PI 3.1415926535897931
+#endif
+
+
+/* We define these named constants to make it easier to state whether we want timing info
+printed from the integrate() function.*/
+#define PRINT_TIMES 1
+#define NO_PRINT_TIMES 0
+
+/* Calculate the first function given on the specification sheet */
+double f1(double x)
+{
+	double res;
+	
+	res = 5*pow(x, 3) + 4 * pow(x, 2) + 3*x + 2;
+	
+	return res;
+}
+
+/* Calculate the second function given on the specification sheet */
+double f2(double x)
+{
+	double res;
+	
+	res = sin(x);
+	
+	return res;
+}
+
+/* Calculate the third function given on the specification sheet */
+double f3(double x)
+{
+	double res;
+	
+	if (x <= 0)
+	{
+		res = x;
+	}
+	else
+	{
+		res = sin(x);
+	}
+	
+	return res;
+}
+
+/* This function does the actual integration
+*fn			A pointer to a function to intergrate
+a			The lower limit for integration
+b			The upper limit for integration
+n			The number of trapezia to use for integration
+t			The number of threads to use (given as an argument so that tests can easily be carried out)
+print_times	Takes a #define'd constant of either PRINT_TIMES or NO_PRINT_TIMES to specify whether timing
+			information should be printed or not
+*/
+double integrate( double (*fn)(double), double a, double b, int n, int t, int print_times)
+{	
+	/* Declare variables
+	(All are initialised to zero as C variables will otherwise be initialised to
+	whatever happens to be in that memory location) */
+	
+	double tstart = 0; /* The starting time */
+	double tend = 0; /* The ending time */
+	
+	double h = 0; /* The x-step value */
+	double curr_x = 0; /* The current x value used in the loop */
+	double sum = 0; /* Used to hold the sum as we go from i = a to b in steps of h */
+	int i; /* The integer loop variable */
+	
+	/* Record the start time */
+	tstart = timer();
+	
+	/* Calculate h (the distance between each x value) given n (the number of bits to split the
+	input range into*/
+	h = (b - a) / (double) n;
+
+
+	/* Start a parallel region using the number of threads set by the parameter t
+	The region will only be run in parallel if n is greater than 1300
+	The loop variable and curr_x variable are private to each thread, all others are shared */
+	#pragma omp parallel num_threads(t), default(none), private(i, curr_x), shared(h, a, b, fn, n, sum) if(n>1300)
+	
+	/* Go from a to b in steps of h and stop when we get to b
+	We do this using a standard integer loop, and then calculating what x value
+	we are at inside the loop. This means that the loop variable is an int, which is
+	more efficient. */
+	
+	/* Parallelize this loop - splitting the iterations between threads
+	Each thread will calculate its own sum, at the end add all of these sub-sums together and store
+	it in the variable sum.
+	Split the iterations equally between the threads, and do all of the splitting at the beginning. */
+	#pragma omp for reduction(+:sum) schedule(static)
+	for (i = 0; i < n; i++)
+	{
+		curr_x = a + i * h;
+		/* Calculate the equation given on the Coursework 1 instruction sheet */
+		sum += h * ( ( (*fn)(curr_x) + (*fn)(curr_x - h) ) / 2);
+	}
+	
+	/* Record the end time */
+	tend = timer();
+	
+	/* Print the value of n (number of steps), t (number of threads), and the time taken in CSV
+	format ready to be redirected to a CSV file from the command line */
+	if (print_times == PRINT_TIMES)
+	{
+		printf("%d, %d, %f\n", n, t, tend-tstart);
+	}
+	
+	/* Return the final calculated value of the integral */
+	return sum;
+}
+
+/* Integrate a function using the adaptive scheme discussed in the report
+*fn			A pointer to a function to intergrate
+a			The lower limit for integration
+b			The upper limit for integration
+start_n 	The number of trapezia to use for the first integration
+epsilon		The accuracy required for the final result
+n_factor	The factor to change n by each iteration (new_n = n * n_factor)
+t			The number of threads to use (given as an argument so that tests can easily be carried out)
+*/
+double adaptive_integrate(double (*fn)(double), double a, double b, int start_n, double epsilon, int n_factor, int t)
+{
+	double prev_res = 0; /* The previous result, initialised to zero */
+	double curr_res = 0; /* The current result, initialised to zero */
+	double diff = 10000; /* The difference - initialised to a large number */
+	int n = start_n; /* The current n value to use - initialised to the user-specified start value */
+	
+	double tstart = 0; /* The starting time */
+	double tend = 0; /* The ending time */
+	
+	/* Record the start time */
+	tstart = timer();
+	
+	/* While the difference between the last two integrations is larger than the user-specified
+	accuracy (epsilon) */
+	while (diff > epsilon)
+	{
+		/* Record the current result */
+		prev_res = curr_res;
+		
+		/* Run the integration (telling it not to print any timing information */
+		curr_res = integrate((*fn), a, b, n, t, NO_PRINT_TIMES);
+		printf("Integrating with n = %d\n\tResult = %f\n", n, curr_res);
+		
+		/* Compute the next n value */
+		n = n * n_factor;
+		
+		/* Get the absolute difference between the previous two integrations */
+		diff = fabs(prev_res - curr_res);
+		
+		printf("\tDifference between previous results = %f\n", diff);
+	}
+	
+	printf("Difference is less than epsilon. Stopping.\n");
+	printf("Final result = %f\n", curr_res);
+	
+	/* Record the end time */
+	tend = timer();
+	
+	printf("Time taken = %f seconds\n", tend-tstart);
+	
+	return curr_res;
+}
+
+/* Test the adaptive integration scheme */
+void run_adaptive_test(void)
+{
+	adaptive_integrate((double (*)(double))f1, -1, 3, 10, 0.0001, 10, 8);
+}
+
+/* Integrate all of the test functions and display the results */
+void run_all(void)
+{
+	printf("Using n = 1000\n");
+	printf("Integral of f1 = %f\n", integrate((double (*)(double))f1, -1, 3, 10000, 8, NO_PRINT_TIMES));
+	printf("Integral of f2 = %f\n", integrate((double (*)(double))f2, 0, 2 * M_PI, 10000, 8, NO_PRINT_TIMES));
+	printf("Integral of f3 = %f\n", integrate((double (*)(double))f3, -1 * M_PI, M_PI, 10000, 8, NO_PRINT_TIMES));
+}
+
+/* Run the test to calculate what value of n should be used in the omp parallel if statement */
+void run_n_test(void)
+{
+	double res;
+	
+	int i;
+	
+	for (i = 0; i <= 50000; i+=100)
+	{
+		res = integrate((double (*)(double))f3, -1 * M_PI, M_PI, i, 1, PRINT_TIMES);
+		res = integrate((double (*)(double))f3, -1 * M_PI, M_PI, i, 8, PRINT_TIMES);
+	}
+}
+
+/* Run a test to produce the data used for the scaling graphs */
+void run_scaling_test(void)
+{
+	int n = 100000; /* Set n to a large number */
+	int i;
+	for (i = 1; i <= 8; i++)
+	{
+		integrate((double (*)(double))f1, -1, 3, n, i, PRINT_TIMES);
+		integrate((double (*)(double))f2, 0, 2 * M_PI, n, i, PRINT_TIMES);
+		integrate((double (*)(double))f3, -1 * M_PI, M_PI, n, i, PRINT_TIMES);
+	}
+}
+
+/* Run a simple test to calculate the difference between the numerical integration results and
+analytical results */
+void run_unit_test(void)
+{
+	/* Use a large n to get values as accurate as possible */
+	int n = 1000000;
+	
+	/* Define the variables for the CALCulated values of the integrals
+	and the ANALytical values (derived from Mathematica) */
+	double calc_res1, calc_res2, calc_res3 = 0;
+	double anal_res1, anal_res2, anal_res3 = 0;
+	
+	/* For each of the functions, integrate it and store the result and put the analytical result
+	in a variable too */
+	
+	calc_res1 = integrate((double (*)(double))f1, -1, 3, n, 8, NO_PRINT_TIMES);
+	anal_res1 = 472 / (double) 3;	
+	
+	calc_res2 = integrate((double (*)(double))f2, 0, 2 * M_PI, n, 8, NO_PRINT_TIMES);
+	anal_res2 = 0.0;
+	
+	calc_res3 = integrate((double (*)(double))f3, -1 * M_PI, M_PI, n, 8, NO_PRINT_TIMES);
+	anal_res3 = 2 - (pow(M_PI,2) / 2);
+	
+	/* Print the results */
+	printf("Function 1 difference: %f\n", calc_res1 - anal_res1);
+	printf("Function 2 difference: %f\n", calc_res2 - anal_res2);
+	printf("Function 3 difference: %f\n", calc_res3 - anal_res3);
+}
+
+/* The main function */
+int main(int argc, char *argv[])
+{
+	/* Define a single int loop variable */
+	int i;
+	
+	/* If no command-line arguments have been specified then display the help text below */
+	if (argc == 1)
+	{
+	printf("SESG6028 Integration Coursework by Robin Wilson\n \
+	----------------------------------------------- \
+	\nThe following options are available:\n \
+	full\t\tRun test of all functions given on coursework sheet\n \
+	unittest\tRuns a simple test to ensure that the functions are giving the right results\n \
+	ntest\t\tRun a test to see what value of n should be used as the if threshold\n \
+	scalingtest\tRun a test to determine the scaling of the code\n \
+	adaptivetest\tRuns a test of the adaptive integration system\n");
+    }
+    
+
+	/* Process command line arguments checking them and running the appropriate function */
+	for (i = 1; i < argc; i++)  /* Skip argv[0] (program name). */
+    {
+    	/* if strcmp returns 0 then the strings are identical */
+        if (strcmp(argv[i], "full") == 0)
+        {
+            run_all();
+        }
+        else if (strcmp(argv[i], "ntest") == 0)
+        {
+            run_n_test();
+        }
+        else if (strcmp(argv[i], "scalingtest") == 0)
+        {
+            run_scaling_test();
+        }
+        else if (strcmp(argv[i], "unittest") == 0)
+        {
+            run_unit_test();
+        }
+        else if (strcmp(argv[i], "adaptivetest") == 0)
+        {
+        	run_adaptive_test();
+        }
+
+    }	
+
+	/* Return success regardless */
+	return 0;
+}
\ No newline at end of file
diff --git a/code/train/C/0148373_main.c b/code/train/C/0148373_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..a9a19f34c5dac606d74ca338c90c78ca9c7dbffb
--- /dev/null
+++ b/code/train/C/0148373_main.c
@@ -0,0 +1,243 @@
+/**
+ *
+ * Simple MODE Device Controller
+ * 
+ * This is a demonstration of how a WICED device uses the MODE client library
+ * to communicate with the MODE cloud.
+ * 
+ * Before building and running this code, you should have already created a
+ * project on the MODE Developer Console, created a device class and added
+ * a device instance. Use the ID and API Key assigned to the device as the
+ * values for the global variables mode_device_id and mode_api_key
+ * respectively.
+ *
+ * This program does the following:
+ *   - Use the mode_start_listener() function to start a thread that handles
+ *     incoming JSON commands to control the GPIO output for LED1.
+ *     + The command {"action": "change", "parameters": {"switch": 1}} will
+ *       turn on the LED.
+ *     + The command {"action": "change", "parameters": {"switch": 0}} will
+ *       turn off the LED.
+ *   - Start a thread to monitor states of GPIO input from BUTTON1 and BUTTON2.
+ *     + If BUTTON1 is pressed, the mode_trigger_event() function is called.
+ *     + If BUTTON2 is pressed, the "claim mode" is toggled by the mode_enable_claim_mode()
+ *       and mode_disable_claim_mode() functions.
+ *
+ * Once your device is up and running, you can go to the MODE Developer Console,
+ * set up an app, and launch the App Simulator. Using the simulator, you can
+ * interact with the device such as sending the LED commands described above,
+ * or observe the events triggered by the GPIO button.
+ *
+ */
+
+
+#include <stdlib.h>
+#include "wiced.h"
+#include "platform.h"
+#include "mode.h"
+#include "JSON.h"
+
+static wiced_thread_t gpio_thread;
+static char mode_device_id[] = "** Put device ID assigned to device here **";
+static char mode_api_key[] = "** Put API key assigned to device here **";
+
+typedef struct {
+	char *name;
+	uint32_t id;
+} button_event_t;
+
+static struct {
+	wiced_bool_t ok;
+	wiced_bool_t value_ok;
+	uint8_t value;
+} led_command;
+
+static struct {
+	wiced_mutex_t mutex;
+	wiced_bool_t enabled;
+} claim_mode;
+
+static wiced_result_t send_mode_event(void *arg) {
+	button_event_t *btn_event = (button_event_t *)arg;
+	uint32_t resp_code;
+	char event_json[128];
+	wiced_result_t ret;
+
+	snprintf(event_json, sizeof(event_json),
+        "{\"eventType\":\"%s\",\"eventData\":{\"button\":%u}}",
+        btn_event->name, (unsigned int)btn_event->id);
+    
+    ret = mode_trigger_event(mode_device_id, mode_api_key, event_json, &resp_code);
+
+    if (ret == WICED_SUCCESS) {
+    	WPRINT_APP_INFO( ("MODE event DONE\n") );
+    }
+    else {
+    	WPRINT_APP_INFO( ("MODE event FAILED (err=%u, resp_code=%u)\n", ret, (unsigned int)resp_code) );
+    }
+
+    return ret;
+}
+
+static wiced_result_t toggle_claim_mode(void *arg) {
+	wiced_result_t ret;
+	uint32_t resp_code;
+	UNUSED_VARIABLE(arg);
+
+	ret = wiced_rtos_lock_mutex(&(claim_mode.mutex));
+	if (ret != WICED_SUCCESS) {
+		WPRINT_APP_INFO( ("Failed to acquire mutex lock on claim mode (err=%u)\n", ret) );
+		return ret;
+	}
+
+	if (claim_mode.enabled) {
+		/* Claim mode was enabled; disable it now. */
+		WPRINT_APP_INFO(("Disabling claim mode...\n"));
+		ret = mode_disable_claim_mode(mode_device_id, mode_api_key, &resp_code);
+	}
+	else {
+		/* Claim mode was disabled; enable it for 5 minutes. */
+		WPRINT_APP_INFO(("Enabling claim mode...\n"));
+		ret = mode_enable_claim_mode(mode_device_id, mode_api_key, 300, &resp_code);
+	}
+
+	if (ret == WICED_SUCCESS) {
+		WPRINT_APP_INFO( ("Claim mode toggle DONE\n") );
+		claim_mode.enabled = !claim_mode.enabled;
+	}
+	else {
+		WPRINT_APP_INFO( ("Claim mode toggle FAILED (err=%u, resp_code=%u)\n", ret, (unsigned int)resp_code) );
+	}
+
+	wiced_rtos_unlock_mutex(&(claim_mode.mutex));
+	return ret;
+}
+
+static void gpio_thread_main(uint32_t arg) {
+	wiced_result_t ret;
+	wiced_bool_t btn1_prev_state = WICED_TRUE, btn1_curr_state = WICED_TRUE;
+	wiced_bool_t btn2_prev_state = WICED_TRUE, btn2_curr_state = WICED_TRUE;
+	button_event_t btn_event;
+
+	WPRINT_APP_INFO(("GPIO thread started.\n"));
+
+	btn_event.name = "click";
+	btn_event.id = 1;
+
+	while (WICED_TRUE) {
+		/* Check BUTTON1 */
+		btn1_prev_state = btn1_curr_state;
+		btn1_curr_state = wiced_gpio_input_get(WICED_BUTTON1);
+
+		/* send event on button release */
+		if (!btn1_prev_state && btn1_curr_state) {
+			ret = wiced_rtos_send_asynchronous_event(WICED_NETWORKING_WORKER_THREAD, send_mode_event, (void *)&btn_event);
+			if (ret != WICED_SUCCESS) {
+				WPRINT_APP_INFO(("Failed to send async event (err=%u)\n", ret));
+			}
+		}
+
+		/* Check BUTTON2 */
+		btn2_prev_state = btn2_curr_state;
+		btn2_curr_state = wiced_gpio_input_get(WICED_BUTTON2);
+
+		/* send event on button release */
+		if (!btn2_prev_state && btn2_curr_state) {
+			ret = wiced_rtos_send_asynchronous_event(WICED_NETWORKING_WORKER_THREAD, toggle_claim_mode, NULL);
+			if (ret != WICED_SUCCESS) {
+				WPRINT_APP_INFO(("Failed to send async event (err=%u)\n", ret));
+			}
+		}
+
+		wiced_rtos_delay_milliseconds(250);
+	}
+}
+
+static wiced_result_t handle_json_obj(wiced_json_object_t *obj) {
+	char name[128];
+	char value[256];
+	uint32_t len;
+
+	len = MIN(sizeof(name) - 1, obj->object_string_length);
+	memcpy(name, obj->object_string, len);
+	name[len] = '\0';
+
+	len = MIN(sizeof(value) - 1, obj->value_length);
+	memcpy(value, obj->value, len);
+	value[len] = '\0';
+
+	if (strcmp(name, "action") == 0) {
+		if (obj->value_type == JSON_STRING_TYPE && strcmp(value, "change") == 0) {
+			led_command.ok = WICED_TRUE;
+		}
+	}
+	else if (strcmp(name, "switch") == 0) {
+		if (obj->value_type == JSON_NUMBER_TYPE) {
+			led_command.value = (uint8_t)atoi(value);
+			led_command.value_ok = WICED_TRUE;
+		}
+	}
+
+	return WICED_SUCCESS;
+}
+
+static wiced_result_t handle_mode_command(const char *cmd_json_str, uint32_t length) {
+	wiced_result_t ret = WICED_ERROR;
+
+	led_command.ok = WICED_FALSE;
+	led_command.value_ok = WICED_FALSE;
+
+	wiced_JSON_parser_register_callback(handle_json_obj);
+
+	ret = wiced_JSON_parser(cmd_json_str, length);
+	if (ret != WICED_SUCCESS) {
+		WPRINT_APP_INFO( ("Failed to parse command JSON string (err=%u)\n", ret) );
+		return ret;
+	}
+
+	if (led_command.ok && led_command.value_ok) {
+		if (led_command.value > 0) {
+			WPRINT_APP_INFO( ("Received command to set LED1 to HIGH\n") );
+			ret = wiced_gpio_output_high(WICED_LED1);
+		}
+		else {
+			WPRINT_APP_INFO( ("Received command to set LED1 to LOW\n") );
+			ret = wiced_gpio_output_low(WICED_LED1);
+		}
+	}
+	else {
+		WPRINT_APP_INFO( ("Received unrecognized command.\n") );
+	}
+
+	return ret;
+}
+
+void application_start(void)
+{
+	wiced_result_t ret;
+
+  wiced_init();
+  wiced_network_up(WICED_STA_INTERFACE, WICED_USE_EXTERNAL_DHCP_SERVER, NULL);
+
+  ret = mode_init();
+  if (ret != WICED_SUCCESS) {
+    WPRINT_APP_INFO( ("Failed to initialize MODE library (err=%u)\n", ret) );
+    return;
+  }
+
+  /* Initialize claim mode. */
+  wiced_rtos_init_mutex(&(claim_mode.mutex));
+  claim_mode.enabled = WICED_FALSE;
+
+  ret = wiced_rtos_create_thread(&gpio_thread, WICED_APPLICATION_PRIORITY, "gpio thread", gpio_thread_main, WICED_DEFAULT_APPLICATION_STACK_SIZE, NULL);
+  if (ret != WICED_SUCCESS) {
+    WPRINT_APP_INFO( ("Failed to create thread (err=%u)\n", ret) );
+  }
+
+  wiced_rtos_delay_milliseconds(3000);
+
+  ret = mode_start_listener(mode_device_id, mode_api_key, handle_mode_command);
+  if (ret != WICED_SUCCESS) {
+    WPRINT_APP_INFO( ("Failed to start listener (err=%u)\n", ret));
+  }
+}
diff --git a/code/train/C/0148470_heap.c b/code/train/C/0148470_heap.c
new file mode 100644
index 0000000000000000000000000000000000000000..973eca7adb4271049b83483bf00f36c20e191739
--- /dev/null
+++ b/code/train/C/0148470_heap.c
@@ -0,0 +1,149 @@
+//---------------------------------------------------------------------------
+// FunkOS - Copyright (c) 2009, Funkenstein Software, See license.txt for details
+//--------------------------------------------------------------------------- 
+/*!
+	\file:  heap.c
+	
+	Description:
+		Static block-size heap implementation
+*/
+
+#include "types.h"
+#include "heap.h"
+#include "protect.h"
+
+//---------------------------------------------------------------------------
+static const HEAP_INIT_STRUCT astHeapInit[NUM_BLOCK_SIZES] = 
+{
+	{NUM_BLOCK_1, ELEMENT_SIZE_1},
+	{NUM_BLOCK_2, ELEMENT_SIZE_2},
+	{NUM_BLOCK_3, ELEMENT_SIZE_3},
+	{NUM_BLOCK_4, ELEMENT_SIZE_4},
+	{NUM_BLOCK_5, ELEMENT_SIZE_5}
+};
+//---------------------------------------------------------------------------
+static HEAP_STRUCT stHeap;
+
+//---------------------------------------------------------------------------
+/*!
+	Initializes each heap block header  and zeros out the memory pool used
+	for dynamic memory allocation.
+	\fn void Heap_Init(void)
+*/
+void Heap_Init(void)
+{
+	USHORT i, j;
+	USHORT usBlockOffset = 0;
+	USHORT usHeapBlock = 0;
+	
+	// For each size group in the table
+	for (i = 0; i < NUM_BLOCK_SIZES; i++)
+	{
+		// For each element in the size group
+		for (j = 0; j < astHeapInit[i].usNumBlocks; j++)
+		{
+			// Set up the heap variables
+			stHeap.astHeapElements[usHeapBlock].usSize = astHeapInit[i].usBlockSize;
+			stHeap.astHeapElements[usHeapBlock].usOffset = usBlockOffset; 
+			stHeap.astHeapElements[usHeapBlock].bInUse = FALSE;
+			
+			// Update the block offset
+			usBlockOffset += astHeapInit[i].usBlockSize;
+			usHeapBlock++;
+		}
+	}
+	
+	// Clear the heap
+	for (i = 0; i < HEAP_SIZE_BYTES; i++)
+	{
+		stHeap.aucPool[i] = 0;
+	}
+}
+//---------------------------------------------------------------------------
+/*!
+	Allocates a single block of memory from the heap based on the required 
+	size (if one is available).
+	\fn UCHAR *Heap_Alloc(USHORT usSize_)
+	\param usSize_ - the size of the block to allocate
+	\return pointer to the block of newly-allocated memory, or NULL on failure
+*/
+UCHAR *Heap_Alloc(USHORT usSize_)
+{
+	USHORT i;
+	BOOL bDone = FALSE;
+	UCHAR *pucReturn = NULL;
+	
+	// Try to allocate the smallest possible block
+	for(i = 0; i < HEAP_NUM_ELEMENTS; i++)
+	{
+		if (stHeap.astHeapElements[i].usSize > usSize_)
+		{
+			CS_ENTER();
+			if (stHeap.astHeapElements[i].bInUse == FALSE)
+			{
+				// Found smallest suitable block that isn't in use.
+				
+				// Set the in-use flag to true
+				stHeap.astHeapElements[i].bInUse = TRUE;
+				// Set the return value
+				pucReturn = &(stHeap.aucPool[stHeap.astHeapElements[i].usOffset]);
+				// Found something, bail.
+				bDone = TRUE;
+			}
+			CS_EXIT();
+
+			// break on success.
+			if (bDone)
+			{
+				break;
+			}
+		}
+	}
+	
+	// Return the address of the 
+	return pucReturn;
+}
+
+//---------------------------------------------------------------------------
+/*!
+	De-allocates a previously allocated block of memory based on the address
+	given.
+	\fn void Heap_Free(void *pvData_)
+	\param pvData_ - pointer to the previously-allocated memory block
+*/
+void Heap_Free(void *pvData_)
+{
+	USHORT i;
+	BOOL bDone = FALSE;
+	UCHAR *pucData = NULL;
+	UCHAR *pucTemp = NULL;
+	
+	// Set the UCHAR* version of the input void parameter
+	pucData = (UCHAR*)pvData_;
+	
+	// Go through the whole list trying to find the matching element allocated
+	for (i = 0; i < HEAP_NUM_ELEMENTS; i++)
+	{
+		// Only looking at allocated elements
+		if (stHeap.astHeapElements[i].bInUse == TRUE)
+		{
+			CS_ENTER();
+			// Get the address for the element's array
+			pucTemp = &(stHeap.aucPool[stHeap.astHeapElements[i].usOffset]);
+			// Element addresses match, this is the match
+			if (pucTemp == pucData)
+			{
+				// Deallocate the element and exit
+				stHeap.astHeapElements[i].bInUse = FALSE;
+				bDone = TRUE;
+			}
+			CS_EXIT();
+			
+			// Break on success
+			if (bDone)
+			{
+				break;
+			}
+		}
+	}
+}
diff --git a/code/train/C/0148646_sca_wrapper.c b/code/train/C/0148646_sca_wrapper.c
new file mode 100644
index 0000000000000000000000000000000000000000..b37e6f2e30e9f1ecabe77fc56f7c25cc900863c0
--- /dev/null
+++ b/code/train/C/0148646_sca_wrapper.c
@@ -0,0 +1,259 @@
+/*
+*	sca_wrapper.c
+*
+*	Provides wrapper for various system calls.
+*
+*	ORIG: Hien T. Ly
+*
+* $Id:$
+*
+* $Log:	sca_wrapper.c,v $
+ * Revision 1.3  00/07/07  12:05:11  12:05:11  lyh ()
+ * added return statement in sca_sleep and sca_fflush to resolve compiler
+ * warning when porting to other platforms.
+ * 
+ * Revision 1.2  00/04/06  14:49:50  14:49:50  lyh ()
+ * added fnctl.h for open() function
+ * 
+ * Revision 1.1  00/03/03  15:18:26  15:18:26  lyh ()
+ * Initial revision
+ * 
+*
+* $Revision: 1.3 $
+*
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+
+/*
+*	Definitions
+*/
+#define FAILURE		-1
+#define MAX_READ_RETRY  5
+#define MAX_WRITE_RETRY 5
+
+
+
+
+/*
+*	sca_sleep
+*
+*	A wrapper for the sleep() system call.
+*
+*/
+unsigned int sca_sleep(unsigned int sleep_time)
+{
+	unsigned int time_remaining;	
+	time_remaining = sleep_time;
+
+	do {
+		time_remaining = sleep(time_remaining);
+	}
+	while (time_remaining > 0);
+
+	return time_remaining;
+}
+
+
+
+
+/*
+*	sca_write
+*	A wrapper for the write() system call.
+*
+*/
+ssize_t sca_write(int fdesc, const void *fbuff, size_t fbuff_len)
+{
+	ssize_t		gtmioStatus; 
+	size_t		gtmioBuffLen;
+	char *          gtmioBuff;
+	int		gtmioRetryCount = MAX_WRITE_RETRY; 
+	gtmioBuffLen = fbuff_len; 
+	gtmioBuff = (char *)(fbuff); 
+	do 
+        { 
+		if (-1 != (gtmioStatus = write(fdesc, gtmioBuff, gtmioBuffLen))) 
+	        { 
+			gtmioBuffLen -= gtmioStatus; 
+			if (0 == gtmioBuffLen) 
+			        break; 
+			gtmioBuff += gtmioStatus; 
+	        } 
+		else if (EINTR != errno)
+		        break;
+
+        } while (0 < gtmioRetryCount--);
+	if (-1 == gtmioStatus) /* Had legitimate error - return it */
+		return -1; /*rlen = -1;*/ 
+	else 
+		return fbuff_len - gtmioBuffLen;
+		/*rlen = fbuff_len - gtmioBuffLen;  Return length actually written */
+}
+
+
+
+
+/*
+*	sca_read
+*
+*	A wrapper for the read() system call.
+*
+*/
+ssize_t sca_read(int fdesc, void * fbuff, size_t fbuff_len)
+{
+	ssize_t		gtmioStatus; 
+	size_t		gtmioBuffLen; 
+	char *	 	gtmioBuff;
+	int	gtmioRetryCount = MAX_READ_RETRY;
+	gtmioBuffLen = fbuff_len;
+	gtmioBuff = (char *)(fbuff); 
+	do
+        { 
+		if (-1 != (gtmioStatus = read(fdesc, gtmioBuff, gtmioBuffLen)))
+	        {
+			gtmioBuffLen -= gtmioStatus; 
+			if (0 == gtmioBuffLen || 0 == gtmioStatus) 
+				break;
+			gtmioBuff += gtmioStatus; 
+	        } 
+		else if (EINTR != errno)
+		  break; 
+        } while (0 < gtmioRetryCount--); 
+
+	if (-1 == gtmioStatus)	    /* Had legitimate error - return it */ 
+		return -1; 
+	else 
+		return (fbuff_len - gtmioBuffLen); /* Return length actually read */
+}
+
+
+
+
+/*
+*	sca_fflush
+*
+*	A wrapper for the fflush() system call.
+*
+*/
+int sca_fflush (FILE * Stream)
+{
+	int value;
+	
+	value = FAILURE;
+	errno = EINTR;
+
+	while (value == FAILURE && errno == EINTR) {
+		value = fflush (Stream);
+	}
+
+	return value;
+}
+
+
+
+
+/*
+*	sca_open
+*
+*	A wrapper for the open() system call.
+*
+*/
+int sca_open (  path, oflag, mode )
+       const char *path;
+       int oflag;
+       mode_t mode;
+{
+	int handle=0;
+	do {
+		handle = open(path, oflag, mode);
+	} while ( (handle==FAILURE) && (errno==EINTR) );
+
+	return handle;
+}
+
+
+
+
+/*
+*	sca_close
+*
+*	A wrapper for the close() system call.
+*
+*/
+int sca_close (int FileDescriptor)
+{
+	int value;
+
+	value = FAILURE;
+	errno = EINTR;
+	while (value == FAILURE && errno == EINTR) {
+		value = close(FileDescriptor);
+	}
+
+	return(value);
+}
+
+
+
+
+
+/*
+*	sca_fgets
+*
+*	A wrapper for the fgets() system call.
+*
+*/
+sca_fgets(char *string, int n, FILE *stream)
+{
+        do {
+                fgets(string, n, stream);
+        }   while (errno == EINTR);
+        return;
+}
+
+
+
+
+
+/*
+*	sca_fopen
+*
+*	A wrapper for the fopen() system call.
+*
+*/
+FILE *sca_fopen(char *file, char *mode)
+{
+        FILE *fptr = (FILE *)NULL;
+ 
+        do {
+                fptr = fopen(file, mode);
+        } while (errno == EINTR);
+ 
+ 
+        return fptr;
+}
+
+
+
+
+
+/*
+*	sca_fclose
+*
+*	A wrapper for the fclose() system call.
+*
+*/
+int sca_fclose(FILE *fptr)
+{
+	int retval;
+	do {
+                retval = fclose(fptr);
+        } while (errno == EINTR);
+ 
+	return retval;
+}
diff --git a/code/train/C/0148893_pknum50f.c b/code/train/C/0148893_pknum50f.c
new file mode 100644
index 0000000000000000000000000000000000000000..46401db8921be399a28583fcbab8cfc429f3a426
--- /dev/null
+++ b/code/train/C/0148893_pknum50f.c
@@ -0,0 +1,131 @@
+
+/* ///////////////////////////////////////////////////////////////////////// */
+/* This file is a part of the BSTools package                                */
+/* written by Przemyslaw Kiciak                                              */
+/* ///////////////////////////////////////////////////////////////////////// */
+/* (C) Copyright by Przemyslaw Kiciak, 2012, 2013                            */
+/* this package is distributed under the terms of the                        */
+/* Lesser GNU Public License, see the file COPYING.LIB                       */
+/* ///////////////////////////////////////////////////////////////////////// */
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+#include "pkvaria.h"
+#include "pknum.h"
+
+/* /////////////////////////////////////////////////////////////////////////// */
+boolean pkn_SPMmultMMTCf ( int nra, int nca, int nrb,
+                           unsigned int nnza, index2 *ai, float *ac,
+                           unsigned int *apermut, int *acols, boolean ca,
+                           unsigned int nnzb, index2 *bi, float *bc,
+                           unsigned int *bpermut, int *brows, boolean rb,
+                           index2 *abi, float *abc )
+{
+  void         *sp, *sp1;
+  unsigned int nnz;
+  int          *wsp, wsps, wspn;
+  unsigned int *auxpermut;
+  index2       *aikbkj;
+  int          i, j, k, k0, k1, l, l0, l1, cnt, m, n;
+  double       s;
+
+  sp = pkv_GetScratchMemTop ();
+  wsp = NULL;
+  aikbkj = NULL;
+  if ( !apermut ) {
+    apermut = (unsigned int*)pkv_GetScratchMemi ( nnza+nca+1 );
+    if ( !apermut )
+      goto failure;
+    ca = false;
+    acols = (int*)&apermut[nnza];
+  }
+  if ( !bpermut ) {
+    bpermut = (unsigned int*)pkv_GetScratchMemi ( nnzb+nrb+1 );
+    if ( !bpermut )
+      goto failure;
+    rb = false;
+    brows = (int*)&bpermut[nnzb];
+  }
+  if ( !ca ) {
+    if ( !pkn_SPMFindCols ( nra, nca, nnza, ai, apermut, false, acols ) )
+      goto failure;
+  }
+  if ( !rb ) {
+    if ( !pkn_SPMFindRows ( nrb, nca, nnzb, bi, bpermut, false, brows ) )
+      goto failure;
+  }
+
+  sp1 = pkv_GetScratchMemTop ();
+  wsps = 0;
+  nnz = 0;
+  for ( i = 0; i < nrb; i++ ) {
+    k0 = brows[i];
+    k1 = brows[i+1];
+        /* find the workspace size and allocate the workspace */
+    wspn = 0;
+    for ( k = k0; k < k1; k++ ) {
+      j = bi[bpermut[k]].j;
+      wspn += acols[j+1]-acols[j];
+    }
+    if ( wspn > wsps ) {
+      pkv_SetScratchMemTop ( sp1 );
+      wsp = pkv_GetScratchMemi ( 4*wspn );
+      if ( !wsp )
+        goto failure;
+      aikbkj = (index2*)&wsp[wspn];
+      wsps = wspn;
+    }
+        /* find the positions (row numbers) of nonzero product coefficients */
+    cnt = 0;
+    for ( k = k0; k < k1; k++ ) {
+      m = bpermut[k];
+      j = bi[m].j;
+      l0 = acols[j];
+      l1 = acols[j+1];
+      for ( l = l0; l < l1; l++ ) {
+        aikbkj[cnt].i = n = apermut[l];
+        aikbkj[cnt].j = m;
+        wsp[cnt++] = ai[n].i;
+      }
+    }
+    if ( cnt ) {
+          /* set up the identity permutation */
+      auxpermut = (unsigned int*)&aikbkj[wspn];
+      for ( l = 0; l < cnt; l++ )
+        auxpermut[l] = l;
+          /* sort by columns */
+      if ( pkv_SortKernel ( sizeof(int), ID_UNSIGNED, sizeof(int),
+                            0, cnt, wsp, auxpermut ) != SORT_OK )
+        goto failure;
+      k = auxpermut[0];
+      l0 = wsp[k];
+      abi[nnz].j = i;
+      abi[nnz].i = l0;
+      s = ac[aikbkj[k].i]*bc[aikbkj[k].j];
+      for ( l = 1; l < cnt; l++ ) {
+        k = auxpermut[l];
+        if (wsp[k] != l0 ) {
+          abc[nnz++] = s;
+          s = ac[aikbkj[k].i]*bc[aikbkj[k].j];
+          l0 = wsp[k];
+          abi[nnz].j = i;
+          abi[nnz].i = l0;
+        }
+        else
+          s += ac[aikbkj[k].i]*bc[aikbkj[k].j];
+      }
+      abc[nnz++] = s;
+    }
+  }
+
+  pkv_SetScratchMemTop ( sp );
+  return true;
+
+failure:
+  pkv_SetScratchMemTop ( sp );
+  return false;
+} /*pkn_SPMmultMMTCf*/
+
diff --git a/code/train/C/0148915_cmsInt.c b/code/train/C/0148915_cmsInt.c
new file mode 100644
index 0000000000000000000000000000000000000000..cf492a535eda0a6840a4f5208f94f47b55a3f4d0
--- /dev/null
+++ b/code/train/C/0148915_cmsInt.c
@@ -0,0 +1,424 @@
+/* $Xorg: cmsInt.c,v 1.4 2000/08/17 19:45:09 cpqbld Exp $ */
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * 	All Rights Reserved
+ * 
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System.  Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation.  TekColor
+ * is a trademark of Tektronix, Inc.
+ * 
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose.  It is provided "as is" and with all faults.
+ * 
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE.  IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ *	NAME
+ *		XcmsInt.c - Xcms API utility routines
+ *
+ *	DESCRIPTION
+ *		Xcms Application Program Interface (API) utility
+ *		routines for hanging information directly onto
+ *		the Display structure.
+ *
+ *
+ */
+/* $XFree86: xc/lib/X11/cmsInt.c,v 1.3 2001/01/17 19:41:51 dawes Exp $ */
+
+/* #define NEED_EVENTS */
+#include <stdio.h>
+#include "Xlibint.h"
+#include "Xcmsint.h"
+
+#ifndef XCMSCOMPPROC
+#  define XCMSCOMPPROC	XcmsTekHVCClipC
+#endif
+
+/*
+ *      EXTERNS
+ */
+extern XcmsColorSpace **_XcmsDIColorSpaces;
+extern XcmsFunctionSet **_XcmsSCCFuncSets;
+
+/* LRGB.c */
+extern int _XcmsLRGB_InitScrnDefault();
+
+static void _XcmsFreeDefaultCCCs();
+
+/*
+ *      GLOBALS
+ */
+
+
+
+/************************************************************************
+ *									*
+ *			   API PRIVATE ROUTINES				*
+ *									*
+ ************************************************************************/
+
+/*
+ *	NAME
+ *		_XcmsCopyPointerArray
+ *
+ *	SYNOPSIS
+ */
+XPointer *
+_XcmsCopyPointerArray(pap)
+    XPointer *pap;
+/*
+ *	DESCRIPTION
+ *		Copies an array of NULL terminated pointers.
+ *
+ *	RETURNS
+ *		Returns NULL if failed; otherwise the address to
+ *		the copy.
+ *
+ */
+{
+    XPointer *newArray;
+    char **tmp;
+    int n;
+
+    for (tmp = pap, n = 0; *tmp != NULL; tmp++, n++);
+    n++; /* add 1 to include the NULL pointer */
+
+    if ((newArray = (XPointer *)Xmalloc(n * sizeof(XPointer)))) {
+	memcpy((char *)newArray, (char *)pap,
+	       (unsigned)(n * sizeof(XPointer)));
+    }
+    return((XPointer *)newArray);
+}
+
+/*
+ *	NAME
+ *		_XcmsFreePointerArray
+ *
+ *	SYNOPSIS
+ */
+void
+_XcmsFreePointerArray(pap)
+    XPointer *pap;
+/*
+ *	DESCRIPTION
+ *		Frees an array of NULL terminated pointers.
+ *
+ *	RETURNS
+ *		void
+ *
+ */
+{
+    Xfree(pap);
+}
+
+/*
+ *	NAME
+ *		_XcmsPushPointerArray
+ *
+ *	SYNOPSIS
+ */
+XPointer *
+_XcmsPushPointerArray(pap, p, papNoFree)
+    XPointer *pap;
+    XPointer p;
+    XPointer *papNoFree;
+/*
+ *	DESCRIPTION
+ *		Places the specified pointer at the head of an array of NULL
+ *		terminated pointers.
+ *
+ *	RETURNS
+ *		Returns NULL if failed; otherwise the address to
+ *		the head of the array.
+ *
+ */
+{
+    XPointer *newArray;
+    char **tmp;
+    int n;
+
+    for (tmp = pap, n = 0; *tmp != NULL; tmp++, n++);
+
+    /* add 2: 1 for the new pointer and another for the NULL pointer */
+    n += 2;
+
+    if ((newArray = (XPointer *)Xmalloc(n * sizeof(XPointer)))) {
+	memcpy((char *)(newArray+1),(char *)pap,
+	       (unsigned)((n-1) * sizeof(XPointer)));
+	*newArray = p;
+    }
+    if (pap != papNoFree) {
+        _XcmsFreePointerArray(pap);
+    }
+    return((XPointer *)newArray);
+}
+
+/*
+ *	NAME
+ *		_XcmsInitDefaultCCCs
+ *
+ *	SYNOPSIS
+ */
+int
+_XcmsInitDefaultCCCs(dpy)
+    Display *dpy;
+/*
+ *	DESCRIPTION
+ *		Initializes the Xcms per Display Info structure
+ *		(XcmsPerDpyInfo).
+ *
+ *	RETURNS
+ *		Returns 0 if failed; otherwise non-zero.
+ *
+ */
+{
+    int nScrn = ScreenCount(dpy);
+    int i;
+    XcmsCCC ccc;
+
+    if (nScrn <= 0) {
+	return(0);
+    }
+
+    /*
+     * Create an array of XcmsCCC structures, one for each screen.
+     * They serve as the screen's default CCC.
+     */
+    if (!(ccc = (XcmsCCC)
+	    Xcalloc((unsigned)nScrn, (unsigned) sizeof(XcmsCCCRec)))) {
+	return(0);
+    } 
+    dpy->cms.defaultCCCs = (XPointer)ccc;
+    dpy->free_funcs->defaultCCCs = _XcmsFreeDefaultCCCs;
+
+    for (i = 0; i < nScrn; i++, ccc++) {
+	ccc->dpy = dpy;
+	ccc->screenNumber = i;
+	ccc->visual = DefaultVisual(dpy, i);
+	/*
+	 * Used calloc to allocate memory so:
+	 *	ccc->clientWhitePt->format == XcmsUndefinedFormat
+	 *	ccc->gamutCompProc == NULL
+	 *	ccc->whitePtAdjProc == NULL
+	 *	ccc->pPerScrnInfo = NULL
+	 *
+	 * Don't need to create XcmsPerScrnInfo and its functionSet and
+	 * pScreenData components until the default CCC is accessed.
+	 * Note that the XcmsDefaultCCC routine calls _XcmsInitScrnInto
+	 * to do this.
+	 */
+	ccc->gamutCompProc = XCMSCOMPPROC;
+    }
+
+    return(1);
+}
+
+
+/*
+ *	NAME
+ *		_XcmsFreeDefaultCCCs - Free Default CCCs and its PerScrnInfo
+ *
+ *	SYNOPSIS
+ */
+static void
+_XcmsFreeDefaultCCCs(dpy)
+    Display *dpy;
+/*
+ *	DESCRIPTION
+ *		This routine frees the default XcmsCCC's associated with
+ *		each screen and its associated substructures as neccessary.
+ *
+ *	RETURNS
+ *		void
+ *
+ *
+ */
+{
+    int nScrn = ScreenCount(dpy);
+    XcmsCCC ccc;
+    int i;
+
+    /*
+     * Free Screen data in each DefaultCCC
+     *		Do not use XcmsFreeCCC here because it will not free
+     *		DefaultCCC's.
+     */
+    ccc = (XcmsCCC)dpy->cms.defaultCCCs;
+    for (i = nScrn; i--; ccc++) {
+	/*
+	 * Check if XcmsPerScrnInfo exists.
+	 *
+	 * This is the only place where XcmsPerScrnInfo structures
+	 * are freed since there is only one allocated per Screen.
+	 * It just so happens that we place its reference in the
+	 * default CCC.
+	 */
+	if (ccc->pPerScrnInfo) {
+	    /* Check if SCCData exists */
+	    if (ccc->pPerScrnInfo->state != XcmsInitNone
+		    && ccc->pPerScrnInfo->screenData) {
+		(*((XcmsFunctionSet *)ccc->pPerScrnInfo->functionSet)->screenFreeProc)
+			(ccc->pPerScrnInfo->screenData);
+	    }
+	    Xfree(ccc->pPerScrnInfo);
+	}
+    }
+
+    /*
+     * Free the array of XcmsCCC structures
+     */
+    Xfree(dpy->cms.defaultCCCs);
+    dpy->cms.defaultCCCs = (XPointer)NULL;
+}
+
+
+
+/*
+ *	NAME
+ *		_XcmsInitScrnInfo
+ *
+ *	SYNOPSIS
+ */
+int
+_XcmsInitScrnInfo(dpy, screenNumber)
+    register Display *dpy;
+    int screenNumber;
+/*
+ *	DESCRIPTION
+ *		Given a display and screen number, this routine attempts
+ *		to initialize the Xcms per Screen Info structure
+ *		(XcmsPerScrnInfo).
+ *
+ *	RETURNS
+ *		Returns zero if initialization failed; non-zero otherwise.
+ */
+{
+    XcmsFunctionSet **papSCCFuncSet = _XcmsSCCFuncSets;
+    XcmsCCC defaultccc;
+
+    /*
+     * Check if the XcmsCCC's for each screen has been created.
+     * Really dont need to be created until some routine uses the Xcms
+     * API routines.
+     */
+    if ((XcmsCCC)dpy->cms.defaultCCCs == NULL) {
+	if (!_XcmsInitDefaultCCCs(dpy)) {
+	    return(0);
+	}
+    }
+
+    defaultccc = (XcmsCCC)dpy->cms.defaultCCCs + screenNumber;
+
+    /*
+     * For each SCCFuncSet, try its pInitScrnFunc.
+     *	If the function succeeds, then we got it!
+     */
+
+    if (!defaultccc->pPerScrnInfo) {
+	/*
+	 * This is one of two places where XcmsPerScrnInfo structures
+	 * are allocated.  There is one allocated per Screen that is
+	 * shared among visuals that do not have specific intensity
+	 * tables.  Other XcmsPerScrnInfo structures are created
+	 * for the latter (see XcmsCreateCCC).  The ones created
+	 * here are referenced by the default CCC.
+	 */
+	if (!(defaultccc->pPerScrnInfo = (XcmsPerScrnInfo *)
+		Xcalloc(1, (unsigned) sizeof(XcmsPerScrnInfo)))) {
+	    return(0);
+	} 
+	defaultccc->pPerScrnInfo->state = XcmsInitNone;
+    }
+
+    while (*papSCCFuncSet != NULL) {
+	if ((*(*papSCCFuncSet)->screenInitProc)(dpy, screenNumber,
+		defaultccc->pPerScrnInfo)) {
+	    defaultccc->pPerScrnInfo->state = XcmsInitSuccess;
+	    return(1);
+	}
+	papSCCFuncSet++;
+    }
+
+    /*
+     * Use Default SCCData
+     */
+    return(_XcmsLRGB_InitScrnDefault(dpy, screenNumber, defaultccc->pPerScrnInfo));
+}
+
+
+/*
+ *	NAME
+ *		_XcmsFreeIntensityMaps
+ *
+ *	SYNOPSIS
+ */
+void
+_XcmsFreeIntensityMaps(dpy)
+    Display *dpy;
+/*
+ *	DESCRIPTION
+ *		Frees all XcmsIntensityMap structures in the linked list
+ *		and sets dpy->cms.perVisualIntensityMaps to NULL.
+ *
+ *	RETURNS
+ *		void
+ *
+ */
+{
+    XcmsIntensityMap *pNext, *pFree;
+
+    pNext = (XcmsIntensityMap *)dpy->cms.perVisualIntensityMaps;
+    while (pNext != NULL) {
+	pFree = pNext;
+	pNext = pNext->pNext;
+	(*pFree->pFreeScreenData)(pFree->screenData);
+	/* Now free the XcmsIntensityMap structure */
+	Xfree(pFree);
+    }
+    dpy->cms.perVisualIntensityMaps = (XPointer)NULL;
+}
+
+
+/*
+ *	NAME
+ *		_XcmsGetIntensityMap
+ *
+ *	SYNOPSIS
+ */
+XcmsIntensityMap *
+_XcmsGetIntensityMap(dpy, visual)
+    Display *dpy;
+    Visual *visual;
+/*
+ *	DESCRIPTION
+ *		Attempts to return a per-Visual intensity map.
+ *
+ *	RETURNS
+ *		Pointer to the XcmsIntensityMap structure if found;
+ *		otherwise NULL
+ *
+ */
+{
+    VisualID targetID = visual->visualid;
+    XcmsIntensityMap *pNext;
+
+    pNext = (XcmsIntensityMap *)dpy->cms.perVisualIntensityMaps;
+    while (pNext != NULL) {
+	if (targetID == pNext->visualID) {
+	    return(pNext);
+	}
+	pNext = pNext->pNext;
+    }
+    return((XcmsIntensityMap *)NULL);
+}
diff --git a/code/train/C/0149280_tile-manager-crop.c b/code/train/C/0149280_tile-manager-crop.c
new file mode 100644
index 0000000000000000000000000000000000000000..ce9a2aa1851aa911db997a51dceeb73448f46138
--- /dev/null
+++ b/code/train/C/0149280_tile-manager-crop.c
@@ -0,0 +1,160 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * 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.
+ */
+
+#include "config.h"
+
+#include <glib-object.h>
+
+#include "base-types.h"
+
+#include "paint-funcs/paint-funcs.h"
+
+#include "pixel-region.h"
+#include "tile-manager.h"
+#include "tile-manager-crop.h"
+
+
+/*  Crop the buffer to the size of pixels with non-zero transparency */
+
+TileManager *
+tile_manager_crop (TileManager *tiles,
+                   gint         border)
+{
+  PixelRegion  region;
+  TileManager *new_tiles;
+  gint         bytes, alpha;
+  gint         x1, y1, x2, y2;
+  gboolean     found;
+  gboolean     empty;
+  gpointer     pr;
+
+  g_return_val_if_fail (tiles != NULL, NULL);
+
+  bytes = tile_manager_bpp (tiles);
+  alpha = bytes - 1;
+
+  /*  go through and calculate the bounds  */
+  x1 = tile_manager_width (tiles);
+  y1 = tile_manager_height (tiles);
+  x2 = 0;
+  y2 = 0;
+
+  pixel_region_init (&region, tiles, 0, 0, x1, y1, FALSE);
+
+  for (pr = pixel_regions_register (1, &region);
+       pr != NULL;
+       pr = pixel_regions_process (pr))
+    {
+      const guchar *data = region.data + alpha;
+      gint          ex   = region.x + region.w;
+      gint          ey   = region.y + region.h;
+      gint          x, y;
+
+      for (y = region.y; y < ey; y++)
+        {
+          found = FALSE;
+
+          for (x = region.x; x < ex; x++, data += bytes)
+            if (*data)
+              {
+                if (x < x1)
+                  x1 = x;
+                if (x > x2)
+                  x2 = x;
+
+                found = TRUE;
+              }
+
+          if (found)
+            {
+              if (y < y1)
+                y1 = y;
+              if (y > y2)
+                y2 = y;
+            }
+        }
+    }
+
+  x2 = CLAMP (x2 + 1, 0, tile_manager_width (tiles));
+  y2 = CLAMP (y2 + 1, 0, tile_manager_height (tiles));
+
+  empty = (x1 == tile_manager_width (tiles) &&
+           y1 == tile_manager_height (tiles));
+
+  if (empty)
+    {
+      /*  If there are no visible pixels, return NULL */
+
+      new_tiles = NULL;
+    }
+  else if (x1 == 0 && y1 == 0 &&
+           x2 == tile_manager_width (tiles)  &&
+           y2 == tile_manager_height (tiles) &&
+           border == 0)
+    {
+      /*  If no cropping, return original buffer  */
+
+      new_tiles = tiles;
+    }
+  else
+    {
+      /*  Otherwise, crop the original area  */
+
+      PixelRegion srcPR, destPR;
+      gint        new_width, new_height;
+
+      new_width  = (x2 - x1) + border * 2;
+      new_height = (y2 - y1) + border * 2;
+      new_tiles  = tile_manager_new (new_width, new_height, bytes);
+
+      /*  If there is a border, make sure to clear the new tiles first  */
+      if (border)
+        {
+          pixel_region_init (&destPR, new_tiles,
+                             0, 0, new_width, border,
+                             TRUE);
+          clear_region (&destPR);
+
+          pixel_region_init (&destPR, new_tiles,
+                             0, border, border, (y2 - y1),
+                             TRUE);
+          clear_region (&destPR);
+
+          pixel_region_init (&destPR, new_tiles,
+                             new_width - border, border, border, (y2 - y1),
+                             TRUE);
+          clear_region (&destPR);
+
+          pixel_region_init (&destPR, new_tiles,
+                             0, new_height - border, new_width, border,
+                             TRUE);
+          clear_region (&destPR);
+        }
+
+      pixel_region_init (&srcPR, tiles,
+                         x1, y1, (x2 - x1), (y2 - y1), FALSE);
+      pixel_region_init (&destPR, new_tiles,
+                         border, border, (x2 - x1), (y2 - y1), TRUE);
+
+      copy_region (&srcPR, &destPR);
+
+      tile_manager_set_offsets (new_tiles, x1, y1);
+    }
+
+  return new_tiles;
+}
diff --git a/code/train/C/0149356_7-performance.c b/code/train/C/0149356_7-performance.c
new file mode 100644
index 0000000000000000000000000000000000000000..2e27267b940221c7573f3dd562b593feeaa4394d
--- /dev/null
+++ b/code/train/C/0149356_7-performance.c
@@ -0,0 +1,145 @@
+/*
+* Copyright (c) Bull S.A.  2007 All Rights Reserved.
+*
+* This program is free software; you can redistribute it and/or modify it
+* under the terms of version 2 of the GNU General Public License as
+* published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it would be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+*
+* Further, this software is distributed without any warranty that it is
+* free of the rightful claim of any third person regarding infringement
+* or the like.  Any license provided herein, whether implied or
+* otherwise, applies only to this software file.  Patent licenses, if
+* any, provided herein do not apply to combinations of this program with
+* other software, or any other product whatsoever.
+*
+* You should have received a copy of the GNU General Public License along
+* with this program; if not, write the Free Software Foundation, Inc., 59
+* Temple Place - Suite 330, Boston MA 02111-1307, USA.
+*
+* History:
+* Created by: Cyril Lacabanne (Cyril.Lacabanne@bull.net)
+*
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <rpc/rpc.h>
+
+//Standard define
+#define PROCNUM 1
+#define VERSNUM 1
+
+//Set number of test call
+int maxIter;
+
+double average(double *tbl)
+{
+	//Return average of values in tbl
+	int i;
+	double rslt = 0;
+
+	for (i = 0; i < maxIter; i++)
+	{
+		rslt += tbl[i];
+	}
+	rslt = rslt / maxIter;
+	return rslt;
+}
+
+double mini(double *tbl)
+{
+	//Return minimal of values in tbl
+	int i;
+	double rslt = tbl[0];
+
+	for (i = 0; i < maxIter; i++)
+	{
+		if (rslt > tbl[i])
+			rslt = tbl[i];
+	}
+	return rslt;
+}
+
+double maxi(double *tbl)
+{
+	//Return maximal of values in tbl
+	int i;
+	double rslt = tbl[0];
+
+	for (i = 0; i < maxIter; i++)
+	{
+		if (rslt < tbl[i])
+			rslt = tbl[i];
+	}
+	return rslt;
+}
+
+int main(int argn, char *argc[])
+{
+	//Program parameters : argc[1] : HostName or Host IP
+	//					   argc[2] : Server Program Number
+	//					   argc[3] : Number of test call
+	//					   other arguments depend on test case
+
+	//run_mode can switch into stand alone program or program launch by shell script
+	//1 : stand alone, debug mode, more screen information
+	//0 : launch by shell script as test case, only one printf -> result status
+	int run_mode = 0;
+	int test_status = 0; //Default test result set to FAILED
+	int i;
+	double *resultTbl;
+	struct timeval tv1,tv2;
+    struct timezone tz;
+    long long diff;
+    double rslt;
+	SVCXPRT *svcr = NULL;
+
+	//Test initialisation
+    maxIter = atoi(argc[3]);
+    resultTbl = (double *)malloc(maxIter * sizeof(double));
+
+	//Call tested function several times
+	for (i = 0; i < maxIter; i++)
+	{
+		//Tic
+		gettimeofday(&tv1, &tz);
+
+		//Call function
+		svcr = svcraw_create();
+
+		//Toc
+		gettimeofday(&tv2, &tz);
+
+		//Add function execution time (toc-tic)
+		diff = (tv2.tv_sec-tv1.tv_sec) * 1000000L + (tv2.tv_usec-tv1.tv_usec);
+		rslt = (double)diff / 1000;
+
+    	if (svcr != NULL)
+    	{
+    		resultTbl[i] = rslt;
+    	}
+    	else
+    	{
+    		test_status = 1;
+    	}
+
+    	if (run_mode)
+    	{
+    		fprintf(stderr, "lf time  = %lf usecn\n", resultTbl[i]);
+    	}
+	}
+
+	//This last printf gives the result status to the tests suite
+	//normally should be 0: test has passed or 1: test has failed
+	printf("%d\n", test_status);
+	printf("%lf %d\n", average(resultTbl), maxIter);
+	printf("%lf\n", mini(resultTbl));
+	printf("%lf\n", maxi(resultTbl));
+
+	return test_status;
+}
\ No newline at end of file
diff --git a/code/train/C/0149357_battery.c b/code/train/C/0149357_battery.c
new file mode 100644
index 0000000000000000000000000000000000000000..bb2caf2733b9bf69b86b2a506f3211ffdb5ae162
--- /dev/null
+++ b/code/train/C/0149357_battery.c
@@ -0,0 +1,396 @@
+/**
+ * @file battery.c
+ * Battery module -- this implements battery and charger logic for MCE
+ * <p>
+ * Copyright © 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
+ * <p>
+ * @author David Weinehall <david.weinehall@nokia.com>
+ * @author Jonathan Wilson <jfwfreo@tpgi.com.au>
+ *
+ * mce is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License
+ * version 2.1 as published by the Free Software Foundation.
+ *
+ * mce 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 mce.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <glib.h>
+#include <gmodule.h>
+#include <bme-dbus-proxy/dbus-names.h>
+#include "mce.h"
+#include "mce-log.h"
+#include "mce-dbus.h"
+#include "datapipe.h"
+
+/** Module name */
+#define MODULE_NAME		"battery"
+
+/** Functionality provided by this module */
+static const gchar *const provides[] = { MODULE_NAME, NULL };
+
+/** Module information */
+G_MODULE_EXPORT module_info_struct module_info = {
+	/** Name of the module */
+	.name = MODULE_NAME,
+	/** Module provides */
+	.provides = provides,
+	/** Module priority */
+	.priority = 100
+};
+
+/**
+ * D-Bus callback for the battery full signal
+ *
+ * @param msg The D-Bus message
+ * @return TRUE on success, FALSE on failure
+ */
+static gboolean battery_full_dbus_cb(DBusMessage *const msg)
+{
+	gboolean status = FALSE;
+
+	(void)msg;
+
+	mce_log(LL_DEBUG,
+		"Received battery full signal");
+
+	execute_datapipe_output_triggers(&led_pattern_deactivate_pipe, MCE_LED_PATTERN_BATTERY_CHARGING, USE_INDATA);
+	execute_datapipe_output_triggers(&led_pattern_activate_pipe, MCE_LED_PATTERN_BATTERY_FULL, USE_INDATA);
+
+	execute_datapipe(&battery_status_pipe,
+			 GINT_TO_POINTER(BATTERY_STATUS_FULL),
+			 USE_INDATA, CACHE_INDATA);
+
+	status = TRUE;
+
+//EXIT:
+	return status;
+}
+
+/**
+ * D-Bus callback for the battery low signal
+ *
+ * @param msg The D-Bus message
+ * @return TRUE on success, FALSE on failure
+ */
+static gboolean battery_low_dbus_cb(DBusMessage *const msg)
+{
+	gboolean status = FALSE;
+
+	(void)msg;
+
+	mce_log(LL_DEBUG,
+		"Received battery low signal");
+
+//	execute_datapipe_output_triggers(&led_pattern_activate_pipe, MCE_LED_PATTERN_BATTERY_LOW, USE_INDATA);
+
+	execute_datapipe(&battery_status_pipe,
+			 GINT_TO_POINTER(BATTERY_STATUS_LOW),
+			 USE_INDATA, CACHE_INDATA);
+
+	status = TRUE;
+
+//EXIT:
+	return status;
+}
+
+/**
+ * D-Bus callback for the battery empty signal
+ *
+ * @param msg The D-Bus message
+ * @return TRUE on success, FALSE on failure
+ */
+static gboolean battery_empty_dbus_cb(DBusMessage *const msg)
+{
+	gboolean status = FALSE;
+
+	(void)msg;
+
+	mce_log(LL_INFO,
+		"Received battery empty signal");
+
+	execute_datapipe(&battery_status_pipe,
+			 GINT_TO_POINTER(BATTERY_STATUS_EMPTY),
+			 USE_INDATA, CACHE_INDATA);
+
+	status = TRUE;
+
+//EXIT:
+	return status;
+}
+
+/**
+ * D-Bus callback for the charger_charging_on signal
+ *
+ * @param msg The D-Bus message
+ * @return TRUE on success, FALSE on failure
+ */
+static gboolean charger_charging_on_dbus_cb(DBusMessage *const msg)
+{
+	gboolean old_charger_state = datapipe_get_gbool(charger_state_pipe);
+	gboolean status = FALSE;
+
+	(void)msg;
+
+	mce_log(LL_DEBUG,
+		"Received charger_charging_on signal");
+
+	/* Only update the charger state if needed */
+	if (old_charger_state == FALSE) {
+		execute_datapipe(&charger_state_pipe, GINT_TO_POINTER(TRUE),
+				 USE_INDATA, CACHE_INDATA);
+	}
+
+	/* In case these are active; there's no harm to call them anyway */
+	execute_datapipe_output_triggers(&led_pattern_deactivate_pipe, MCE_LED_PATTERN_BATTERY_FULL, USE_INDATA);
+//	execute_datapipe_output_triggers(&led_pattern_deactivate_pipe, MCE_LED_PATTERN_BATTERY_LOW, USE_INDATA);
+
+	execute_datapipe_output_triggers(&led_pattern_activate_pipe, MCE_LED_PATTERN_BATTERY_CHARGING, USE_INDATA);
+
+	status = TRUE;
+
+//EXIT:
+	return status;
+}
+
+/**
+ * D-Bus callback for the charger_charging_off signal
+ *
+ * @param msg The D-Bus message
+ * @return TRUE on success, FALSE on failure
+ */
+static gboolean charger_charging_off_dbus_cb(DBusMessage *const msg)
+{
+	gboolean old_charger_state = datapipe_get_gbool(charger_state_pipe);
+	gboolean status = FALSE;
+
+	(void)msg;
+
+	mce_log(LL_DEBUG,
+		"Received charger_charging_off signal");
+
+	/* Only update the charger state if needed */
+	if (old_charger_state == TRUE) {
+		execute_datapipe(&charger_state_pipe, GINT_TO_POINTER(FALSE),
+				 USE_INDATA, CACHE_INDATA);
+	}
+
+	/* In case these are active; there's no harm to call them anyway */
+	execute_datapipe_output_triggers(&led_pattern_deactivate_pipe, MCE_LED_PATTERN_BATTERY_CHARGING, USE_INDATA);
+
+	status = TRUE;
+
+//EXIT:
+	return status;
+}
+
+/**
+ * D-Bus callback for the charger_charging_failed signal
+ *
+ * @param msg The D-Bus message
+ * @return TRUE on success, FALSE on failure
+ */
+static gboolean charger_charging_failed_dbus_cb(DBusMessage *const msg)
+{
+	gboolean old_charger_state = datapipe_get_gbool(charger_state_pipe);
+	gboolean status = FALSE;
+
+	(void)msg;
+
+	mce_log(LL_DEBUG,
+		"Received charger_charging_failed signal");
+
+	/* Only update the charger state if needed */
+	if (old_charger_state == TRUE) {
+		execute_datapipe(&charger_state_pipe, GINT_TO_POINTER(FALSE),
+				 USE_INDATA, CACHE_INDATA);
+	}
+
+	/* In case these are active; there's no harm to call them anyway */
+	execute_datapipe_output_triggers(&led_pattern_deactivate_pipe, MCE_LED_PATTERN_BATTERY_FULL, USE_INDATA);
+	execute_datapipe_output_triggers(&led_pattern_deactivate_pipe, MCE_LED_PATTERN_BATTERY_CHARGING, USE_INDATA);
+
+	/* Generate activity */
+	(void)execute_datapipe(&device_inactive_pipe, GINT_TO_POINTER(FALSE),
+			       USE_INDATA, CACHE_INDATA);
+
+	status = TRUE;
+
+//EXIT:
+	return status;
+}
+
+/**
+ * D-Bus callback for the charger_connected signal
+ *
+ * @param msg The D-Bus message
+ * @return TRUE on success, FALSE on failure
+ */
+static gboolean charger_connected_dbus_cb(DBusMessage *const msg)
+{
+	gboolean status = FALSE;
+
+	(void)msg;
+
+	mce_log(LL_DEBUG,
+		"Received charger_connected signal");
+
+	/* Generate activity */
+	(void)execute_datapipe(&device_inactive_pipe, GINT_TO_POINTER(FALSE),
+			       USE_INDATA, CACHE_INDATA);
+
+	status = TRUE;
+
+//EXIT:
+	return status;
+}
+
+/**
+ * D-Bus callback for the charger_disconnected signal
+ *
+ * @param msg The D-Bus message
+ * @return TRUE on success, FALSE on failure
+ */
+static gboolean charger_disconnected_dbus_cb(DBusMessage *const msg)
+{
+	gboolean old_charger_state = datapipe_get_gbool(charger_state_pipe);
+	gboolean status = FALSE;
+
+	(void)msg;
+
+	mce_log(LL_DEBUG,
+		"Received charger_disconnected signal");
+
+	/* Only update the charger state if needed */
+	if (old_charger_state == TRUE) {
+		execute_datapipe(&charger_state_pipe, GINT_TO_POINTER(FALSE),
+				 USE_INDATA, CACHE_INDATA);
+	}
+
+	/* In case these are active; there's no harm to call them anyway */
+	execute_datapipe_output_triggers(&led_pattern_deactivate_pipe, MCE_LED_PATTERN_BATTERY_FULL, USE_INDATA);
+	execute_datapipe_output_triggers(&led_pattern_deactivate_pipe, MCE_LED_PATTERN_BATTERY_CHARGING, USE_INDATA);
+
+	/* Generate activity */
+	(void)execute_datapipe(&device_inactive_pipe, GINT_TO_POINTER(FALSE),
+			       USE_INDATA, CACHE_INDATA);
+
+	status = TRUE;
+
+//EXIT:
+	return status;
+}
+
+/**
+ * Request update of charger status
+ *
+ * @return TRUE on success, FALSE on failure
+ */
+static gboolean request_charger_status(void)
+{
+	return dbus_send(BME_SERVICE, BME_REQUEST_PATH, BME_REQUEST_IF,
+			 BME_STATUS_INFO_REQ, NULL, DBUS_TYPE_INVALID);
+}
+
+/**
+ * Init function for the battery and charger module
+ *
+ * @todo XXX status needs to be set on error!
+ *
+ * @param module Unused
+ * @return NULL on success, a string with an error message on failure
+ */
+G_MODULE_EXPORT const gchar *g_module_check_init(GModule *module);
+const gchar *g_module_check_init(GModule *module)
+{
+	(void)module;
+
+	/* battery_full */
+	if (mce_dbus_handler_add(BME_SIGNAL_IF,
+				 BME_BATTERY_FULL,
+				 NULL,
+				 DBUS_MESSAGE_TYPE_SIGNAL,
+				 battery_full_dbus_cb) == NULL)
+		goto EXIT;
+
+	/* battery_low */
+	if (mce_dbus_handler_add(BME_SIGNAL_IF,
+				 BME_BATTERY_LOW,
+				 NULL,
+				 DBUS_MESSAGE_TYPE_SIGNAL,
+				 battery_low_dbus_cb) == NULL)
+		goto EXIT;
+
+	/* battery_empty */
+	if (mce_dbus_handler_add(BME_SIGNAL_IF,
+				 BME_BATTERY_EMPTY,
+				 NULL,
+				 DBUS_MESSAGE_TYPE_SIGNAL,
+				 battery_empty_dbus_cb) == NULL)
+		goto EXIT;
+
+	/* charger_charging_on */
+	if (mce_dbus_handler_add(BME_SIGNAL_IF,
+				 BME_CHARGER_CHARGING_ON,
+				 NULL,
+				 DBUS_MESSAGE_TYPE_SIGNAL,
+				 charger_charging_on_dbus_cb) == NULL)
+		goto EXIT;
+
+	/* charger_charging_off */
+	if (mce_dbus_handler_add(BME_SIGNAL_IF,
+				 BME_CHARGER_CHARGING_OFF,
+				 NULL,
+				 DBUS_MESSAGE_TYPE_SIGNAL,
+				 charger_charging_off_dbus_cb) == NULL)
+		goto EXIT;
+
+	/* charger_charging_failed */
+	if (mce_dbus_handler_add(BME_SIGNAL_IF,
+				 BME_CHARGER_CHARGING_FAILED,
+				 NULL,
+				 DBUS_MESSAGE_TYPE_SIGNAL,
+				 charger_charging_failed_dbus_cb) == NULL)
+		goto EXIT;
+
+	/* charger_connected */
+	if (mce_dbus_handler_add(BME_SIGNAL_IF,
+				 BME_CHARGER_CONNECTED,
+				 NULL,
+				 DBUS_MESSAGE_TYPE_SIGNAL,
+				 charger_connected_dbus_cb) == NULL)
+		goto EXIT;
+
+	/* charger_disconnected */
+	if (mce_dbus_handler_add(BME_SIGNAL_IF,
+				 BME_CHARGER_DISCONNECTED,
+				 NULL,
+				 DBUS_MESSAGE_TYPE_SIGNAL,
+				 charger_disconnected_dbus_cb) == NULL)
+		goto EXIT;
+
+	/* Update charger status */
+	request_charger_status();
+
+EXIT:
+	return NULL;
+}
+
+/**
+ * Exit function for the battery and charger module
+ *
+ * @todo D-Bus unregistration
+ *
+ * @param module Unused
+ */
+G_MODULE_EXPORT void g_module_unload(GModule *module);
+void g_module_unload(GModule *module)
+{
+	(void)module;
+
+	return;
+}
diff --git a/code/train/C/0149515_prims.c b/code/train/C/0149515_prims.c
new file mode 100644
index 0000000000000000000000000000000000000000..2a2e4f1f4920fc38f1d2e9a4c8ebf92fde93e923
--- /dev/null
+++ b/code/train/C/0149515_prims.c
@@ -0,0 +1,96 @@
+#include <stdio.h>
+typedef int bool;
+int true = 1;
+int false = 0;
+
+int minKey(int key[], bool mset[], int v)
+{
+  int minIndex = 0;
+  int min = 999,i;
+
+  for( i = 0;i<v;i++)
+  {
+     if(mset[i]==false && key[i] < min) {
+         minIndex = i;
+         min = key[i];
+     }
+  }
+
+  return minIndex;
+}
+
+void printMst(int parent[], int key[], int graph[10][10],int V)
+{
+    int i = 0;
+    for(i =1;i<V;i++)
+    {
+        printf("%d -> %d : %d\n", parent[i],i, graph[i][parent[i]]);
+    }
+}
+
+void primMst(int graph[10][10],int V)
+{
+    int parent[V];
+    bool mset[V];
+    int key[V];
+    //set default values for key and parent
+
+    int v,u;
+     int i;
+    for( i =0;i<V;i++)
+    {
+       mset[i] = false;
+       key[i] = 999;
+       parent[i] = -1;
+    }
+
+    //set first node as visited
+    key[0] = 0;
+    parent[0] = -1;
+
+    for(i = 0;i<V;i++)
+    {
+        u=minKey(key,mset,V);
+        mset[u] = true;
+
+        for(v=0;v<V;v++)
+        {
+            if(graph[u][v] && mset[v]==false && graph[u][v] < key[v]) //first check whether node exists between two
+            {
+                 parent[v] = u;
+                 key[v] = graph[u][v];
+            }
+
+        }
+
+   }
+
+  printMst(parent,key,graph,9);
+  printf("key values are: \n");
+
+  for(v=0;v<V;v++){
+     printf("%d\n", key[v]);
+  }
+  printf("parent: \n");
+
+  for(v=0;v<V;v++){
+     printf("%d\n", parent[v]);
+  }
+
+}
+
+int main()
+{
+
+    int prim[10][10] = {{0, 4,  0, 0, 0, 0, 0, 8, 0},
+                    {4, 0,  8, 0, 0, 0, 0, 11,0},
+                    {0, 8,  0, 7, 0, 4, 0, 0, 2},
+                    {0, 0,  7, 0, 9, 14,0, 0, 0},
+                    {0, 0,  0, 9, 0, 16, 0, 0, 0},
+                    {0, 0,  4, 14,16, 0, 2, 0, 0},
+                    {0, 0,  0, 0, 0, 2, 0, 1, 6},
+                    {8, 11, 0, 0, 0, 0, 1, 0, 7},
+                    {0, 0,  2, 0, 0, 0, 6, 7, 0}};
+    primMst(prim,9);
+    return 0;
+}
diff --git a/code/train/C/0149607_dbus-proxy.c b/code/train/C/0149607_dbus-proxy.c
new file mode 100644
index 0000000000000000000000000000000000000000..6ed1697fadc54e5c6de9c4a320b5ff79b3559d88
--- /dev/null
+++ b/code/train/C/0149607_dbus-proxy.c
@@ -0,0 +1,223 @@
+/*
+ * Copyright © 2015 Red Hat, Inc
+ *
+ * This program 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 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *       Alexander Larsson <alexl@redhat.com>
+ */
+
+#include "config.h"
+
+#include <string.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+#include "libglnx/libglnx.h"
+
+#include "flatpak-proxy.h"
+
+GList *proxies;
+int sync_fd = -1;
+
+int
+parse_generic_args (int n_args, const char *args[])
+{
+  if (g_str_has_prefix (args[0], "--fd="))
+    {
+      const char *fd_s = args[0] + strlen ("--fd=");
+      char *endptr;
+      int fd;
+
+      fd = strtol (fd_s, &endptr, 10);
+      if (fd < 0 || endptr == fd_s || *endptr != 0)
+        {
+          g_printerr ("Invalid fd %s\n", fd_s);
+          return -1;
+        }
+      sync_fd = fd;
+
+      return 1;
+    }
+  else
+    {
+      g_printerr ("Unknown argument %s\n", args[0]);
+      return -1;
+    }
+}
+
+int
+start_proxy (int n_args, const char *args[])
+{
+  g_autoptr(FlatpakProxy) proxy = NULL;
+  g_autoptr(GError) error = NULL;
+  const char *bus_address, *socket_path;
+  int n;
+
+  n = 0;
+  if (n_args < n + 1 || args[n][0] == '-')
+    {
+      g_printerr ("No bus address given\n");
+      return -1;
+    }
+  bus_address = args[n++];
+
+  if (n_args < n + 1 || args[n][0] == '-')
+    {
+      g_printerr ("No socket path given\n");
+      return -1;
+    }
+  socket_path = args[n++];
+
+  proxy = flatpak_proxy_new (bus_address, socket_path);
+
+  while (n < n_args)
+    {
+      if (args[n][0] != '-')
+        break;
+
+      if (g_str_has_prefix (args[n], "--see=") ||
+          g_str_has_prefix (args[n], "--talk=") ||
+          g_str_has_prefix (args[n], "--own="))
+        {
+          FlatpakPolicy policy = FLATPAK_POLICY_SEE;
+          g_autofree char *name = NULL;
+          gboolean wildcard = FALSE;
+
+          if (args[n][2] == 't')
+            policy = FLATPAK_POLICY_TALK;
+          else if (args[n][2] == 'o')
+            policy = FLATPAK_POLICY_OWN;
+
+          name = g_strdup (strchr (args[n], '=') + 1);
+          if (g_str_has_suffix (name, ".*"))
+            {
+              name[strlen (name) - 2] = 0;
+              wildcard = TRUE;
+            }
+
+          if (name[0] == ':' || !g_dbus_is_name (name))
+            {
+              g_printerr ("'%s' is not a valid dbus name\n", name);
+              return -1;
+            }
+
+          if (wildcard)
+            flatpak_proxy_add_wildcarded_policy (proxy, name, policy);
+          else
+            flatpak_proxy_add_policy (proxy, name, policy);
+        }
+      else if (g_str_equal (args[n], "--log"))
+        {
+          flatpak_proxy_set_log_messages (proxy, TRUE);
+        }
+      else if (g_str_equal (args[n], "--filter"))
+        {
+          flatpak_proxy_set_filter (proxy, TRUE);
+        }
+      else
+        {
+          int res = parse_generic_args (n_args - n, &args[n]);
+          if (res == -1)
+            return -1;
+
+          n += res - 1; /* res - 1, because we ++ below */
+        }
+
+      n++;
+    }
+
+  if (!flatpak_proxy_start (proxy, &error))
+    {
+      g_printerr ("Failed to start proxy for %s: %s\n", bus_address, error->message);
+      return -1;
+    }
+
+  proxies = g_list_prepend (proxies, g_object_ref (proxy));
+
+  return n;
+}
+
+static gboolean
+sync_closed_cb (GIOChannel  *source,
+                GIOCondition condition,
+                gpointer     data)
+{
+  GList *l;
+
+  for (l = proxies; l != NULL; l = l->next)
+    flatpak_proxy_stop (FLATPAK_PROXY (l->data));
+
+  exit (0);
+  return TRUE;
+}
+
+int
+main (int argc, const char *argv[])
+{
+  GMainLoop *service_loop;
+  int n_args, res;
+  const char **args;
+
+  n_args = argc - 1;
+  args = &argv[1];
+
+  while (n_args > 0)
+    {
+      if (args[0][0] == '-')
+        {
+          res = parse_generic_args (n_args, &args[0]);
+          if (res == -1)
+            return 1;
+        }
+      else
+        {
+          res = start_proxy (n_args, args);
+          if (res == -1)
+            return 1;
+        }
+
+      g_assert (res > 0);
+      n_args -= res;
+      args += res;
+    }
+
+  if (proxies == NULL)
+    {
+      g_printerr ("No proxies specied\n");
+      return 1;
+    }
+
+  if (sync_fd >= 0)
+    {
+      ssize_t written;
+      GIOChannel *sync_channel;
+      written = write (sync_fd, "x", 1);
+      if (written != 1)
+        g_warning ("Can't write to sync socket");
+
+      sync_channel = g_io_channel_unix_new (sync_fd);
+      g_io_add_watch (sync_channel, G_IO_ERR | G_IO_HUP,
+                      sync_closed_cb, NULL);
+    }
+
+  service_loop = g_main_loop_new (NULL, FALSE);
+  g_main_loop_run (service_loop);
+
+  g_main_loop_unref (service_loop);
+
+  return 0;
+}
diff --git a/code/train/C/0149666_LabMnL.c b/code/train/C/0149666_LabMnL.c
new file mode 100644
index 0000000000000000000000000000000000000000..b61638426d7a86eda016d639edc2b3d7f732052f
--- /dev/null
+++ b/code/train/C/0149666_LabMnL.c
@@ -0,0 +1,222 @@
+/* $Xorg: LabMnL.c,v 1.3 2000/08/17 19:44:39 cpqbld Exp $ */
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * 	All Rights Reserved
+ * 
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System.  Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation.  TekColor
+ * is a trademark of Tektronix, Inc.
+ * 
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose.  It is provided "as is" and with all faults.
+ * 
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE.  IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *	NAME
+ *		CIELabMnL.c
+ *
+ *	DESCRIPTION
+ *		Source for the XcmsCIELabQueryMinL() gamut boundary
+ *		querying routine.
+ *
+ */
+/* $XFree86: xc/lib/X11/LabMnL.c,v 1.3 2001/01/17 19:41:39 dawes Exp $ */
+
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include <math.h>
+
+/*
+ *	DEFINES
+ */
+#define MAXBISECTCOUNT	100
+#define EPS		(XcmsFloat)0.001
+#define START_L_STAR	(XcmsFloat)40.0
+
+/*
+ *	EXTERNS
+ */
+extern Status _XcmsCIELabQueryMaxLCRGB();
+
+/* CvColW.c */
+extern Status _XcmsConvertColorsWithWhitePt();
+
+
+/************************************************************************
+ *									*
+ *			 PUBLIC ROUTINES				*
+ *									*
+ ************************************************************************/
+
+/*
+ *	NAME
+ *		XcmsCIELabQueryMinL - Compute max Lstar for a hue and chroma
+ *
+ *	SYNOPSIS
+ */
+Status
+XcmsCIELabQueryMinL(ccc, hue_angle, chroma, pColor_return)
+    XcmsCCC ccc;
+    XcmsFloat hue_angle;	    /* hue angle in degrees */
+    XcmsFloat chroma;
+    XcmsColor *pColor_return;
+/*
+ *	DESCRIPTION
+ *		Return the maximum Lstar for a specified hue_angle and chroma.
+ *
+ *	ASSUMPTIONS
+ *		This routine assumes that the white point associated with
+ *		the color specification is the Screen White Point.  The
+ *		Screen White Point will also be associated with the
+ *		returned color specification.
+ *
+ *	RETURNS
+ *		XcmsFailure - Failure
+ *              XcmsSuccess - Succeeded with no modifications
+ *
+ */
+{
+    XcmsCCCRec	myCCC;
+    XcmsColor   max_lc, tmp, prev;
+    XcmsFloat   max_chroma, tmp_chroma;
+    XcmsFloat   hue, nT, nChroma, lastChroma, prevChroma;
+    XcmsFloat   rFactor;
+    XcmsRGBi    rgb_saved;
+    int         nCount, nMaxCount;
+
+    /*
+     * Check Arguments
+     */
+    if (ccc == NULL || pColor_return == NULL) {
+	return(XcmsFailure);
+    }
+
+    /* setup the CCC to use for the conversions. */
+    memcpy ((char *) &myCCC, (char *) ccc, sizeof(XcmsCCCRec));
+    myCCC.clientWhitePt.format = XcmsUndefinedFormat;
+    myCCC.gamutCompProc = (XcmsCompressionProc) NULL;
+
+    while (hue_angle < 0.0) {
+	hue_angle += 360.0;
+    }
+    while (hue_angle >= 360.0) {
+	hue_angle -= 360.0;
+    } 
+
+    hue = radians(hue_angle);
+    tmp.spec.CIELab.L_star = START_L_STAR;
+    tmp.spec.CIELab.a_star = XCMS_CIEASTAROFHUE(hue, chroma);
+    tmp.spec.CIELab.b_star = XCMS_CIEBSTAROFHUE(hue, chroma);
+    tmp.pixel = pColor_return->pixel;
+    tmp.format = XcmsCIELabFormat;
+    
+    /* Step 1: Obtain the maximum L_star and chroma for this hue. */
+    if (_XcmsCIELabQueryMaxLCRGB(&myCCC, hue, &max_lc, &rgb_saved)
+	    == XcmsFailure) {
+	return(XcmsFailure);
+    }
+
+    max_chroma = XCMS_CIELAB_PMETRIC_CHROMA(max_lc.spec.CIELab.a_star,
+					    max_lc.spec.CIELab.b_star);
+
+    if (max_chroma <= chroma) {
+	/*
+	 *  If the chroma is greater than the chroma for the 
+	 *  maximum L/chroma point then the L_star is the
+	 *  the L_star for the maximum L_star/chroma point.
+	 *  This is an error but I return the best approximation I can.
+         *  Thus the inconsistency.
+	 */
+	memcpy ((char *) pColor_return, (char *) &max_lc, sizeof (XcmsColor));
+	return(XcmsSuccess);
+    }
+
+    /*
+     *  If the chroma is equal to the chroma for the 
+     *  maximum L_star/chroma point then the L_star is the
+     *  the L_star for the maximum L* and chroma point.
+     */
+    /* if (max_chroma == chroma) {
+     *  memcpy ((char *) pColor_return, (char *) &max_lc, sizeof (XcmsColor));
+     *	return(XcmsSuccess);
+     *    }
+     */
+
+    /* must do a bisection here to compute the maximum L* */
+    /* save the structure input so that any elements that */
+    /* are not touched are recopied later in the routine. */
+    nChroma = chroma;
+    tmp_chroma = max_chroma;
+    lastChroma = -1.0;
+    nMaxCount = MAXBISECTCOUNT;
+    rFactor = 1.0;
+
+    for (nCount = 0; nCount < nMaxCount; nCount++) {
+	prevChroma = lastChroma;
+	lastChroma = tmp_chroma;
+	nT = (nChroma - max_chroma) / max_chroma * rFactor;
+	memcpy ((char *)&prev, (char *)&tmp, sizeof(XcmsColor));
+	tmp.spec.RGBi.red   = rgb_saved.red + (rgb_saved.red * nT);
+	tmp.spec.RGBi.green = rgb_saved.green + (rgb_saved.green * nT);
+	tmp.spec.RGBi.blue  = rgb_saved.blue + (rgb_saved.blue * nT);
+	tmp.format = XcmsRGBiFormat;
+
+	/* convert from RGB to CIELab */
+	if (_XcmsConvertColorsWithWhitePt(&myCCC, &tmp,
+		ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIELabFormat,
+		(Bool *) NULL) == XcmsFailure) {
+	    return(XcmsFailure);
+	}
+
+	/* Now check the return against what is expected */
+	tmp_chroma = XCMS_CIELAB_PMETRIC_CHROMA(tmp.spec.CIELab.a_star,
+						tmp.spec.CIELab.b_star);
+	if (tmp_chroma <= chroma + EPS && tmp_chroma >= chroma - EPS) {
+	    /* Found It! */
+	    memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+	    return(XcmsSuccess);
+	} 
+	nChroma += chroma - tmp_chroma;
+	if (nChroma > max_chroma) {
+	    nChroma = max_chroma;
+	    rFactor *= 0.5;  /* selective relaxation employed */
+	} else if (nChroma < 0.0) {
+	    if (XCMS_FABS(lastChroma - chroma) < 
+		XCMS_FABS(tmp_chroma - chroma)) {
+		memcpy ((char *)pColor_return, (char *)&prev, 
+			sizeof(XcmsColor));
+	    } else {
+		memcpy ((char *)pColor_return, (char *)&tmp,
+ 			sizeof(XcmsColor));
+	    }
+	    return(XcmsSuccess);
+	} else if (tmp_chroma <= prevChroma + EPS &&
+		   tmp_chroma >= prevChroma - EPS) {
+	    rFactor *= 0.5;  /* selective relaxation employed */
+	}
+    }
+
+    if (nCount >= nMaxCount) {
+	if (XCMS_FABS(lastChroma - chroma) < 
+	    XCMS_FABS(tmp_chroma - chroma)) {
+		memcpy ((char *)pColor_return, (char *)&prev,
+ 			sizeof(XcmsColor));
+	    } else {
+		memcpy ((char *)pColor_return, (char *)&tmp,
+ 			sizeof(XcmsColor));
+	}
+    }
+    memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+    return(XcmsSuccess);
+}
diff --git a/code/train/C/0149677_eb_chain.c b/code/train/C/0149677_eb_chain.c
new file mode 100644
index 0000000000000000000000000000000000000000..da5c2e344c612fd8fb632fc2f1cef2eea2408135
--- /dev/null
+++ b/code/train/C/0149677_eb_chain.c
@@ -0,0 +1,281 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006, 2007
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * Author:  Drake Dowsett, dowsett@de.ibm.com
+ * Contact: Andreas Arnez, arnez@de.ibm.com
+ */
+
+/* see eb_chain.h */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <mtd_swab.h>
+#include "unubi_analyze.h"
+#include "crc32.h"
+
+#define COPY(dst, src)							\
+	do {								\
+		dst = malloc(sizeof(*dst));				\
+		if (dst == NULL)					\
+			return -ENOMEM;					\
+		memcpy(dst, src, sizeof(*dst));				\
+	} while (0)
+
+
+/**
+ * inserts an eb_info into the chain starting at head, then searching
+ * linearly for the correct position;
+ * new should contain valid vid and ec headers and the data_crc should
+ * already have been checked before insertion, otherwise the chain
+ * could be have un an undesired manner;
+ * returns -ENOMEM if alloc fails, otherwise SHOULD always return 0,
+ * if not, the code reached the last line and returned -EAGAIN,
+ * meaning there is a bug or a case not being handled here;
+ **/
+int
+eb_chain_insert(struct eb_info **head, struct eb_info *new)
+{
+	uint32_t vol, num, ver;
+	uint32_t new_vol, new_num, new_ver;
+	struct eb_info *prev, *cur, *hist, *ins;
+	struct eb_info **prev_ptr;
+
+	if ((head == NULL) || (new == NULL))
+		return 0;
+
+	if (*head == NULL) {
+		COPY(*head, new);
+		(*head)->next = NULL;
+		return 0;
+	}
+
+	new_vol = be32_to_cpu(new->vid.vol_id);
+	new_num = be32_to_cpu(new->vid.lnum);
+	new_ver = be32_to_cpu(new->vid.leb_ver);
+
+	/** TRAVERSE HORIZONTALY **/
+
+	cur = *head;
+	prev = NULL;
+
+	/* traverse until vol_id/lnum align */
+	vol = be32_to_cpu(cur->vid.vol_id);
+	num = be32_to_cpu(cur->vid.lnum);
+	while ((new_vol > vol) || ((new_vol == vol) && (new_num > num))) {
+		/* insert new at end of chain */
+		if (cur->next == NULL) {
+			COPY(ins, new);
+			ins->next = NULL;
+			cur->next = ins;
+			return 0;
+		}
+
+		prev = cur;
+		cur = cur->next;
+		vol = be32_to_cpu(cur->vid.vol_id);
+		num = be32_to_cpu(cur->vid.lnum);
+	}
+
+	if (prev == NULL)
+		prev_ptr = head;
+	else
+		prev_ptr = &(prev->next);
+
+	/* insert new into the middle of chain */
+	if ((new_vol != vol) || (new_num != num)) {
+		COPY(ins, new);
+		ins->next = cur;
+		*prev_ptr = ins;
+		return 0;
+	}
+
+	/** TRAVERSE VERTICALY **/
+
+	hist = cur;
+	prev = NULL;
+
+	/* traverse until versions align */
+	ver = be32_to_cpu(cur->vid.leb_ver);
+	while (new_ver < ver) {
+		/* insert new at bottom of history */
+		if (hist->older == NULL) {
+			COPY(ins, new);
+			ins->next = NULL;
+			ins->older = NULL;
+			hist->older = ins;
+			return 0;
+		}
+
+		prev = hist;
+		hist = hist->older;
+		ver = be32_to_cpu(hist->vid.leb_ver);
+	}
+
+	if (prev == NULL) {
+		/* replace active version */
+		COPY(ins, new);
+		ins->next = hist->next;
+		*prev_ptr = ins;
+
+		/* place cur in vertical histroy */
+		ins->older = hist;
+		hist->next = NULL;
+		return 0;
+	}
+
+	/* insert between versions, beneath active version */
+	COPY(ins, new);
+	ins->next = NULL;
+	ins->older = prev->older;
+	prev->older = ins;
+	return 0;
+}
+
+
+/**
+ * sets the pointer at pos to the position of the first entry in the chain
+ * with of vol_id and, if given, with the same lnum as *lnum;
+ * if there is no entry in the chain, then *pos is NULL on return;
+ * always returns 0;
+ **/
+int
+eb_chain_position(struct eb_info **head, uint32_t vol_id, uint32_t *lnum,
+		  struct eb_info **pos)
+{
+	uint32_t vol, num;
+	struct eb_info *cur;
+
+	if ((head == NULL) || (*head == NULL) || (pos == NULL))
+		return 0;
+
+	*pos = NULL;
+
+	cur = *head;
+	while (cur != NULL) {
+		vol = be32_to_cpu(cur->vid.vol_id);
+		num = be32_to_cpu(cur->vid.lnum);
+
+		if ((vol_id == vol) && ((lnum == NULL) || (*lnum == num))) {
+			*pos = cur;
+			return 0;
+		}
+
+		cur = cur->next;
+	}
+
+	return 0;
+}
+
+
+/**
+ * prints to stream, the vol_id, lnum and leb_ver for each entry in the
+ * chain, starting at head;
+ * this is intended for debuging purposes;
+ * always returns 0;
+ *
+ * FIXME I do not like the double list traversion ...
+ **/
+int
+eb_chain_print(FILE* stream, struct eb_info *head)
+{
+	struct eb_info *cur;
+
+	if (stream == NULL)
+		stream = stdout;
+
+	if (head == NULL) {
+		fprintf(stream, "EMPTY\n");
+		return 0;
+	}
+	/*               012345678012345678012345678012301230123 0123 01234567 0123457 01234567*/
+	fprintf(stream, "VOL_ID   LNUM     LEB_VER  EC  VID DAT  PBLK PADDR    DSIZE   EC\n");
+	cur = head;
+	while (cur != NULL) {
+		struct eb_info *hist;
+
+		fprintf(stream, "%08x %-8u %08x %-4s%-4s",
+			be32_to_cpu(cur->vid.vol_id),
+			be32_to_cpu(cur->vid.lnum),
+			be32_to_cpu(cur->vid.leb_ver),
+			cur->ec_crc_ok   ? "ok":"bad",
+			cur->vid_crc_ok  ? "ok":"bad");
+		if (cur->vid.vol_type == UBI_VID_STATIC)
+			fprintf(stream, "%-4s", cur->data_crc_ok ? "ok":"bad");
+		else	fprintf(stream, "%-4s", cur->data_crc_ok ? "ok":"ign");
+		fprintf(stream, " %-4d %08x %-8u %-8llu\n", cur->phys_block,
+			cur->phys_addr, be32_to_cpu(cur->vid.data_size),
+			(unsigned long long)be64_to_cpu(cur->ec.ec));
+
+		hist = cur->older;
+		while (hist != NULL) {
+			fprintf(stream, "%08x %-8u %08x %-4s%-4s",
+				be32_to_cpu(hist->vid.vol_id),
+				be32_to_cpu(hist->vid.lnum),
+				be32_to_cpu(hist->vid.leb_ver),
+				hist->ec_crc_ok   ? "ok":"bad",
+				hist->vid_crc_ok  ? "ok":"bad");
+			if (hist->vid.vol_type == UBI_VID_STATIC)
+				fprintf(stream, "%-4s", hist->data_crc_ok ? "ok":"bad");
+			else	fprintf(stream, "%-4s", hist->data_crc_ok ? "ok":"ign");
+			fprintf(stream, " %-4d %08x %-8u %-8llu (*)\n",
+				hist->phys_block, hist->phys_addr,
+				be32_to_cpu(hist->vid.data_size),
+				(unsigned long long)be64_to_cpu(hist->ec.ec));
+
+			hist = hist->older;
+		}
+		cur = cur->next;
+	}
+
+	return 0;
+}
+
+
+/**
+ * frees the memory of the entire chain, starting at head;
+ * head will be NULL on return;
+ * always returns 0;
+ **/
+int
+eb_chain_destroy(struct eb_info **head)
+{
+	if (head == NULL)
+		return 0;
+
+	while (*head != NULL) {
+		struct eb_info *cur;
+		struct eb_info *hist;
+
+		cur = *head;
+		*head = (*head)->next;
+
+		hist = cur->older;
+		while (hist != NULL) {
+			struct eb_info *temp;
+
+			temp = hist;
+			hist = hist->older;
+			free(temp);
+		}
+		free(cur);
+	}
+	return 0;
+}
+
diff --git a/code/train/C/0149754_diophantine_equation.c b/code/train/C/0149754_diophantine_equation.c
new file mode 100644
index 0000000000000000000000000000000000000000..12333f3857b65319cf8b534289ca1817fbdb2243
--- /dev/null
+++ b/code/train/C/0149754_diophantine_equation.c
@@ -0,0 +1,137 @@
+
+#include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+
+#define MAX             1000
+#define ABS(x)          ((x) < 0 ? (x) * -1 : (x))
+
+
+int64_t diophantine_minimise_x(int64_t n);
+int64_t perfect_square(int64_t n);
+int main(int argc, char** argv);
+int64_t init_m(int64_t n);
+
+
+int main(int argc, char** argv)
+{
+        (void) argc;
+        (void) argv;
+
+        int64_t max_x = 0;
+        int64_t max_d = 0;
+
+        /* Note that this solution massively pisses me off since I worked so
+         * hard on mathematically reducing the problem and ultimately I only
+         * get a solution because of an order of magnitude hack */
+
+        for(int64_t D = 1; D <= MAX; D++){
+
+                int64_t x = diophantine_minimise_x(D);
+                if(x > max_x) {
+                        max_x = x;
+                        max_d = D;
+                }
+        }
+
+        printf("%ld\n", max_d);
+
+        return 0;
+
+
+}
+
+
+int64_t init_m(int64_t n)
+{
+
+        int64_t m = 1;
+        int64_t min_sol = n * n;
+        int64_t min_m = n * n;
+        int64_t last_k  = n * n;
+
+        for( ; ; m++){
+
+                int64_t k = ABS((m * m) - n);
+
+                if(k < min_sol){
+                        min_sol = k;
+                        min_m = m;
+                }
+
+                if(k > last_k){
+                        break;
+                }
+
+                last_k = k;
+
+        }
+
+        return min_m;
+}
+
+/* The limit that we impose upon this solution is a massive hack so we can
+ * operate with 64bit integers. Looking at all of the solutions where there is
+ * still a remainder for k at the end of this, the remainder is on the same
+ * roughly on the same order of magnitude as the limit we impose. This means
+ * that we are probably close, just a few iterations (albeit overflowing ones)
+ * before we hit the solution. Instead of employing a big integer solution, we
+ * can take the largest value of x for the order of magnitude is sufficient for
+ * the numbers to be comparable */
+int64_t diophantine_minimise_x(int64_t n)
+{
+        if(perfect_square(n)){
+                return 0;
+        }
+
+        int64_t m = init_m(n);
+
+        int64_t a = m;
+        int64_t b = 1;
+
+        int64_t k = (m * m) - n;
+        int64_t tmp_a;
+
+        for( ; m < 1000; ){
+
+                /* This means that we have an overflow, and if k is that big
+                 * anyway, it will make x smaller than other solutions */
+                if(k == 0){
+                        return 0;
+                }
+
+                /* We only want solutions with integer solutions to
+                        (a + bm)/k */
+                if((a + b * m) % ABS(k) != 0){
+                        m++;
+                        continue;
+                }
+
+                tmp_a = a;
+
+                /* We proceed by the Chakravala method for an efficient way of
+                 * solving Pell's equation */
+                a = (tmp_a * m + (n * b)) / ABS(k);
+                b = (tmp_a + (b * m))/ ABS(k);
+                k = ((m * m) - n) / k;
+
+                if(k == 1){
+                        break;
+                }
+
+                m = 2;
+
+        }
+
+        return a;
+}
+
+
+int64_t perfect_square(int64_t n)
+{
+        int64_t x = round(sqrt((double) n));
+        return (x * x) == n;
+}
+
diff --git a/code/train/C/0149836_bsdiff.c b/code/train/C/0149836_bsdiff.c
new file mode 100644
index 0000000000000000000000000000000000000000..71728f218db3a57c8742a989d509bafefa9b9489
--- /dev/null
+++ b/code/train/C/0149836_bsdiff.c
@@ -0,0 +1,242 @@
+/*
+  Copyright (C) 2003-2005 Brian Harring
+
+  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, US 
+*/
+#include <stdlib.h>
+#include <diffball/defs.h>
+#include <string.h>
+#include <diffball/dcbuffer.h>
+#include <diffball/bit-functions.h>
+#include <diffball/bsdiff.h>
+
+unsigned long
+bsdiff_overlay_read(u_dcb_src uc, unsigned long pos, unsigned char *buff, unsigned long len)
+{
+	return 0L;
+}
+
+unsigned long
+bsdiff_apply_overlay(cfile *cfh, unsigned long src_pos, unsigned char *buff, 
+	unsigned long len)
+{
+	cfile_window *scfw;
+	unsigned char *p;
+	p = buff;
+	scfw = expose_page(cfh);
+	while(p != buff + len) {
+			if(scfw->pos == scfw->end) {
+				scfw = next_page(cfh);
+				if (scfw->end == 0)
+						return p - buff;
+			}
+			*p += scfw->buff[scfw->pos];
+			p++; 
+			scfw->pos++;
+	}
+	return p - buff;
+}
+
+unsigned long 
+bsdiff_overlay_copy(DCommand *dc, 
+	cfile *out_cfh)
+{
+	#define MIN(x,y) ((x) < (y) ? (x) : (y))
+	cfile_window *cfw;
+	cfile_window *ocfw;
+	unsigned long bytes_wrote = 0;
+	unsigned long com_len;
+	unsigned long tmp_len;
+	unsigned long commands_read = 0;
+	DCLoc *dptr;  DCB_registered_src *dsrc;
+	overlay_chain *ov;
+	ov = dc->dcb_src->ov;
+
+	// error checking...
+	v3printf("processing src(%llu), len(%u), ver(%llu)\n", (act_off_u64)dc->data.src_pos, dc->data.len, (act_off_u64)dc->data.ver_pos);
+	cflush(out_cfh);
+	if(dc->data.src_pos != cseek(dc->dcb_src->src_ptr.cfh, dc->data.src_pos, CSEEK_FSTART)) {
+			return 0L;
+	}
+	cfw = expose_page(dc->dcb_src->src_ptr.cfh);
+	ocfw = expose_page(out_cfh);
+	commands_read = 1;
+	while(dc->ov_len > commands_read) {
+			com_len = 0;
+		dptr = ov->command + dc->ov_offset + commands_read;
+		dsrc = &dc->dcb_ptr->srcs[ov->src_id[dc->ov_offset + commands_read]];
+		while(dptr->len > com_len) {
+			tmp_len = MIN(dptr->len - com_len, ocfw->size);
+			if(tmp_len != dsrc->read_func(dsrc->src_ptr, 
+					dptr->offset + com_len, ocfw->buff, tmp_len)) {
+				// note thate just the previous byte_count is returned.
+				// that number contains the copyed (eg read AND overlayed)
+				// don't want the data to be considered valid, hence leavng ocfw->pos as 0.
+				printf("bailing\n");
+					return bytes_wrote;
+			}
+			while(ocfw->pos < tmp_len) {
+					if(cfw->pos < cfw->end) {
+						ocfw->buff[ocfw->pos] += cfw->buff[cfw->pos];
+						cfw->pos++;
+						ocfw->pos++;
+					} else {
+					cfw = next_page(dc->dcb_src->src_ptr.cfh);
+					if(cfw->end == 0) {
+							return bytes_wrote + ocfw->pos;
+					}
+				}
+			}
+			ocfw->write_end = tmp_len;
+			cflush(out_cfh);
+			com_len += tmp_len;
+			bytes_wrote += tmp_len;
+		}
+		commands_read++;
+	}
+	return bytes_wrote;
+}
+
+
+unsigned int
+check_bsdiff_magic(cfile *patchf)
+{
+	unsigned char buff[BSDIFF_MAGIC_LEN];
+	cseek(patchf, 0, CSEEK_FSTART);
+	if(BSDIFF_MAGIC_LEN != cread(patchf, buff, BSDIFF_MAGIC_LEN)) {
+		return 0;
+	}
+	if(memcmp(buff, BSDIFF4_MAGIC, BSDIFF_MAGIC_LEN)!=0 && 
+		memcmp(buff, BSDIFF3_MAGIC, BSDIFF_MAGIC_LEN)!=0 && 
+		memcmp(buff, BSDIFF_QS_MAGIC, BSDIFF_MAGIC_LEN)!=0) {
+		return 0;
+	}
+	return 2;
+}
+
+/* note this currently only supports u32, no u64. yet */
+signed int 
+bsdiffReconstructDCBuff(DCB_SRC_ID src_id, cfile *patchf, CommandBuffer *dcbuff)
+{
+	cfile ctrl_cfh, *diff_cfh, *extra_cfh = NULL;
+//  following variables are related to allowing conversion of bsdiff formats, 
+//  once a reference file option is added to convert_delta (if ever)
+//  note, this functionality is removed right now.  pull it from cvs when needed
+
+	EDCB_SRC_ID diff_id, extra_id = -1, ref_id;
+	unsigned char ver;
+	unsigned char buff[32];
+	off_u32 len1, len2, diff_offset, extra_offset;
+	off_s32 seek;
+	off_u32 diff_len, ctrl_len;
+	off_u64 ver_size;
+	off_u64 ver_pos, src_pos;
+
+	if(cread(patchf, buff, 32)!=32) {
+		return EOF_ERROR;
+	}
+	if(memcmp(buff, BSDIFF4_MAGIC, BSDIFF_MAGIC_LEN)==0) {
+		ver = 4;
+	} else if (memcmp(buff, BSDIFF3_MAGIC, BSDIFF_MAGIC_LEN) == 0 || 
+		memcmp(buff, BSDIFF_QS_MAGIC, BSDIFF_MAGIC_LEN) == 0) {
+		ver = 3;
+	} else {
+		return PATCH_CORRUPT_ERROR;
+	}
+
+	if((diff_cfh = (cfile *)malloc(sizeof(cfile)))==NULL ||
+		(ver == 4 && (extra_cfh = (cfile *)malloc(sizeof(cfile)))==NULL)) {
+		return MEM_ERROR;
+	}
+	ctrl_len = readUBytesLE(buff + 8, 4);
+	diff_len = readUBytesLE(buff + 16, 4);
+	ver_size = readUBytesLE(buff + 24, 4);
+	dcbuff->ver_size = ver_size;
+	v1printf("start=32, ctrl_len=%u, diff_len=%u, ver_size=%llu\n", 
+		ctrl_len, diff_len, (act_off_u64)ver_size);
+	if(copen_child_cfh(&ctrl_cfh, patchf, 32, ctrl_len + 32,
+		BZIP2_COMPRESSOR, CFILE_RONLY)) {
+		return MEM_ERROR;
+	} else if (copen_child_cfh(diff_cfh, patchf, ctrl_len + 32, 
+		diff_len + ctrl_len + 32, BZIP2_COMPRESSOR, 
+		CFILE_RONLY)) {
+		return MEM_ERROR;
+	} else if(ver  == 4 && copen_child_cfh(extra_cfh, patchf, 
+		ctrl_len + diff_len + 32, cfile_len(patchf),
+		BZIP2_COMPRESSOR, CFILE_RONLY)) {
+		return MEM_ERROR;
+	}
+	
+	ref_id = src_id;
+	diff_id = DCB_register_overlay_src(dcbuff, diff_cfh,  &bsdiff_overlay_read, 
+			&bsdiff_overlay_copy, NULL, (unsigned char)DCB_FREE_SRC_CFH);
+	if(ver == 4) {
+		extra_id = DCB_REGISTER_ADD_SRC(dcbuff, extra_cfh, NULL, 1);
+	}
+	
+	ver = (ver -1) *8;
+	src_pos = ver_pos = 0;
+	diff_offset = extra_offset = 0;
+	len2 = 0;
+	while(cread(&ctrl_cfh, buff, ver)==ver) {
+		len1 = readUBytesLE(buff, 4);
+		if(ver > 16) {
+			len2 = readUBytesLE(buff + 8, 4);
+			seek = readUBytesLE(buff + 16, 4);
+			if(buff[23] & 0x80) {
+				seek = -seek;
+			}
+			v2printf("len1(%u), len2(%u), seek(%u)\n", len1, len2, seek);
+		} else {
+			seek = readUBytesLE(buff + 8, 4);
+			if(buff[15] & 0x80) {
+				seek = -seek;
+			}
+			v2printf("len1(%u), seek(%d)\n", len1, seek);
+		}
+		 if(len1) {
+			DCB_add_overlay(dcbuff, diff_offset, len1, diff_id, src_pos, ref_id);
+ 
+			 diff_offset += len1;
+			 src_pos += len1;
+			 ver_pos += len1;
+		 }
+		if(len2) {
+			DCB_add_add(dcbuff, extra_offset, len2, extra_id);
+			extra_offset+=len2;
+			ver_pos += len2;
+		}
+		src_pos += seek;
+		assert(ver_pos == dcbuff->reconstruct_pos);
+		assert(ver_pos <= ver_size);
+	}
+	v1printf("ver_pos=%llu, size=%llu, extra_pos=%u, diff_pos=%u, ctrl_pos=%llu, recon=%llu\n", (act_off_u64)ver_pos, (act_off_u64)ver_size, 
+		extra_offset, diff_offset, (act_off_u64)ctrl_cfh.data.pos + ctrl_cfh.data.offset, 
+		(act_off_u64)dcbuff->reconstruct_pos);
+	if(ver_pos != ver_size) {
+		printf("error detected, aborting...\n");
+		return PATCH_CORRUPT_ERROR;
+	}
+	cclose(&ctrl_cfh);
+	return 0;
+}
+
+signed int 
+bsdiffEncodeDCBuffer(CommandBuffer *buffer, cfile *ver_cfh, cfile *out_cfh)
+{
+	return 0;
+}
+
+
diff --git a/code/train/C/0149954_exercise15.c b/code/train/C/0149954_exercise15.c
new file mode 100644
index 0000000000000000000000000000000000000000..9e5d369a313b4ace2e8650e97d8c3d838d8ed700
--- /dev/null
+++ b/code/train/C/0149954_exercise15.c
@@ -0,0 +1,205 @@
+/* Copyright (C) 2015 Felipe de Lima Peressim
+ 
+ * 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/>.
+ */
+
+/* Exercise 5-15. Add the option -f to fold upper and lower case together, so that case distinctions are not made during sorting; 
+ * for example, a and A compare equal. 
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MAXLINES 5000           /* max #lines to be sorted */
+char *lineptr[MAXLINES];        /* pointers to text lines */
+
+int readlines(char *lineptr[], int nlines);
+void writelines(char *lineptr[], int nlines);
+
+void lqsort(void *lineptr[], int left, int right, int (*comp) (void *, void*));
+int numcmp(char *, char *);
+int my_strcmp(char *s1, char *s2);
+int decrease = 0;
+int fold = 0;
+
+/* sort input lines */
+int main(int argc, char *argv[])
+{       
+        int nlines;             /* number of input lines read */
+        int numeric = 0;        /* 1 if numeric sort */
+
+        if (argc > 1 && strcmp(argv[1], "-n") == 0)
+                numeric = 1;
+	else if (argc > 1 && strcmp(argv[1], "-r") == 0)
+		decrease = 1;
+	else if (argc > 1 && strcmp(argv[1], "-f") == 0)
+                fold = 1;
+	else if (argc > 1 && (strcmp(argv[1], "-fr") == 0 || strcmp(argv[1], "-rf") == 0)) { 
+                decrease = 1;
+		fold = 1;
+	}
+	else if (argc > 1 && (strcmp(argv[1], "-nr") == 0 || strcmp(argv[1], "-rn") == 0)) {
+		numeric = 1;
+		decrease = 1;
+	}
+	else if (argc > 1) {
+		printf("Options: -n\tNumeric comparrision\n\t -r\tPrint in reverse order\nUsage: ./a.out -flags\n");
+		return 1;
+	}
+        if ((nlines = readlines(lineptr, MAXLINES)) >= 0) { 
+                lqsort((void **) lineptr, 0, nlines-1, (int (*)(void*,void*))(numeric ? numcmp : my_strcmp));
+                writelines(lineptr, nlines);
+                return 0;
+        } else {
+                printf("input too big to sort\n");
+                return 1;
+        }
+}
+#define MAXLEN 1000     /* max lenght of any input line */
+int lgetline(char *, int);
+char *alloc(int);
+
+/* readlines: read input lines */
+int readlines(char *lineptr[], int maxlines)
+{       
+        int len, nlines;
+        char *p, line[MAXLEN];
+        
+        nlines = 0; 
+        while ((len = lgetline(line, MAXLEN)) > 0)
+                if (nlines >= maxlines || (p = alloc(len)) == NULL)
+                        return -1;
+                else {  
+                        line[len-1] = '\0';     /* delete newline */
+                        strcpy(p, line);
+                        lineptr[nlines++] = p;
+                }
+	lineptr[nlines] = NULL;
+        return nlines;
+}
+/* writelines: write output line */
+void writelines(char *lineptr[], int nlines)
+{
+	while ( nlines-- > 0) {
+               	printf("%s\n", *lineptr++); 
+	}	
+}
+
+int lgetline(char *s, int lim)
+{
+        int c, i;
+
+        for (i = 0; i < lim-1 && (c=getchar()) != EOF && c != '\n'; ++i)
+                *(s++) = c;
+        if (c == '\n') {
+                *(s++) = c;
+                ++i;
+        }
+        *s = '\0';
+        return i;
+}
+#define ALLOCSIZE 10000 /* size of available space */
+
+static char allocbuf[ALLOCSIZE];        /* storage for alloc */
+static char *allocp = allocbuf;         /* next free position */
+
+char *alloc(int n)      /* return pointer to n characters */
+{
+        if (allocbuf + ALLOCSIZE - allocp >= n) { /* it fits */
+                allocp += n;
+                return allocp - n;      /* old p */
+        } else  /* not enough room */
+                return 0;
+}
+
+void afree(char *p)     /* free storage pointed to by p */
+{
+        if (p >= allocbuf && p < allocbuf + ALLOCSIZE)
+                allocp = p;
+}
+
+/* qsort: sort v[left]...v[right] onto increasing order */
+void lqsort(void *v[], int left, int right, int (*comp) (void *, void *))
+{
+        int i, last;
+        void swap(void *v[], int, int);
+
+        if (left >= right)      /* do nothing if array contains */
+                return;         /* fewer than two elements */
+        swap(v, left, (left + right) / 2);
+        last = left;
+        for (i = left+1; i <= right; i++)
+        last = left;
+        for (i = left+1; i <= right; i++)
+                if ((*comp)(v[i], v[left]) < 0)
+                        swap(v, ++last, i);
+        swap(v, left, last);
+        lqsort(v, left, last-1, comp);
+        lqsort(v, last+1, right, comp);
+}
+
+/* numcmp: compare s1 and s2 numerically */
+int numcmp(char *s1, char *s2)
+{
+        double v1, v2;
+
+        v1 = atof(s1);
+        v2 = atof(s2);
+	if (v1 == v2)
+		return 0;
+ 	if (decrease == 0) {
+	        if (v1 < v2)
+        	        return -1;
+		else
+                	return 1;
+	}
+	else {
+		if (v1 < v2)
+                	return 1;
+                else
+			return -1;
+	}
+}
+
+#include <ctype.h>
+
+int my_strcmp(char *s1, char *s2)
+{
+	while (*s1++ == *s2++)
+		;
+	if (*s1 == '\0' && *s2 == '\0')
+		return s1 - s2;
+	if (decrease == 0) {
+		if (fold == 0)
+			return (*s1 < *s2) ? -1 : 1;
+		else
+			return (tolower(*s1) < tolower(*s2)) ? -1 : 1;
+	}
+	else  {
+		if (fold == 0)
+			return (*s1 < *s2) ? 1 : -1;
+		else
+	                return (tolower(*s1) < tolower(*s2)) ? 1 : -1;
+	}
+}
+
+void swap(void *v[], int i, int j)
+{
+        void *temp;
+
+        temp = v[i];
+        v[i] = v[j];
+        v[j] = temp;
+}
diff --git a/code/train/C/0149962_qcs_hash_table.c b/code/train/C/0149962_qcs_hash_table.c
new file mode 100644
index 0000000000000000000000000000000000000000..5da1036de3a136eac01a148ee429d8370532a744
--- /dev/null
+++ b/code/train/C/0149962_qcs_hash_table.c
@@ -0,0 +1,193 @@
+/***************************************************************************
+ *   Copyright (C) 2005 -- 2011 by Marek Sawerwain                         *
+ *                                         <M.Sawerwain@gmail.com>         *
+ *                                                                         *
+ *   Part of the Quantum Computing Simulator:                              *
+ *   http://code.google.com/p/qcs                                          *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/ 
+
+#include<string.h>
+#include<stdio.h>
+
+#include "qcs.h"
+#include "qcs_hash_table.h"
+
+static char *mystrdup(const char *s)
+{
+	char *b;
+
+	if(!(b=malloc(strlen(s)+1))) return NULL;
+
+	strcpy(b, s);
+
+	return b;
+}
+
+static qcs_hash_table_size def_hashfunc(const char *key)
+{
+	qcs_hash_table_size hash=0;
+
+	while( *key )
+        hash += (unsigned char)*key++;
+
+	return hash;
+}
+
+DYNAMIC_LIB_DECORATION t_qcs_hash_table *qcs_hash_table_create(qcs_hash_table_size size, qcs_hash_table_size (*hash_func)(const char *))
+{
+	t_qcs_hash_table *hashtbl;
+
+	if(!(hashtbl=malloc(sizeof(t_qcs_hash_table)))) return NULL;
+
+	if(!(hashtbl->nodes=calloc(size, sizeof(struct t_qcs_hash_table_node *))))
+	{
+		free(hashtbl);
+		return NULL;
+	}
+
+	hashtbl->size = size;
+
+	if(hash_func)
+        hashtbl->qcs_hash_table_func = hash_func ;
+	else
+        hashtbl->qcs_hash_table_func = def_hashfunc ;
+
+	return hashtbl;
+}
+
+
+DYNAMIC_LIB_DECORATION void qcs_hash_table_destroy(t_qcs_hash_table *hash_tbl)
+{
+	qcs_hash_table_size n;
+	t_qcs_hash_table_node *node, *oldnode;
+
+	for( n = 0 ; n < hash_tbl->size ; n++ )
+	{
+		node = hash_tbl->nodes[n];
+
+		while(node)
+		{
+			free(node->key);
+			oldnode=node;
+			node=node->next;
+			free(oldnode);
+		}
+	}
+
+	free(hash_tbl->nodes);
+	free(hash_tbl);
+}
+
+DYNAMIC_LIB_DECORATION int qcs_hash_table_insert(t_qcs_hash_table *hash_tbl, const char *key, void *data)
+{
+	t_qcs_hash_table_node *node;
+
+	qcs_hash_table_size hash=hash_tbl->qcs_hash_table_func(key) % hash_tbl->size;
+
+
+//	fprintf(stderr, "hashtbl_insert() key=%s, hash=%d, data=%s\n", key, hash, (char*)data);
+
+	node = hash_tbl->nodes[hash];
+	while(node)
+	{
+		if(!strcmp(node->key, key))
+		{
+			node->data=data;
+			return 0;
+		}
+		node = node->next;
+	}
+
+
+	if(!(node=malloc(sizeof(t_qcs_hash_table_node)))) return -1;
+	if(!(node->key=mystrdup(key)))
+	{
+		free(node);
+		return -1;
+	}
+	node->data=data;
+	node->next=hash_tbl->nodes[hash];
+	hash_tbl->nodes[hash]=node;
+
+
+	return 0;
+}
+
+DYNAMIC_LIB_DECORATION int qcs_hash_table_remove(t_qcs_hash_table *hash_tbl, const char *key)
+{
+	t_qcs_hash_table_node *node, *prev_node=NULL;
+	qcs_hash_table_size hash=hash_tbl->qcs_hash_table_func(key) % hash_tbl->size;
+
+	node=hash_tbl->nodes[hash];
+	while(node)
+	{
+		if(!strcmp(node->key, key))
+		{
+			free(node->key);
+
+			if(prev_node)
+                prev_node->next=node->next;
+			else
+                hash_tbl->nodes[hash]=node->next;
+
+			free(node);
+
+			return 0;
+		}
+		prev_node=node;
+		node=node->next;
+	}
+
+	return -1;
+}
+
+DYNAMIC_LIB_DECORATION void *qcs_hash_table_get(t_qcs_hash_table *hash_tbl, const char *key)
+{
+	t_qcs_hash_table_node *node;
+	qcs_hash_table_size hash = hash_tbl->qcs_hash_table_func(key) % hash_tbl->size;
+
+//	fprintf(stderr, "hashtbl_get() key=%s, hash=%d\n", key, hash);
+
+	node=hash_tbl->nodes[hash];
+	while(node)
+	{
+		if(!strcmp(node->key, key)) return node->data;
+		node  = node->next;
+	}
+
+	return NULL;
+}
+
+DYNAMIC_LIB_DECORATION void qcs_hash_table_basic_display(t_qcs_hash_table *hash_tbl, FILE *f)
+{
+	qcs_hash_table_size n;
+	t_qcs_hash_table_node *node, *oldnode;
+
+	for( n = 0 ; n < hash_tbl->size ; n++ )
+	{
+	    fprintf(f, "entry: %ld [\n", n);
+		node = hash_tbl->nodes[n];
+		while(node)
+		{
+			fprintf(f, " %s", node->key);
+			node=node->next;
+		}
+		fprintf(f, "\n]\n");
+	}
+
+}