diff --git a/cpp/ms_dsge_c_driver.cc b/cpp/ms_dsge_c_driver.cc
index 4fdcc184273f6973763c1f9991445f2769cb8afc..6815205312b12c870e39226bb1245a7febf50fb1 100644
--- a/cpp/ms_dsge_c_driver.cc
+++ b/cpp/ms_dsge_c_driver.cc
@@ -379,3 +379,40 @@ ModFileMeasurementErrorCorrPrior::ModFileMeasurementErrorCorrPrior(const int ind
   assert(index2 >= 0);
 }
 
+BasicModFileOption::BasicModFileOption(const int index_arg,
+                                       const double init_arg) :
+  index(index_arg),
+  init(init_arg)
+{
+  assert(index >= 0);
+  assert(!isnan(init));
+}
+
+ModFileOption::ModFileOption(const int index_arg, const double init_arg) :
+  BasicModFileOption(index_arg, init_arg)
+{
+}
+
+ModFileStructuralInnovationOption::ModFileStructuralInnovationOption(const int index_arg, const double init_arg) :
+  BasicModFileOption(index_arg, init_arg)
+{
+}
+
+ModFileMeasurementErrorOption::ModFileMeasurementErrorOption(const int index_arg, const double init_arg) :
+  BasicModFileOption(index_arg, init_arg)
+{
+}
+
+ModFileStructuralInnovationCorrOption::ModFileStructuralInnovationCorrOption(const int index1_arg, const int index2_arg, const double init_arg) :
+  BasicModFileOption(index1_arg, init_arg),
+  index2(index2_arg)
+{
+  assert(index2 >= 0);
+}
+
+ModFileMeasurementErrorCorrOption::ModFileMeasurementErrorCorrOption(const int index1_arg, const int index2_arg, const double init_arg) :
+  BasicModFileOption(index1_arg, init_arg),
+  index2(index2_arg)
+{
+  assert(index2 >= 0);
+}
diff --git a/cpp/ms_dsge_c_driver.hh b/cpp/ms_dsge_c_driver.hh
index 325255e95b7b9a65ed6ffb1a5dff04f7c7391db9..27ceed0780922858ec7b15ea6034ecaf782bea95 100644
--- a/cpp/ms_dsge_c_driver.hh
+++ b/cpp/ms_dsge_c_driver.hh
@@ -167,6 +167,62 @@ public:
                                    const vector <double> domain_arg);
 };
 
