diff --git a/DynamicModel.cc b/DynamicModel.cc
index dc79dcb888e66c6a6026f961ea775ac34c6e0704..da197ef821168a481d887162c268d0210ce71fde 100644
--- a/DynamicModel.cc
+++ b/DynamicModel.cc
@@ -3200,6 +3200,13 @@ DynamicModel::writeOutput(ostream &output, const string &basename, bool block_de
   else
     output << "-1";
   output << "];" << endl;
+
+  // Write PacExpectationInfo
+  deriv_node_temp_terms_t tef_terms;
+  temporary_terms_t temp_terms_empty;
+  for (set<const PacExpectationNode *>::const_iterator it = pac_expectation_info.begin();
+       it != pac_expectation_info.end(); it++)
+    (*it)->writeOutput(output, oMatlabDynamicModel, temp_terms_empty, tef_terms);
 }
 
 map<pair<int, pair<int, int > >, expr_t>
@@ -3344,8 +3351,7 @@ DynamicModel::fillPacExpectationVarInfo(map<string, map<pair<string, int>, pair<
 void
 DynamicModel::substitutePacExpectation()
 {
-  // maps PacExpectationNode to (subst node, (var_model_name, (growth_id, (h0_idxs, h1_idxs))))
-  map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > subst_table;
+  map<const PacExpectationNode *, const BinaryOpNode *> subst_table;
   for (map<int, expr_t>::iterator it = local_variables_table.begin();
        it != local_variables_table.end(); it++)
     it->second = it->second->substitutePacExpectation(subst_table);
@@ -3357,40 +3363,9 @@ DynamicModel::substitutePacExpectation()
       equations[i] = substeq;
     }
 
-  for (map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > >::const_iterator it = subst_table.begin(); it != subst_table.end(); it++)
-    pac_expectation_info[it->second.second.first] = it->second.second.second;
-}
-
-void
-DynamicModel::writePacExpectationInfo(ostream &output) const
-{
-  int i = 1;
-  for (map<string, pair<int, pair<vector<int>, vector<int> > > >::const_iterator it = pac_expectation_info.begin();
-       it != pac_expectation_info.end(); it++, i++)
-    {
-      output << "M_.pac_expectation(" << i << ").var_model_name = '"
-             << it->first << "';" << endl
-             << "M_.pac_expectation(" << i << ").growth_param_index = "
-             << symbol_table.getTypeSpecificID(it->second.first) + 1 << ";" << endl
-             << "M_.pac_expectation(" << i << ").h0_param_indices = [";
-      for (vector<int>::const_iterator it1 = it->second.second.first.begin();
-           it1 != it->second.second.first.end(); it1++)
-        {
-          if (it1 != it->second.second.first.begin())
-            output << " ";
-          output << symbol_table.getTypeSpecificID(*it1) + 1;
-        }
-      output << "];" << endl
-           << "M_.pac_expectation(" << i << ").h1_param_indices = [";
-      for (vector<int>::const_iterator it1 = it->second.second.second.begin();
-           it1 != it->second.second.second.end(); it1++)
-        {
-          if (it1 != it->second.second.second.begin())
-            output << " ";
-          output << symbol_table.getTypeSpecificID(*it1) + 1;
-        }
-      output << "];" << endl;
-    }
+  for (map<const PacExpectationNode *, const BinaryOpNode *>::const_iterator it = subst_table.begin();
+       it != subst_table.end(); it++)
+    pac_expectation_info.insert(const_cast<PacExpectationNode *>(it->first));
 }
 
 void
diff --git a/DynamicModel.hh b/DynamicModel.hh
index 5edd6b1ddf0981e742639f8f58c28eb7a5520d1e..676718a679a9a63fbcb138bd5191df9d01dff638 100644
--- a/DynamicModel.hh
+++ b/DynamicModel.hh
@@ -227,8 +227,7 @@ private:
   map<string, set<int> > var_expectation_functions_to_write;
 
   //! Used for pac_expectation operator
-  // maps var_model_name to (growth_idx, (h0_indices, h1_indices))
-  map<string, pair<int, pair<vector<int>, vector<int> > > > pac_expectation_info;
+  set<const PacExpectationNode *> pac_expectation_info; // PacExpectationNode pointers
 
   //!Maximum lead and lag for each block on endogenous of the block, endogenous of the previous blocks, exogenous and deterministic exogenous
   vector<pair<int, int> > endo_max_leadlag_block, other_endo_max_leadlag_block, exo_max_leadlag_block, exo_det_max_leadlag_block, max_leadlag_block;
