text: // ******************************************************** 
  
  // This C++ code was automatically generated by ml2cpp (development version).
  // Copyright 2020
  
  // https://github.com/antoinecarme/ml2cpp
  // Model : XGBClassifier_Pipeline
  // Dataset : iris
  
  // This CPP code can be compiled using any C++-17 compiler.
  // g++ -Wall -Wno-unused-function -std=c++17 -g -o ml2cpp-demo_XGBClassifier_Pipeline_iris.exe ml2cpp-demo_XGBClassifier_Pipeline_iris.cpp
  
  // Model deployment code
  
  // ******************************************************** 
  
  #include "../../Generic.i"
  
  namespace  {
  
  	std::vector<std::any> get_classes(){
  		std::vector<std::any> lClasses = { 0, 1, 2 };
  
  		return lClasses;
  	}
  
  	namespace imputer {
  	
  		std::vector<std::string> get_input_names(){
  			std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3" };
  	
  			return lFeatures;
  		}
  	
  		std::vector<std::string> get_output_names(){
  			std::vector<std::string> lOutputs = { "imputer_output_2", "imputer_output_3", "imputer_output_4", "imputer_output_5" };
  	
  			return lOutputs;
  		}
  	
  		tTable compute_features(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3) {
  	
  			tTable lTable;
  	
  			lTable["imputer_output_2"] = { ((Feature_0 == std::any()) ?  ( 5.8474999999999975 ) : ( Feature_0)) };
  			lTable["imputer_output_3"] = { ((Feature_1 == std::any()) ?  ( 3.040833333333332 ) : ( Feature_1)) };
  			lTable["imputer_output_4"] = { ((Feature_2 == std::any()) ?  ( 3.844166666666667 ) : ( Feature_2)) };
  			lTable["imputer_output_5"] = { ((Feature_3 == std::any()) ?  ( 1.2458333333333336 ) : ( Feature_3)) };
  	
  			return lTable;
  		}
  	
  		tTable compute_model_outputs_from_table( tTable const & iTable) {
  			tTable lTable = compute_features(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0]);
  	
  			return lTable;
  		}
  	
  	} // eof namespace imputer
  	
  
  	namespace scaler {
  	
  		std::vector<std::string> get_input_names(){
  			std::vector<std::string> lFeatures = { "imputer_output_2", "imputer_output_3", "imputer_output_4", "imputer_output_5" };
  	
  			return lFeatures;
  		}
  	
  		std::vector<std::string> get_output_names(){
  			std::vector<std::string> lOutputs = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  	
  			return lOutputs;
  		}
  	
  		tTable compute_features(std::any imputer_output_2, std::any imputer_output_3, std::any imputer_output_4, std::any imputer_output_5) {
  	
  			tTable lTable;
  	
  			lTable["scaler_output_2"] = { ( ( imputer_output_2 - 5.8474999999999975 ) / 0.827039146594646 ) };
  			lTable["scaler_output_3"] = { ( ( imputer_output_3 - 3.040833333333332 ) / 0.43922200789830873 ) };
  			lTable["scaler_output_4"] = { ( ( imputer_output_4 - 3.844166666666667 ) / 1.7109839193347847 ) };
  			lTable["scaler_output_5"] = { ( ( imputer_output_5 - 1.2458333333333336 ) / 0.7486538845747673 ) };
  	
  			return lTable;
  		}
  	
  		tTable compute_model_outputs_from_table( tTable const & iTable) {
  			tTable lTable = compute_features(iTable.at("imputer_output_2")[0], iTable.at("imputer_output_3")[0], iTable.at("imputer_output_4")[0], iTable.at("imputer_output_5")[0]);
  	
  			return lTable;
  		}
  	
  	} // eof namespace scaler
  	
  
  	namespace model {
  	
  		std::vector<std::any> get_classes(){
  			std::vector<std::any> lClasses = { 0, 1, 2 };
  	
  			return lClasses;
  		}
  	
  		namespace XGB_Tree_0_0 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {0.424203843 }} ,
  					{ 2 ,  {-0.219061613 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < -0.814833283 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_0
  		
  	
  		namespace XGB_Tree_1_0 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {-0.212101951 }} ,
  					{ 3 ,  {0.392727286 }} ,
  					{ 4 ,  {-0.170270294 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < -0.814833283 ) ? ( 1 ) : ( ( scaler_output_4 < 0.587868333 ) ? ( 3 ) : ( 4 ) );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_0
  		
  	
  		namespace XGB_Tree_2_0 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {-0.201277986 }} ,
  					{ 2 ,  {0.384324342 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < 0.587868333 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_0
  		
  	
  		namespace XGB_Tree_0_1 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {0.29374373 }} ,
  					{ 2 ,  {-0.196091712 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < -0.814833283 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_1
  		
  	
  		namespace XGB_Tree_1_1 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 2 ,  {-0.180128545 }} ,
  					{ 3 ,  {-0.18836607 }} ,
  					{ 4 ,  {0.262382179 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_5 < 0.67343092 ) ? ( ( scaler_output_4 < -0.814833283 ) ? ( 3 ) : ( 4 ) ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_1
  		
  	
  		namespace XGB_Tree_2_1 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 2 ,  {0.288523525 }} ,
  					{ 3 ,  {-0.193561107 }} ,
  					{ 4 ,  {-0.101268761 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_5 < 0.539857864 ) ? ( ( scaler_output_2 < -0.117890432 ) ? ( 3 ) : ( 4 ) ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_1
  		
  	
  		namespace XGB_Tree_0_2 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {0.235035926 }} ,
  					{ 2 ,  {-0.180885702 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < -0.814833283 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_2
  		
  	
  		namespace XGB_Tree_1_2 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 2 ,  {-0.18022272 }} ,
  					{ 3 ,  {-0.17220664 }} ,
  					{ 5 ,  {0.234874919 }} ,
  					{ 6 ,  {0.138648033 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < 0.704760194 ) ? ( ( scaler_output_4 < -0.814833283 ) ? ( 3 ) : ( ( scaler_output_4 < 0.35408479 ) ? ( 5 ) : ( 6 ) ) ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_2
  		
  	
  		namespace XGB_Tree_2_2 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {-0.161172479 }} ,
  					{ 2 ,  {0.215844914 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < 0.587868333 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_2
  		
  	
  		namespace XGB_Tree_0_3 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {0.202856556 }} ,
  					{ 2 ,  {-0.17015931 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < -0.814833283 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_3
  		
  	
  		namespace XGB_Tree_1_3 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 2 ,  {-0.167039722 }} ,
  					{ 3 ,  {-0.11818748 }} ,
  					{ 4 ,  {0.15860258 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < 0.704760194 ) ? ( ( scaler_output_4 < -0.259597212 ) ? ( 3 ) : ( 4 ) ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_3
  		
  	
  		namespace XGB_Tree_2_3 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {-0.144913137 }} ,
  					{ 2 ,  {0.189143792 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_5 < 0.40628475 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_3
  		
  	
  		namespace XGB_Tree_0_4 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {0.183456451 }} ,
  					{ 2 ,  {-0.162424743 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < -0.814833283 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_4
  		
  	
  		namespace XGB_Tree_1_4 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 2 ,  {-0.131034434 }} ,
  					{ 3 ,  {-0.0753694326 }} ,
  					{ 4 ,  {0.154471502 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_5 < 0.539857864 ) ? ( ( scaler_output_5 < -0.261580586 ) ? ( 3 ) : ( 4 ) ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_4
  		
  	
  		namespace XGB_Tree_2_4 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {-0.147176549 }} ,
  					{ 2 ,  {0.15442808 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < 0.529422462 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_4
  		
  	
  		namespace XGB_Tree_0_5 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {0.170136407 }} ,
  					{ 2 ,  {-0.156103179 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < -0.814833283 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_5
  		
  	
  		namespace XGB_Tree_1_5 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 2 ,  {-0.0981252044 }} ,
  					{ 3 ,  {-0.035291709 }} ,
  					{ 4 ,  {0.135694861 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_5 < 0.40628475 ) ? ( ( scaler_output_4 < 0.0618552491 ) ? ( 3 ) : ( 4 ) ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_5
  		
  	
  		namespace XGB_Tree_2_5 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {-0.113073878 }} ,
  					{ 2 ,  {0.166775137 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < 0.646314263 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_5
  		
  	
  		namespace XGB_Tree_0_6 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {0.14238207 }} ,
  					{ 2 ,  {-0.150093779 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < -0.259597212 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_6
  		
  	
  		namespace XGB_Tree_1_6 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {0.0483991094 }} ,
  					{ 2 ,  {-0.0713306144 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < 0.529422462 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_6
  		
  	
  		namespace XGB_Tree_2_6 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {-0.101883739 }} ,
  					{ 2 ,  {0.155921906 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_5 < 0.67343092 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_6
  		
  	
  		namespace XGB_Tree_0_7 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 0 ,  {-0.00841712113 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = 0;
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_7
  		
  	
  		namespace XGB_Tree_1_7 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {0.0380957723 }} ,
  					{ 2 ,  {-0.0313301198 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_3 < -0.206805065 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_7
  		
  	
  		namespace XGB_Tree_2_7 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {-0.11234241 }} ,
  					{ 2 ,  {0.120162539 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < 0.587868333 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_7
  		
  	
  		namespace XGB_Tree_0_8 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 0 ,  {-0.00796850957 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = 0;
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_8
  		
  	
  		namespace XGB_Tree_1_8 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {0.0339897424 }} ,
  					{ 2 ,  {-0.0270754173 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_3 < -0.206805065 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_8
  		
  	
  		namespace XGB_Tree_2_8 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {-0.103382565 }} ,
  					{ 2 ,  {0.120745026 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_5 < 0.40628475 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_8
  		
  	
  		namespace XGB_Tree_0_9 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 0 ,  {-0.00740856072 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = 0;
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_9
  		
  	
  		namespace XGB_Tree_1_9 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {-0.0315100215 }} ,
  					{ 2 ,  {0.0289743468 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_2 < -0.117890432 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_9
  		
  	
  		namespace XGB_Tree_2_9 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 0 ,  {0.00493490091 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = 0;
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_9
  		
  	
  		namespace XGB_Tree_0_10 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 0 ,  {-0.00732709561 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = 0;
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_10
  		
  	
  		namespace XGB_Tree_1_10 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {-0.0277820118 }} ,
  					{ 2 ,  {0.0252261665 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_2 < -0.117890432 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_10
  		
  	
  		namespace XGB_Tree_2_10 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 0 ,  {0.00514176395 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = 0;
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_10
  		
  	
  		namespace XGB_Tree_0_11 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 0 ,  {-0.00710532907 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = 0;
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_11
  		
  	
  		namespace XGB_Tree_1_11 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {0.0266226269 }} ,
  					{ 2 ,  {-0.0219738483 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_3 < -0.206805065 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_11
  		
  	
  		namespace XGB_Tree_2_11 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 0 ,  {0.00514557771 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = 0;
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_11
  		
  	
  		namespace XGB_Tree_0_12 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 0 ,  {-0.00611767033 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = 0;
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_12
  		
  	
  		namespace XGB_Tree_1_12 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {-0.0253409147 }} ,
  					{ 2 ,  {0.0223979391 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_2 < -0.117890432 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_12
  		
  	
  		namespace XGB_Tree_2_12 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 0 ,  {0.00440833019 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = 0;
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_12
  		
  	
  		namespace XGB_Tree_0_13 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 0 ,  {-0.00601035962 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = 0;
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_13
  		
  	
  		namespace XGB_Tree_1_13 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {0.0231642779 }} ,
  					{ 2 ,  {-0.01956507 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_3 < -0.206805065 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_13
  		
  	
  		namespace XGB_Tree_2_13 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 0 ,  {0.00443863543 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = 0;
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_13
  		
  	
  		namespace XGB_Tree_0_14 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 0 ,  {-0.00518479012 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = 0;
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_14
  		
  	
  		namespace XGB_Tree_1_14 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {-0.0229822043 }} ,
  					{ 2 ,  {0.0199173167 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_2 < -0.117890432 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_14
  		
  	
  		namespace XGB_Tree_2_14 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 0 ,  {0.00379695487 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = 0;
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_14
  		
  	
  		namespace XGB_Tree_0_15 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 0 ,  {-0.00514737843 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = 0;
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					lNodeValue [0],
  					0.0,
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_0_15
  		
  	
  		namespace XGB_Tree_1_15 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {0.0216402039 }} ,
  					{ 2 ,  {-0.0224721469 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_5 < 0.272711694 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					lNodeValue [0],
  					0.0 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_1_15
  		
  	
  		namespace XGB_Tree_2_15 {
  		
  			std::vector<std::any> get_classes(){
  				std::vector<std::any> lClasses = { 0, 1, 2 };
  		
  				return lClasses;
  			}
  		
  			typedef std::vector<double> tNodeData;
  			std::map<int, tNodeData> Decision_Tree_Node_data = {
  					{ 1 ,  {-0.105153196 }} ,
  					{ 2 ,  {0.111213468 }} 
  			};
  			
  		
  			int get_decision_tree_node_index(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				int lNodeIndex = ( scaler_output_4 < 0.587868333 ) ? ( 1 ) : ( 2 );
  			
  				return lNodeIndex;
  			}
  			
  		
  			std::vector<std::string> get_input_names(){
  				std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  		
  				return lFeatures;
  			}
  		
  			std::vector<std::string> get_output_names(){
  				std::vector<std::string> lOutputs = { 
  					"Score_0", "Score_1", "Score_2",
  					"Proba_0", "Proba_1", "Proba_2",
  					"LogProba_0", "LogProba_1", "LogProba_2" };
  		
  				return lOutputs;
  			}
  		
  			tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  				auto lClasses = get_classes();
  		
  				int lNodeIndex = get_decision_tree_node_index(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5);
  		
  				std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
  		
  		
  				tTable lTable;
  		
  				lTable["Score"] = { 
  					0.0,
  					0.0,
  					lNodeValue [0] 
  				} ;
  				lTable["Proba"] = { 
  					std::any(),
  					std::any(),
  					std::any() 
  				} ;
  		
  				recompute_log_probas( lTable );
  		
  				return lTable;
  			}
  		
  			tTable compute_model_outputs_from_table( tTable const & iTable) {
  				tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  		
  				return lTable;
  			}
  		
  		} // eof namespace XGB_Tree_2_15
  		
  	
  		std::vector<std::string> get_input_names(){
  			std::vector<std::string> lFeatures = { "scaler_output_2", "scaler_output_3", "scaler_output_4", "scaler_output_5" };
  	
  			return lFeatures;
  		}
  	
  		std::vector<std::string> get_output_names(){
  			std::vector<std::string> lOutputs = { 
  				"Score_0", "Score_1", "Score_2",
  				"Proba_0", "Proba_1", "Proba_2",
  				"LogProba_0", "LogProba_1", "LogProba_2",
  				"Decision", "DecisionProba" };
  	
  			return lOutputs;
  		}
  	
  		tTable compute_classification_scores(std::any scaler_output_2, std::any scaler_output_3, std::any scaler_output_4, std::any scaler_output_5) {
  			auto lClasses = get_classes();
  	
  			std::vector<tTable> lTreeScores = { 
  				XGB_Tree_0_0::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_0::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_0::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_0_1::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_1::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_1::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_0_2::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_2::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_2::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_0_3::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_3::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_3::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_0_4::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_4::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_4::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_0_5::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_5::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_5::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_0_6::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_6::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_6::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_0_7::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_7::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_7::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_0_8::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_8::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_8::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_0_9::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_9::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_9::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_0_10::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_10::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_10::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_0_11::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_11::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_11::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_0_12::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_12::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_12::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_0_13::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_13::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_13::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_0_14::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_14::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_14::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_0_15::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_1_15::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5),
  				XGB_Tree_2_15::compute_classification_scores(scaler_output_2, scaler_output_3, scaler_output_4, scaler_output_5)
  			};
  	
  			tTable lAggregatedTable = aggregate_xgb_scores(lTreeScores, {"Score"});
  	
  			tTable lSoftMaxTable = soft_max(lAggregatedTable);
  	
  	
  			tTable lTable = lSoftMaxTable;
  	
  			int lBestClass = get_arg_max( lTable["Proba"] );
  			auto lDecision = lClasses[lBestClass];
  			lTable["Decision"] = { lDecision } ;
  			lTable["DecisionProba"] = { lTable["Proba"][lBestClass] };
  	
  			recompute_log_probas( lTable );
  	
  			return lTable;
  		}
  	
  		tTable compute_model_outputs_from_table( tTable const & iTable) {
  			tTable lTable = compute_classification_scores(iTable.at("scaler_output_2")[0], iTable.at("scaler_output_3")[0], iTable.at("scaler_output_4")[0], iTable.at("scaler_output_5")[0]);
  	
  			return lTable;
  		}
  	
  	} // eof namespace model
  	
  
  	std::vector<std::string> get_input_names(){
  		std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3" };
  
  		return lFeatures;
  	}
  
  	std::vector<std::string> get_output_names(){
  		std::vector<std::string> lOutputs = { 
  			"Score_0", "Score_1", "Score_2",
  			"Proba_0", "Proba_1", "Proba_2",
  			"LogProba_0", "LogProba_1", "LogProba_2",
  			"Decision", "DecisionProba" };
  
  		return lOutputs;
  	}
  
  	tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3) {
  		auto lClasses = get_classes();
  
  		tTable lTable_imputer = imputer::compute_features(Feature_0, Feature_1, Feature_2, Feature_3);
  
  		tTable lTable_scaler = scaler::compute_model_outputs_from_table( lTable_imputer );
  
  		tTable lTable_model = model::compute_model_outputs_from_table( lTable_scaler );
  
  
  		tTable lTable = lTable_model;
  
  		int lBestClass = get_arg_max( lTable["Proba"] );
  		auto lDecision = lClasses[lBestClass];
  		lTable["Decision"] = { lDecision } ;
  		lTable["DecisionProba"] = { lTable["Proba"][lBestClass] };
  
  		recompute_log_probas( lTable );
  
  		return lTable;
  	}
  
  	tTable compute_model_outputs_from_table( tTable const & iTable) {
  		tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0]);
  
  		return lTable;
  	}
  
  } // eof namespace 
  
  
  int main() {
  	score_csv_file("outputs/ml2cpp-demo/datasets/iris.csv");
  	return 0;
  }
  