+class BasicModFileOption
+{
+private:
+  inline bool isnan(double x) const { return (x!=x); };
+protected:
+  const int index;
+  const double init;
+
+  BasicModFileOption(const int index_arg,
+                     const double init_arg);
+public:
+  inline int get_index() const { return index; };
+  inline double get_init() const { return init; };
+};
+
+class ModFileOption : public BasicModFileOption
+{
+public:
+  ModFileOption(const int index_arg,
+                const double init_arg);
+};
+
+class ModFileStructuralInnovationOption: public BasicModFileOption
+{
+public:
+  ModFileStructuralInnovationOption(const int index_arg,
+                                    const double init_arg);
+};
+
+class ModFileMeasurementErrorOption : public BasicModFileOption
+{
+public:
+  ModFileMeasurementErrorOption(const int index_arg,
+                                const double init_arg);
+};
+
+class ModFileStructuralInnovationCorrOption : public BasicModFileOption
+{
+private:
+  const int index2;
+public:
+  ModFileStructuralInnovationCorrOption(const int index1_arg,
+                                        const int index2_arg,
+                                        const double init_arg);
+};
+
+class ModFileMeasurementErrorCorrOption : public BasicModFileOption
+{
+private:
+  const int index2;
+public:
+  ModFileMeasurementErrorCorrOption(const int index1_arg,
+                                    const int index2_arg,
+                                    const double init_arg);
+};
+
 class MsDsgeInfo
 {
 private:
@@ -176,6 +232,11 @@ private:
   vector<ModFileMeasurementErrorPrior *> measurement_error_prior_vector;
   vector<ModFileStructuralInnovationCorrPrior *> structural_innovation_corr_prior_vector;
   vector<ModFileMeasurementErrorCorrPrior *> measurement_error_corr_prior_vector;
+  vector<ModFileOption *> option_vector;
+  vector<ModFileStructuralInnovationOption *> structural_innovation_option_vector;
+  vector<ModFileMeasurementErrorOption *> measurement_error_option_vector;
+  vector<ModFileStructuralInnovationCorrOption *> structural_innovation_corr_option_vector;
+  vector<ModFileMeasurementErrorCorrOption *> measurement_error_corr_option_vector;
   map<string, int > exo_names, exo_det_names, endo_names, param_names;
   map<int, double > params;
   vector<aux_vars_t> aux_vars;
@@ -197,12 +258,19 @@ public:
   ~MsDsgeInfo();
 
   inline void addMarkovSwitching(MarkovSwitching *ms) { markov_switching_vector.push_back(ms); };
+
   inline void addPrior(ModFilePrior *p) { prior_vector.push_back(p); };
   inline void addStructuralInnovationPrior(ModFileStructuralInnovationPrior *sip) { structural_innovation_prior_vector.push_back(sip); };
   inline void addMeasurementErrorPrior(ModFileMeasurementErrorPrior *mep) { measurement_error_prior_vector.push_back(mep); };
   inline void addStructuralInnovationCorrPrior(ModFileStructuralInnovationCorrPrior *sicp) { structural_innovation_corr_prior_vector.push_back(sicp); };
   inline void addMeasurementErrorCorrPrior(ModFileMeasurementErrorCorrPrior *mecp) { measurement_error_corr_prior_vector.push_back(mecp); };
 
+  inline void addOption(ModFileOption *o) { option_vector.push_back(o); };
+  inline void addStructuralInnovationOption(ModFileStructuralInnovationOption *sio) { structural_innovation_option_vector.push_back(sio); };
+  inline void addMeasurementErrorOption(ModFileMeasurementErrorOption *meo) { measurement_error_option_vector.push_back(meo); };
+  inline void addStructuralInnovationCorrOption(ModFileStructuralInnovationCorrOption *sico) { structural_innovation_corr_option_vector.push_back(sico); };
+  inline void addMeasurementErrorCorrOption(ModFileMeasurementErrorCorrOption *meco) { measurement_error_corr_option_vector.push_back(meco); };
+
   inline bool markov_switching_has_val() { return !markov_switching_vector.empty(); };
   inline bool prior_has_val() { return !prior_vector.empty(); };
   inline bool structural_innovation_prior_has_val() { return !structural_innovation_prior_vector.empty(); };
@@ -210,12 +278,25 @@ public:
   inline bool structural_innovation_corr_prior_has_val() { return !structural_innovation_corr_prior_vector.empty(); };
   inline bool measurement_error_corr_prior_has_val() { return !measurement_error_corr_prior_vector.empty(); };
 
+  inline bool option_has_val() { return !option_vector.empty(); };
+  inline bool structural_innovation_option_has_val() { return !structural_innovation_option_vector.empty(); };
+  inline bool measurement_error_option_has_val() { return !measurement_error_option_vector.empty(); };
+  inline bool structural_innovation_corr_option_has_val() { return !structural_innovation_corr_option_vector.empty(); };
+  inline bool measurement_error_corr_option_has_val() { return !measurement_error_corr_option_vector.empty(); };
+
   inline vector<MarkovSwitching *>get_markov_switching() { return markov_switching_vector; };
   inline vector<ModFilePrior *> get_prior() { return prior_vector; };
   inline vector<ModFileStructuralInnovationPrior *> get_structural_innovation_prior() { return structural_innovation_prior_vector; };
   inline vector<ModFileMeasurementErrorPrior *> get_measurement_error_prior() { return measurement_error_prior_vector; };
   inline vector<ModFileStructuralInnovationCorrPrior *> get_structural_innovation_corr_prior() { return structural_innovation_corr_prior_vector; };
   inline vector<ModFileMeasurementErrorCorrPrior *> get_measurement_error_corr_prior() { return measurement_error_corr_prior_vector; };
+
+  inline vector<ModFileOption *> get_option() { return option_vector; };
+  inline vector<ModFileStructuralInnovationOption *> get_structural_innovation_option() { return structural_innovation_option_vector; };
+  inline vector<ModFileMeasurementErrorOption *> get_measurement_error_option() { return measurement_error_option_vector; };
+  inline vector<ModFileStructuralInnovationCorrOption *> get_structural_innovation_corr_option() { return structural_innovation_corr_option_vector; };
+  inline vector<ModFileMeasurementErrorCorrOption *> get_measurement_error_corr_option() { return measurement_error_corr_option_vector; };
+
   inline map<string, int > get_exo_names() { return exo_names; };
   inline map<string, int > get_exo_det_names() { return exo_det_names; };
   inline map<string, int > get_endo_names() { return endo_names; };
diff --git a/preprocessor/ComputingTasks.cc b/preprocessor/ComputingTasks.cc
index 542cb55a79b3c113dd96c193f1510020e9338987..fc368d8e2d1b692970ee8aa7b3db281aa183628b 100644
--- a/preprocessor/ComputingTasks.cc
+++ b/preprocessor/ComputingTasks.cc
@@ -2166,7 +2166,6 @@ PriorStatement::writeCOutput(ostream &output, const string &basename)
 
   output << "msdsgeinfo->addPrior(new ModFilePrior(" << endl
          << "     index, shape, mean, mode, stdev, variance, domain));" << endl;
-
 }
 
 StdPriorStatement::StdPriorStatement(const string &name_arg,
@@ -2415,6 +2414,14 @@ BasicOptionsStatement::checkPass(ModFileStructure &mod_file_struct, WarningConso
 {
 }
 
+bool
+BasicOptionsStatement::is_structural_innovation(const SymbolType symb_type) const
+{
+  if (symb_type == eExogenous || symb_type == eExogenousDet)
+    return true;
+  return false;
+}
+
 void
 BasicOptionsStatement::get_base_name(const SymbolType symb_type, string &lhs_field) const
 {
@@ -2442,6 +2449,16 @@ BasicOptionsStatement::writeCommonOutputHelper(ostream &output, const string &fi
     output << lhs_field << "." << field << " = " << itn->second << ";" << endl;
 }
 
+void
+BasicOptionsStatement::writeCOutputHelper(ostream &output, const string &field) const
+{
+  OptionsList::num_options_t::const_iterator itn = options_list.num_options.find(field);
+  if (itn != options_list.num_options.end())
+    output << field << " = " << itn->second << ";" << endl;
+  else
+    output << field << " = " << "numeric_limits<double>::quiet_NaN();" << endl;
+}
+
 void
 BasicOptionsStatement::writeOptionsOutput(ostream &output, string &lhs_field, const string &name2) const
 {
@@ -2473,6 +2490,15 @@ OptionsStatement::writeOutput(ostream &output, const string &basename) const
   writeOptionsOutput(output, lhs_field, "");
 }
 
+void
+OptionsStatement::writeCOutput(ostream &output, const string &basename)
+{
+  output << endl
+         << "index = param_names[\""<< name << "\"];" << endl;
+  writeCOutputHelper(output, "init");
+  output << "msdsgeinfo->addOption(new ModFileOption(index, init));" << endl;
+}
+
 StdOptionsStatement::StdOptionsStatement(const string &name_arg,
                                          const string &subsample_name_arg,
                                          const OptionsList &options_list_arg,
@@ -2495,6 +2521,26 @@ StdOptionsStatement::writeOutput(ostream &output, const string &basename) const
   writeOptionsOutput(output, lhs_field, "");
 }
 
+void
+StdOptionsStatement::writeCOutput(ostream &output, const string &basename)
+{
+  output << endl
+         << "index = ";
+  if (is_structural_innovation(symbol_table.getType(name)))
+    output << "exo_names";
+  else
+    output << "endo_names";
+  output << "[\""<< name << "\"];" << endl;
+
+  writeCOutputHelper(output, "init");
+
+  if (is_structural_innovation(symbol_table.getType(name)))
+    output << "msdsgeinfo->addStructuralInnovationOption(new ModFileStructuralInnovationOption(";
+  else
+    output << "msdsgeinfo->addMeasurementErrorOption(new ModFileMeasurementErrorOption(";
+  output << "index, init));" << endl;
+}
+
 CorrOptionsStatement::CorrOptionsStatement(const string &name_arg1, const string &name_arg2,
                                            const string &subsample_name_arg,
                                            const OptionsList &options_list_arg,
@@ -2698,3 +2744,30 @@ ModelDiagnosticsStatement::writeOutput(ostream &output, const string &basename)
 {
   output << "model_diagnostics(M_,options_,oo_);" << endl;
 }
+
+void
+CorrOptionsStatement::writeCOutput(ostream &output, const string &basename)
+{
+  output << endl
+         << "index = ";
+  if (is_structural_innovation(symbol_table.getType(name)))
+    output << "exo_names";
+  else
+    output << "endo_names";
+  output << "[\""<< name << "\"];" << endl;
+
+  output << "index1 = ";
+  if (is_structural_innovation(symbol_table.getType(name1)))
+    output << "exo_names";
+  else
+    output << "endo_names";
+  output << "[\""<< name1 << "\"];" << endl;
+
+  writeCOutputHelper(output, "init");
+
+  if (is_structural_innovation(symbol_table.getType(name)))
+    output << "msdsgeinfo->addStructuralInnovationCorrOption(new ModFileStructuralInnovationCorrOption(";
+  else
+    output << "msdsgeinfo->addMeasurementErrorCorrOption(new ModFileMeasurementErrorCorrOption(";
+  output << "index, index1, init));" << endl;
+}
diff --git a/preprocessor/ComputingTasks.hh b/preprocessor/ComputingTasks.hh
index c76728fe4b326b88a97f043bd28d95a09ed64dc8..cefa84874fbc839eb52e31b3a503e452a713d3dc 100644
--- a/preprocessor/ComputingTasks.hh
+++ b/preprocessor/ComputingTasks.hh
@@ -758,6 +758,10 @@ protected:
   void writeOptionsOutput(ostream &output, string &lhs_field, const string &name2) const;
   void writeCommonOutput(ostream &output, const string &lhs_field) const;
   void writeCommonOutputHelper(ostream &output, const string &field, const string &lhs_field) const;
+  bool is_structural_innovation(const SymbolType symb_type) const;
+  void writeOptionsIndex(ostream &output, const string &lhs_field) const;
+  void writeOutputHelper(ostream &output, const string &field, const string &lhs_field) const;
+  void writeCOutputHelper(ostream &output, const string &field) const;
 };
 
 class OptionsStatement : public BasicOptionsStatement
@@ -765,6 +769,7 @@ class OptionsStatement : public BasicOptionsStatement
 public:
   OptionsStatement(const string &name_arg, const string &subsample_name_arg, const OptionsList &options_list_arg);
   virtual void writeOutput(ostream &output, const string &basename) const;
+  virtual void writeCOutput(ostream &output, const string &basename);
 };
 
 class StdOptionsStatement : public BasicOptionsStatement
@@ -777,6 +782,7 @@ public:
                       const OptionsList &options_list_arg,
                       const SymbolTable &symbol_table_arg);
   virtual void writeOutput(ostream &output, const string &basename) const;
+  virtual void writeCOutput(ostream &output, const string &basename);
 };
 
 class CorrOptionsStatement : public BasicOptionsStatement
@@ -825,6 +831,7 @@ class ModelDiagnosticsStatement : public Statement
 public:
   ModelDiagnosticsStatement();
   virtual void writeOutput(ostream &output, const string &basename) const;
+  virtual void writeCOutput(ostream &output, const string &basename);
 };
 
 #endif
diff --git a/preprocessor/ModFile.cc b/preprocessor/ModFile.cc
index bb2a45fb0a27cb0f59ac73845409cedff0d4b9d7..48b76cb431ff3e58cca4c8146db64418043e9b9d 100644
--- a/preprocessor/ModFile.cc
+++ b/preprocessor/ModFile.cc
@@ -865,7 +865,9 @@ ModFile::writeCOutputFiles(const string &basename) const
                << "int chain, number_of_regimes, number_of_lags, number_of_lags_was_passed;" << endl
                << "vector<int> parameters;" << endl
                << "vector<double> duration;" << endl
-               << "restriction_map_t restriction_map;" << endl << endl;
+               << "restriction_map_t restriction_map;" << endl
+               << "/* options args*/" << endl
+               << "double init;" << endl << endl;
 
   // Print statements
   for (vector<Statement *>::const_iterator it = statements.begin();