@@ -295,9 +294,6 @@ public:
   //! Substitutes pac_expectation operator
   void substitutePacExpectation();
 
-  //! Write Pac Expectation info
-  void writePacExpectationInfo(ostream &output) const;
-
   //! Adds informations for simulation in a binary file
   void Write_Inf_To_Bin_File_Block(const string &dynamic_basename, const string &bin_basename,
                                    const int &num, int &u_count_int, bool &file_open, bool is_two_boundaries) const;
diff --git a/ExprNode.cc b/ExprNode.cc
index 6d8a4b13ef75391452243909e12f42077fb01133..79988cb67711f733185adac885dc70b836bceb6a 100644
--- a/ExprNode.cc
+++ b/ExprNode.cc
@@ -494,7 +494,7 @@ NumConstNode::substituteDiff(subst_table_t &subst_table, vector<BinaryOpNode *>
 }
 
 expr_t
-NumConstNode::substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table)
+NumConstNode::substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table)
 {
   return const_cast<NumConstNode *>(this);
 }
@@ -1273,7 +1273,7 @@ VariableNode::substituteDiff(subst_table_t &subst_table, vector<BinaryOpNode *>
 }
 
 expr_t
-VariableNode::substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table)
+VariableNode::substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table)
 {
   return const_cast<VariableNode *>(this);
 }
@@ -2821,7 +2821,7 @@ UnaryOpNode::substituteDiff(subst_table_t &subst_table, vector<BinaryOpNode *> &
 }
 
 expr_t
-UnaryOpNode::substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table)
+UnaryOpNode::substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table)
 {
   expr_t argsubst = arg->substitutePacExpectation(subst_table);
   return buildSimilarUnaryOpNode(argsubst, datatree);
@@ -4445,7 +4445,7 @@ BinaryOpNode::substituteDiff(subst_table_t &subst_table, vector<BinaryOpNode *>
 }
 
 expr_t
-BinaryOpNode::substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table)
+BinaryOpNode::substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table)
 {
   expr_t arg1subst = arg1->substitutePacExpectation(subst_table);
   expr_t arg2subst = arg2->substitutePacExpectation(subst_table);
@@ -5217,7 +5217,7 @@ TrinaryOpNode::substituteDiff(subst_table_t &subst_table, vector<BinaryOpNode *>
 }
 
 expr_t
-TrinaryOpNode::substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table)
+TrinaryOpNode::substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table)
 {
   expr_t arg1subst = arg1->substitutePacExpectation(subst_table);
   expr_t arg2subst = arg2->substitutePacExpectation(subst_table);
@@ -5555,7 +5555,7 @@ AbstractExternalFunctionNode::substituteDiff(subst_table_t &subst_table, vector<
 }
 
 expr_t
-AbstractExternalFunctionNode::substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table)
+AbstractExternalFunctionNode::substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table)
 {
   vector<expr_t> arguments_subst;
   for (vector<expr_t>::const_iterator it = arguments.begin(); it != arguments.end(); it++)
@@ -7046,7 +7046,7 @@ VarExpectationNode::substituteDiff(subst_table_t &subst_table, vector<BinaryOpNo
 }
 
 expr_t
-VarExpectationNode::substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table)
+VarExpectationNode::substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table)
 {
   return const_cast<VarExpectationNode *>(this);
 }
@@ -7161,7 +7161,9 @@ PacExpectationNode::PacExpectationNode(DataTree &datatree_arg,
   ExprNode(datatree_arg),
   model_name(model_name_arg),
   discount(discount_arg),
-  growth(growth_arg)
+  growth(growth_arg),
+  stationary_vars_present(true),
+  nonstationary_vars_present(true)
 {
   datatree.pac_expectation_node_map[make_pair(model_name, make_pair(discount, growth))] = this;
 }
@@ -7217,18 +7219,32 @@ PacExpectationNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
       return;
     }
 
-  // If current node is a temporary term
-  temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<PacExpectationNode *>(this));
-  if (it != temporary_terms.end())
+  output << "M_.pac_expectation." << model_name << ".discount = ";
+  discount->writeOutput(output, oMatlabOutsideModel, temporary_terms, tef_terms);
+  output << ";" << endl
+         << "M_.pac_expectation." << model_name << ".growth = ";
+  growth->writeOutput(output, oMatlabOutsideModel, temporary_terms, tef_terms);
+  output << ";" << endl
+         << "M_.pac_expectation." << model_name << ".growth_neutrality_param_index = "
+         << datatree.symbol_table.getTypeSpecificID(growth_param_index) + 1 << ";" << endl
+         << "M_.pac_expectation." << model_name << ".h0_param_indices = [";
+  for (vector<int>::const_iterator it = h0_indices.begin();
+       it != h0_indices.end(); it++)
     {
-      if (output_type == oMatlabDynamicModelSparse)
-        output << "T" << idx << "(it_)";
-      else
-        output << "T" << idx;
-      return;
+      if (it != h0_indices.begin())
+        output << " ";
+      output << datatree.symbol_table.getTypeSpecificID(*it) + 1;
     }
-
-  output << "[h0, h1, d] = hVectors(params, H, ids, idns);";
+  output << "];" << endl
+         << "M_.pac_expectation." << model_name << ".h1_param_indices = [";
+  for (vector<int>::const_iterator it = h1_indices.begin();
+       it != h1_indices.end(); it++)
+    {
+      if (it != h1_indices.begin())
+        output << " ";
+      output << datatree.symbol_table.getTypeSpecificID(*it) + 1;
+    }
+  output << "];" << endl;
 }
 
 int
@@ -7486,6 +7502,8 @@ PacExpectationNode::fillPacExpectationVarInfo(map<string, map<pair<string, int>,
       exit(EXIT_FAILURE);
     }
 
+  vector<set<pair<int, int> > > rhs;
+  vector<int> lhs, nonstationary_vars;
   for (map<pair<string, int>, pair<pair<int, set<pair<int, int> > >, set<pair<int, int> > > >::const_iterator it1 = it->second.begin(); it1 != it->second.end(); it1++)
     {
       if (it1->second.first.second.size() != 1)
@@ -7506,25 +7524,13 @@ PacExpectationNode::fillPacExpectationVarInfo(map<string, map<pair<string, int>,
       if (it1->second.first.first)
         nonstationary_vars.push_back(lhs.back());
     }
-}
 
-expr_t
-PacExpectationNode::substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table)
-{
-  map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > >::const_iterator myit =
-    subst_table.find(const_cast<PacExpectationNode *>(this));
-  if (myit != subst_table.end())
-    return const_cast<BinaryOpNode *>(myit->second.first);
-
-  bool stationary_vars_present = true;
   if (nonstationary_vars.size() == lhs.size())
     stationary_vars_present = false;
 
-  bool nonstationary_vars_present = true;
   if (nonstationary_vars.empty())
     nonstationary_vars_present = false;
 
-  map<int, set<int > > all_rhs_vars; // lag -> set< symb_id > (all vars that appear at a given lag)
   // Order RHS vars by time (already ordered by equation tag)
   for (vector<set<pair<int, int> > >::const_iterator it = rhs.begin();
        it != rhs.end(); it++)
@@ -7538,8 +7544,8 @@ PacExpectationNode::substitutePacExpectation(map<const PacExpectationNode *, pai
         }
       else
         {
-          map<int, set<int> >::iterator mit = all_rhs_vars.find(abs(it1->second));
-          if (mit == all_rhs_vars.end())
+          map<int, set<int> >::iterator mit = z_vec.find(abs(it1->second));
+          if (mit == z_vec.end())
             {
               if (it1->second > 0)
                 {
@@ -7549,17 +7555,25 @@ PacExpectationNode::substitutePacExpectation(map<const PacExpectationNode *, pai
                 }
               set<int> si;
               si.insert(it1->first);
-              all_rhs_vars[abs(it1->second)] = si;
+              z_vec[abs(it1->second)] = si;
             }
           else
             mit->second.insert(it1->first);
         }
+}
+
+expr_t
+PacExpectationNode::substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table)
+{
+  map<const PacExpectationNode *, const BinaryOpNode *>::const_iterator myit =
+    subst_table.find(const_cast<PacExpectationNode *>(this));
+  if (myit != subst_table.end())
+    return const_cast<BinaryOpNode *>(myit->second);
 
-  vector<int> h0_indices, h1_indices;
   expr_t subExpr = datatree.AddNonNegativeConstant("0");
   if (stationary_vars_present)
-    for (map<int, set<int> >::const_iterator it = all_rhs_vars.begin();
-         it != all_rhs_vars.end(); it++)
+    for (map<int, set<int> >::const_iterator it = z_vec.begin();
+         it != z_vec.end(); it++)
       for (set<int>::const_iterator it1 = it->second.begin(); it1 != it->second.end(); it1++)
         {
           stringstream param_name_h0;
@@ -7574,8 +7588,8 @@ PacExpectationNode::substitutePacExpectation(map<const PacExpectationNode *, pai
         }
 
   if (nonstationary_vars_present)
-    for (map<int, set<int > >::const_iterator it = all_rhs_vars.begin();
-         it != all_rhs_vars.end(); it++)
+    for (map<int, set<int > >::const_iterator it = z_vec.begin();
+         it != z_vec.end(); it++)
       for (set<int>::const_iterator it1 = it->second.begin(); it1 != it->second.end(); it1++)
         {
           stringstream param_name_h1;
@@ -7589,16 +7603,13 @@ PacExpectationNode::substitutePacExpectation(map<const PacExpectationNode *, pai
                                                        datatree.AddVariable(*it1, it->first)));
         }
 
-  int pg_symb_id = datatree.symbol_table.addSymbol("pac_growth_parameter", eParameter);
+  growth_param_index = datatree.symbol_table.addSymbol(model_name + "_pac_growth_neutrality_correction",
+                                                       eParameter);
   subExpr = datatree.AddPlus(subExpr,
-                             datatree.AddTimes(datatree.AddVariable(pg_symb_id),
+                             datatree.AddTimes(datatree.AddVariable(growth_param_index),
                                                growth));
 
-  subst_table[const_cast<PacExpectationNode *>(this)] =
-    make_pair(dynamic_cast<BinaryOpNode *>(subExpr),
-              make_pair(model_name,
-                        make_pair(pg_symb_id,
-                                  make_pair(h0_indices, h1_indices))));
+  subst_table[const_cast<PacExpectationNode *>(this)] = dynamic_cast<BinaryOpNode *>(subExpr);
 
   return subExpr;
 }
diff --git a/ExprNode.hh b/ExprNode.hh
index 4f1d72972594a183e8d8e1af7ab2f1baf6acd455..6600403b264fd1fde5cd6c4d63b712d80cb52f23 100644
--- a/ExprNode.hh
+++ b/ExprNode.hh
@@ -466,7 +466,7 @@ class ExprNode
       virtual expr_t substituteDiff(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const = 0;
 
       //! Substitute pac_expectation operator
-      virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table) = 0;
+      virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table) = 0;
 
       //! Add ExprNodes to the provided datatree
       virtual expr_t cloneDynamic(DataTree &dynamic_datatree) const = 0;
@@ -543,7 +543,7 @@ public:
   virtual expr_t substituteExpectation(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool partial_information_model) const;
   virtual expr_t substituteAdl() const;
   virtual expr_t substituteDiff(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
-  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table);
+  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table);
   virtual expr_t decreaseLeadsLagsPredeterminedVariables() const;
   virtual expr_t differentiateForwardVars(const vector<string> &subset, subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
   virtual bool isNumConstNodeEqualTo(double value) const;
@@ -621,7 +621,7 @@ public:
   virtual expr_t substituteExpectation(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool partial_information_model) const;
   virtual expr_t substituteAdl() const;
   virtual expr_t substituteDiff(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
-  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table);
+  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table);
   virtual expr_t decreaseLeadsLagsPredeterminedVariables() const;
   virtual expr_t differentiateForwardVars(const vector<string> &subset, subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
   virtual bool isNumConstNodeEqualTo(double value) const;
@@ -722,7 +722,7 @@ public:
   virtual expr_t substituteExpectation(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool partial_information_model) const;
   virtual expr_t substituteAdl() const;
   virtual expr_t substituteDiff(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
-  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table);
+  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table);
   virtual expr_t decreaseLeadsLagsPredeterminedVariables() const;
   virtual expr_t differentiateForwardVars(const vector<string> &subset, subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
   virtual bool isNumConstNodeEqualTo(double value) const;
@@ -835,7 +835,7 @@ public:
   virtual expr_t substituteExpectation(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool partial_information_model) const;
   virtual expr_t substituteAdl() const;
   virtual expr_t substituteDiff(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
-  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table);
+  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table);
   virtual expr_t decreaseLeadsLagsPredeterminedVariables() const;
   virtual expr_t differentiateForwardVars(const vector<string> &subset, subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
   virtual bool isNumConstNodeEqualTo(double value) const;
@@ -928,7 +928,7 @@ public:
   virtual expr_t substituteExpectation(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool partial_information_model) const;
   virtual expr_t substituteAdl() const;
   virtual expr_t substituteDiff(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
-  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table);
+  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table);
   virtual expr_t decreaseLeadsLagsPredeterminedVariables() const;
   virtual expr_t differentiateForwardVars(const vector<string> &subset, subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
   virtual bool isNumConstNodeEqualTo(double value) const;
@@ -1021,7 +1021,7 @@ public:
   virtual expr_t substituteExpectation(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool partial_information_model) const;
   virtual expr_t substituteAdl() const;
   virtual expr_t substituteDiff(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
-  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table);
+  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table);
   virtual expr_t buildSimilarExternalFunctionNode(vector<expr_t> &alt_args, DataTree &alt_datatree) const = 0;
   virtual expr_t decreaseLeadsLagsPredeterminedVariables() const;
   virtual expr_t differentiateForwardVars(const vector<string> &subset, subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
@@ -1205,7 +1205,7 @@ public:
   virtual expr_t substituteExpectation(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool partial_information_model) const;
   virtual expr_t substituteAdl() const;
   virtual expr_t substituteDiff(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
-  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table);
+  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table);
   virtual pair<int, expr_t> normalizeEquation(int symb_id_endo, vector<pair<int, pair<expr_t, expr_t> > >  &List_of_Op_RHS) const;
   virtual void compile(ostream &CompileCode, unsigned int &instruction_number,
                        bool lhs_rhs, const temporary_terms_t &temporary_terms,
@@ -1236,8 +1236,10 @@ class PacExpectationNode : public ExprNode
 private:
   const string &model_name;
   const expr_t discount, growth;
-  vector<int> lhs, nonstationary_vars;
-  vector<set<pair<int, int> > > rhs;
+  bool stationary_vars_present, nonstationary_vars_present;
+  map<int, set<int > > z_vec; // lag -> set< symb_id > (all vars that appear at a given lag)
+  vector<int> h0_indices, h1_indices;
+  int growth_param_index;
 public:
   PacExpectationNode(DataTree &datatree_arg, const string &model_name, const expr_t discount_arg, const expr_t growth_arg);
   virtual void computeTemporaryTerms(map<expr_t, pair<int, NodeTreeReference> > &reference_count,
@@ -1271,7 +1273,7 @@ public:
   virtual expr_t substituteExpectation(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool partial_information_model) const;
   virtual expr_t substituteAdl() const;
   virtual expr_t substituteDiff(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
-  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, pair<const BinaryOpNode *, pair<string, pair<int, pair<vector<int>, vector<int> > > > > > &subst_table);
+  virtual expr_t substitutePacExpectation(map<const PacExpectationNode *, const BinaryOpNode *> &subst_table);
   virtual pair<int, expr_t> normalizeEquation(int symb_id_endo, vector<pair<int, pair<expr_t, expr_t> > >  &List_of_Op_RHS) const;
   virtual void compile(ostream &CompileCode, unsigned int &instruction_number,
                        bool lhs_rhs, const temporary_terms_t &temporary_terms,
diff --git a/ModFile.cc b/ModFile.cc
index b6b909e769a985a3e62646c7c0110f0119f50731..ee1cc504dca72b5cd95266b357c2bd9fd6c4d761 100644
--- a/ModFile.cc
+++ b/ModFile.cc
@@ -761,8 +761,6 @@ ModFile::writeOutputFiles(const string &basename, bool clear_all, bool clear_glo
   // Initialize M_.det_shocks
   mOutputFile << "M_.det_shocks = [];" << endl;
 
-  dynamic_model.writePacExpectationInfo(mOutputFile);
-
   if (linear == 1)
     mOutputFile << "options_.linear = 1;" << endl;