diff --git a/CodeInterpreter.hh b/CodeInterpreter.hh
index 3c2f6e00a2feef000c52a6bbe1d18d934b3dfde3..8dfd7e4040f4cfb3779e221635d622783d0663d6 100644
--- a/CodeInterpreter.hh
+++ b/CodeInterpreter.hh
@@ -200,7 +200,8 @@ enum UnaryOpcode
     oSteadyStateParamDeriv, // for the derivative of the STEADY_STATE operator w.r.t. to a parameter
     oSteadyStateParam2ndDeriv, // for the 2nd derivative of the STEADY_STATE operator w.r.t. to a parameter
     oExpectation,
-    oErf
+    oErf,
+    oDiff
   };
 
 enum BinaryOpcode
@@ -219,7 +220,8 @@ enum BinaryOpcode
     oLessEqual,
     oGreaterEqual,
     oEqualEqual,
-    oDifferent
+    oDifferent,
+    oAdl
   };
 
 enum TrinaryOpcode
diff --git a/DataTree.cc b/DataTree.cc
index adaed600b0283a6763e03ef5123aee70ecada131..2ce90dccc9a64e319d624dede2bc2a263b00e2dc 100644
--- a/DataTree.cc
+++ b/DataTree.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2016 Dynare Team
+ * Copyright (C) 2003-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -257,6 +257,20 @@ DataTree::AddPowerDeriv(expr_t iArg1, expr_t iArg2, int powerDerivOrder)
   return AddBinaryOp(iArg1, oPowerDeriv, iArg2, powerDerivOrder);
 }
 
+expr_t
+DataTree::AddDiff(expr_t iArg1)
+{
+  return AddUnaryOp(oDiff, iArg1);
+}
+
+expr_t
+DataTree::AddAdl(expr_t iArg1, string &name, expr_t iArg2)
+{
+  expr_t adlnode = AddBinaryOp(iArg1, oAdl, iArg2);
+  adl_map[adlnode] = new string(name);
+  return adlnode;
+}
+
 expr_t
 DataTree::AddExp(expr_t iArg1)
 {
diff --git a/DataTree.hh b/DataTree.hh
index 486b57441854f5b66f020bcd1f38daea4498b626..18e7341716d2f2f50406da289ac08813e56e0129 100644
--- a/DataTree.hh
+++ b/DataTree.hh
@@ -57,6 +57,10 @@ protected:
   //! A reference to the external functions table
   ExternalFunctionsTable &external_functions_table;
 
+  //! A reference to the adl table
+  typedef map<expr_t, string *> adl_map_t;
+  adl_map_t adl_map;
+
   typedef map<int, NumConstNode *> num_const_node_map_t;
   num_const_node_map_t num_const_node_map;
   //! Pair (symbol_id, lag) used as key
@@ -162,6 +166,10 @@ public:
   expr_t AddPowerDeriv(expr_t iArg1, expr_t iArg2, int powerDerivOrder);
   //! Adds "E(arg1)(arg2)" to model tree
   expr_t AddExpectation(int iArg1, expr_t iArg2);
+  //! Adds "diff(arg)" to model tree
+  expr_t AddDiff(expr_t iArg1);
+  //! Adds "adl(arg1, arg2)" to model tree
+  expr_t AddAdl(expr_t iArg1, string &name, expr_t iArg2);
   //! Adds "exp(arg)" to model tree
   expr_t AddExp(expr_t iArg1);
   //! Adds "log(arg)" to model tree
diff --git a/DynamicModel.cc b/DynamicModel.cc
index 42eaab23a184adb5537f2f7e050fe985c23b0561..36f7432faa2c80d29a513abe52b8510938443320 100644
--- a/DynamicModel.cc
+++ b/DynamicModel.cc
@@ -4651,6 +4651,29 @@ DynamicModel::substituteLeadLagInternal(aux_var_t type, bool deterministic_model
     }
 }
 
+void
+DynamicModel::substituteAdlAndDiff()
+{
+  cout << endl << "BEFORE TRANSFORM" << endl;
+  for (int i = 0; i < (int) equations.size(); i++)
+    {
+      cout << i << ") ";
+      equations[i]->write();
+      cout << endl;
+    }
+
+  for (int i = 0; i < (int) equations.size(); i++)
+    equations[i] = dynamic_cast<BinaryOpNode *>(equations[i]->substituteAdlAndDiff());
+
+  cout << endl << endl << "AFTER TRANSFORM" << endl;
+  for (int i = 0; i < (int) equations.size(); i++)
+    {
+      cout << i << ") ";
+      equations[i]->write();
+      cout << endl;
+    }
+}
+
 void
 DynamicModel::substituteExpectation(bool partial_information_model)
 {
diff --git a/DynamicModel.hh b/DynamicModel.hh
index 62443cf437a96552383fc7628f5963225992f703..7c742f41d6a3f692c27e7a5d3dd19748ee5f4171 100644
--- a/DynamicModel.hh
+++ b/DynamicModel.hh
@@ -330,6 +330,9 @@ public:
   //! Transforms the model by removing trends specified by the user
   void detrendEquations();
 
+  //! Substitutes adl and diff operators
+  void substituteAdlAndDiff();
+
   //! Fill var_expectation_functions_to_write
   void fillVarExpectationFunctionsToWrite();
 
diff --git a/DynareBison.yy b/DynareBison.yy
index 11e2506e75301ff387eb7d1cd6c945c5c1ab44d2..06b7db9dab354fe99e42733926a167b0342ba4a6 100644
--- a/DynareBison.yy
+++ b/DynareBison.yy
@@ -139,7 +139,7 @@ class ParsingDriver;
 %left TIMES DIVIDE
 %left UMINUS UPLUS
 %nonassoc POWER
-%token EXP LOG LN LOG10 SIN COS TAN ASIN ACOS ATAN SINH COSH TANH ERF
+%token EXP LOG LN LOG10 SIN COS TAN ASIN ACOS ATAN SINH COSH TANH ERF DIFF ADL
 %token ASINH ACOSH ATANH SQRT NORMCDF NORMPDF STEADY_STATE EXPECTATION VAR_ESTIMATION
 /* GSA analysis */
 %token DYNARE_SENSITIVITY MORRIS STAB REDFORM PPRIOR PRIOR_RANGE PPOST ILPTAU MORRIS_NLIV
@@ -884,6 +884,12 @@ hand_side : '(' hand_side ')'
             { $$ = $2; }
           | EXP '(' hand_side ')'
             { $$ = driver.add_exp($3); }
+          | DIFF '(' hand_side ')'
+            { $$ = driver.add_diff($3); }
+          | ADL '(' hand_side COMMA QUOTED_STRING ')'
+            { $$ = driver.add_adl($3, $5, new string("1")); }
+          | ADL '(' hand_side COMMA QUOTED_STRING COMMA INT_NUMBER ')'
+            { $$ = driver.add_adl($3, $5, $7); }
           | LOG '(' hand_side ')'
             { $$ = driver.add_log($3); }
           | LN '(' hand_side ')'
diff --git a/DynareFlex.ll b/DynareFlex.ll
index b3834a3aec7065b8761e7d9cff142cc35e363418..811b817c48d335c79a5cd6a1de9a45247a52eba7 100644
--- a/DynareFlex.ll
+++ b/DynareFlex.ll
@@ -373,6 +373,8 @@ DATE -?[0-9]+([YyAa]|[Mm]([1-9]|1[0-2])|[Qq][1-4]|[Ww]([1-9]{1}|[1-4][0-9]|5[0-2
 <DYNARE_STATEMENT>restrictions {return token::RESTRICTIONS;}
 <DYNARE_BLOCK>crossequations {return token::CROSSEQUATIONS;}
 <DYNARE_BLOCK>covariance {return token::COVARIANCE;}
+<DYNARE_BLOCK>adl {return token::ADL;}
+<DYNARE_BLOCK>diff {return token::DIFF;}
 <DYNARE_STATEMENT>cross_restrictions {return token::CROSS_RESTRICTIONS;}
 <DYNARE_STATEMENT>contemp_reduced_form {return token::CONTEMP_REDUCED_FORM;}
 <DYNARE_STATEMENT>real_pseudo_forecast {return token::REAL_PSEUDO_FORECAST;}
diff --git a/ExprNode.cc b/ExprNode.cc
index e738f7fd4e52a01985d845bafefb9107991473c8..7fcd58fcfe9352c363c06459cfabd1a7df9314e7 100644
--- a/ExprNode.cc
+++ b/ExprNode.cc
@@ -456,6 +456,12 @@ NumConstNode::substituteExpectation(subst_table_t &subst_table, vector<BinaryOpN
   return const_cast<NumConstNode *>(this);
 }
 
+expr_t
+NumConstNode::substituteAdlAndDiff() const
+{
+  return const_cast<NumConstNode *>(this);
+}
+
 expr_t
 NumConstNode::differentiateForwardVars(const vector<string> &subset, subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const
 {
@@ -1194,6 +1200,12 @@ VariableNode::maxLead() const
     }
 }
 
+expr_t
+VariableNode::substituteAdlAndDiff() const
+{
+  return const_cast<VariableNode *>(this);
+}
+
 expr_t
 VariableNode::decreaseLeadsLags(int n) const
 {
@@ -1706,6 +1718,9 @@ UnaryOpNode::composeDerivatives(expr_t darg, int deriv_id)
       t14 = datatree.AddDivide(datatree.Two, t13);
       // (2/(sqrt(pi)*exp(x^2)))*dx;
       return datatree.AddTimes(t14, darg);
+    case oDiff:
+      cerr << "UnaryOpNode::composeDerivatives: not implemented on oDiff" << endl;
+      exit(EXIT_FAILURE);
     }
   // Suppress GCC warning
   exit(EXIT_FAILURE);
@@ -1787,6 +1802,9 @@ UnaryOpNode::cost(int cost, bool is_matlab) const
       case oSteadyStateParam2ndDeriv:
       case oExpectation:
         return cost;
+      case oDiff:
+        cerr << "UnaryOpNode::cost: not implemented on oDiff" << endl;
+        exit(EXIT_FAILURE);
       }
   else
     // Cost for C files
@@ -1829,6 +1847,9 @@ UnaryOpNode::cost(int cost, bool is_matlab) const
       case oSteadyStateParam2ndDeriv:
       case oExpectation:
         return cost;
+      case oDiff:
+        cerr << "UnaryOpNode::cost: not implemented on oDiff" << endl;
+        exit(EXIT_FAILURE);
       }
   exit(EXIT_FAILURE);
 }
@@ -2054,6 +2075,9 @@ UnaryOpNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
     case oErf:
       output << "erf";
       break;
+    case oDiff:
+      output << "diff";
+      break;
     }
 
   bool close_parenthesis = false;
@@ -2151,6 +2175,9 @@ UnaryOpNode::eval_opcode(UnaryOpcode op_code, double v) throw (EvalException, Ev
     case oExpectation:
     case oErf:
       return (erf(v));
+    case oDiff:
+      cerr << "UnaryOpNode::eval_opcode: not implemented on oDiff" << endl;
+      exit(EXIT_FAILURE);
     }
   // Suppress GCC warning
   exit(EXIT_FAILURE);
@@ -2400,6 +2427,8 @@ UnaryOpNode::buildSimilarUnaryOpNode(expr_t alt_arg, DataTree &alt_datatree) con
       return alt_datatree.AddExpectation(expectation_information_set, alt_arg);
     case oErf:
       return alt_datatree.AddErf(alt_arg);
+    case oDiff:
+      return alt_datatree.AddDiff(alt_arg);
     }
   // Suppress GCC warning
   exit(EXIT_FAILURE);
@@ -2455,6 +2484,20 @@ UnaryOpNode::maxLead() const
   return arg->maxLead();
 }
 
+expr_t
+UnaryOpNode::substituteAdlAndDiff() const
+{
+  if (op_code != oDiff)
+    {
+      expr_t argsubst = arg->substituteAdlAndDiff();
+      return buildSimilarUnaryOpNode(argsubst, datatree);
+    }
+
+  expr_t argsubst = arg->substituteAdlAndDiff();
+  return datatree.AddMinus(argsubst,
+                           argsubst->decreaseLeadsLags(1));
+}
+
 expr_t
 UnaryOpNode::decreaseLeadsLags(int n) const
 {
@@ -2803,6 +2846,9 @@ BinaryOpNode::composeDerivatives(expr_t darg1, expr_t darg2)
       return datatree.AddPlus(t14, t12);
     case oEqual:
       return datatree.AddMinus(darg1, darg2);
+    case oAdl:
+      cerr << "BinaryOpNode::composeDerivatives not implemented for oAdl";
+      exit(EXIT_FAILURE);
     }
   // Suppress GCC warning
   exit(EXIT_FAILURE);
@@ -2869,6 +2915,9 @@ BinaryOpNode::precedence(ExprNodeOutputType output_type, const temporary_terms_t
     case oMin:
     case oMax:
       return 100;
+    case oAdl:
+      cerr << "BinaryOpNode::precedence not implemented for oAdl";
+      exit(EXIT_FAILURE);
     }
   // Suppress GCC warning
   exit(EXIT_FAILURE);
@@ -2928,6 +2977,9 @@ BinaryOpNode::cost(int cost, bool is_matlab) const
         return cost + (MIN_COST_MATLAB/2+1);
       case oEqual:
         return cost;
+      case oAdl:
+        cerr << "BinaryOpNode::cost not implemented for oAdl";
+        exit(EXIT_FAILURE);
       }
   else
     // Cost for C files
@@ -2955,6 +3007,9 @@ BinaryOpNode::cost(int cost, bool is_matlab) const
         return cost + (MIN_COST_C/2+1);;
       case oEqual:
         return cost;
+      case oAdl:
+        cerr << "BinaryOpNode::cost not implemented for oAdl";
+        exit(EXIT_FAILURE);
       }
   // Suppress GCC warning
   exit(EXIT_FAILURE);
@@ -3067,6 +3122,9 @@ BinaryOpNode::eval_opcode(double v1, BinaryOpcode op_code, double v2, int derivO
       return (v1 != v2);
     case oEqual:
       throw EvalException();
+    case oAdl:
+        cerr << "BinaryOpNode::eval_opcode not implemented for oAdl";
+        exit(EXIT_FAILURE);
     }
   // Suppress GCC warning
   exit(EXIT_FAILURE);
@@ -3685,6 +3743,10 @@ BinaryOpNode::buildSimilarBinaryOpNode(expr_t alt_arg1, expr_t alt_arg2, DataTre
       return alt_datatree.AddDifferent(alt_arg1, alt_arg2);
     case oPowerDeriv:
       return alt_datatree.AddPowerDeriv(alt_arg1, alt_arg2, powerDerivOrder);
+    case oAdl:
+      DataTree::adl_map_t::const_iterator it = datatree.adl_map.find(const_cast<BinaryOpNode *>(this));
+      assert (it != datatree.adl_map.end());
+      return alt_datatree.AddAdl(alt_arg1, *(it->second), alt_arg2);
     }
   // Suppress GCC warning
   exit(EXIT_FAILURE);
@@ -3871,6 +3933,31 @@ BinaryOpNode::substituteExpectation(subst_table_t &subst_table, vector<BinaryOpN
   return buildSimilarBinaryOpNode(arg1subst, arg2subst, datatree);
 }
 
+expr_t
+BinaryOpNode::substituteAdlAndDiff() const
+{
+  if (op_code != oAdl)
+    {
+      expr_t arg1subst = arg1->substituteAdlAndDiff();
+      expr_t arg2subst = arg2->substituteAdlAndDiff();
+      return buildSimilarBinaryOpNode(arg1subst, arg2subst, datatree);
+    }
+
+  expr_t arg1subst = arg1->substituteAdlAndDiff();
+  DataTree::adl_map_t::const_iterator it = datatree.adl_map.find(const_cast<BinaryOpNode *>(this));
+  assert (it != datatree.adl_map.end());
+
+  int i = 1;
+  expr_t retval = datatree.AddTimes(datatree.AddVariable(datatree.symbol_table.addAdlParameter(*(it->second), i), 0),
+                                    arg1subst->decreaseLeadsLags(i));
+  i++;
+  for (; i <= (int) arg2->eval(eval_context_t()); i++)
+    retval = datatree.AddPlus(retval,
+                              datatree.AddTimes(datatree.AddVariable(datatree.symbol_table.addAdlParameter(*(it->second), i), 0),
+                                                arg1subst->decreaseLeadsLags(i)));
+  return retval;
+}
+
 expr_t
 BinaryOpNode::differentiateForwardVars(const vector<string> &subset, subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const
 {
@@ -4567,6 +4654,15 @@ TrinaryOpNode::substituteExpectation(subst_table_t &subst_table, vector<BinaryOp
   return buildSimilarTrinaryOpNode(arg1subst, arg2subst, arg3subst, datatree);
 }
 
+expr_t
+TrinaryOpNode::substituteAdlAndDiff() const
+{
+  expr_t arg1subst = arg1->substituteAdlAndDiff();
+  expr_t arg2subst = arg2->substituteAdlAndDiff();
+  expr_t arg3subst = arg3->substituteAdlAndDiff();
+  return buildSimilarTrinaryOpNode(arg1subst, arg2subst, arg3subst, datatree);
+}
+
 expr_t
 TrinaryOpNode::differentiateForwardVars(const vector<string> &subset, subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const
 {
@@ -4870,6 +4966,15 @@ AbstractExternalFunctionNode::substituteExpectation(subst_table_t &subst_table,
   return buildSimilarExternalFunctionNode(arguments_subst, datatree);
 }
 
+expr_t
+AbstractExternalFunctionNode::substituteAdlAndDiff() const
+{
+  vector<expr_t> arguments_subst;
+  for (vector<expr_t>::const_iterator it = arguments.begin(); it != arguments.end(); it++)
+    arguments_subst.push_back((*it)->substituteAdlAndDiff());
+  return buildSimilarExternalFunctionNode(arguments_subst, datatree);
+}
+
 expr_t
 AbstractExternalFunctionNode::differentiateForwardVars(const vector<string> &subset, subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const
 {
@@ -6118,6 +6223,12 @@ VarExpectationNode::substituteExpectation(subst_table_t &subst_table, vector<Bin
   return const_cast<VarExpectationNode *>(this);
 }
 
+expr_t
+VarExpectationNode::substituteAdlAndDiff() const
+{
+  return const_cast<VarExpectationNode *>(this);
+}
+
 expr_t
 VarExpectationNode::differentiateForwardVars(const vector<string> &subset, subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const
 {
diff --git a/ExprNode.hh b/ExprNode.hh
index ca6cbeb7efb4183a3eed99e5f9a14f94e3ecbfa3..b4d0ce153456c8b58abeb756b8eaf046391a8b2e 100644
--- a/ExprNode.hh
+++ b/ExprNode.hh
@@ -336,6 +336,10 @@ enum ExprNodeOutputType
       //! Type for the substitution map used in the process of creating auxiliary vars for leads >= 2
       typedef map<const ExprNode *, const VariableNode *> subst_table_t;
 
+      //! Type for the substitution map used in the process of substituting adl/diff expressions
+      //      typedef map<const ExprNode *, const UnaryOpNode *> subst_table_diff_t;
+      typedef map<const ExprNode *, const expr_t> subst_table_adl_t;
+
       //! Creates auxiliary endo lead variables corresponding to this expression
       /*!
         If maximum endogenous lead >= 3, this method will also create intermediary auxiliary var, and will add the equations of the form aux1 = aux2(+1) to the substitution table.
@@ -441,6 +445,9 @@ enum ExprNodeOutputType
       */
       virtual expr_t detrend(int symb_id, bool log_trend, expr_t trend) const = 0;
 
+      //! Substitute adl and diff operators
+      virtual expr_t substituteAdlAndDiff() const = 0;
+
       //! Add ExprNodes to the provided datatree
       virtual expr_t cloneDynamic(DataTree &dynamic_datatree) const = 0;
 
@@ -510,6 +517,7 @@ public:
   virtual expr_t substituteExoLead(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool deterministic_model) const;
   virtual expr_t substituteExoLag(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
   virtual expr_t substituteExpectation(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool partial_information_model) const;
+  virtual expr_t substituteAdlAndDiff() const;
   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;
@@ -583,6 +591,7 @@ public:
   virtual expr_t substituteExoLead(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool deterministic_model) const;
   virtual expr_t substituteExoLag(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
   virtual expr_t substituteExpectation(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool partial_information_model) const;
+  virtual expr_t substituteAdlAndDiff() const;
   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;
@@ -672,6 +681,7 @@ public:
   virtual expr_t substituteExoLead(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool deterministic_model) const;
   virtual expr_t substituteExoLag(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
   virtual expr_t substituteExpectation(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool partial_information_model) const;
+  virtual expr_t substituteAdlAndDiff() const;
   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;
@@ -774,6 +784,7 @@ public:
   virtual expr_t substituteExoLead(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool deterministic_model) const;
   virtual expr_t substituteExoLag(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
   virtual expr_t substituteExpectation(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool partial_information_model) const;
+  virtual expr_t substituteAdlAndDiff() const;
   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;
@@ -858,6 +869,7 @@ public:
   virtual expr_t substituteExoLead(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool deterministic_model) const;
   virtual expr_t substituteExoLag(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
   virtual expr_t substituteExpectation(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool partial_information_model) const;
+  virtual expr_t substituteAdlAndDiff() const;
   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;
@@ -941,6 +953,7 @@ public:
   virtual expr_t substituteExoLead(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool deterministic_model) const;
   virtual expr_t substituteExoLag(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
   virtual expr_t substituteExpectation(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool partial_information_model) const;
+  virtual expr_t substituteAdlAndDiff() const;
   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;
@@ -1106,6 +1119,7 @@ public:
   virtual expr_t substituteExoLead(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool deterministic_model) const;
   virtual expr_t substituteExoLag(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs) const;
   virtual expr_t substituteExpectation(subst_table_t &subst_table, vector<BinaryOpNode *> &neweqs, bool partial_information_model) const;
+  virtual expr_t substituteAdlAndDiff() const;
   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 2aa4a39281bc5b9bc5b872f30b2d7c351ea8b317..88ef7f929923b7956a5ec1d1309b6ad906e3fb96 100644
--- a/ModFile.cc
+++ b/ModFile.cc
@@ -349,6 +349,8 @@ ModFile::transformPass(bool nostrict, bool compute_xrefs)
     }
 
   // Var Model
+  dynamic_model.substituteAdlAndDiff();
+
   map<string, pair<SymbolList, int> > var_model_info;
   for (vector<Statement *>::const_iterator it = statements.begin();
        it != statements.end(); it++)
diff --git a/ParsingDriver.cc b/ParsingDriver.cc
index d3c05fb84e83d59651fcf86c151555862377123c..e71b632124cb6cd601de5b8e192c094bf50aaeb6 100644
--- a/ParsingDriver.cc
+++ b/ParsingDriver.cc
@@ -2585,6 +2585,22 @@ ParsingDriver::add_exp(expr_t arg1)
   return data_tree->AddExp(arg1);
 }
 
+expr_t
+ParsingDriver::add_diff(expr_t arg1)
+{
+  return data_tree->AddDiff(arg1);
+}
+
+expr_t
+ParsingDriver::add_adl(expr_t arg1, string *name, string *lag)
+{
+  expr_t id = data_tree->AddAdl(arg1, *name,
+                                data_tree->AddNonNegativeConstant(*lag));
+  delete name;
+  delete lag;
+  return id;
+}
+
 expr_t
 ParsingDriver::add_log(expr_t arg1)
 {
diff --git a/ParsingDriver.hh b/ParsingDriver.hh
index 9d3eb46a094171c67e00d9927cbfd402e4a33d9f..be533089ca2ce1f666d8479890fe8bacf07b59ca 100644
--- a/ParsingDriver.hh
+++ b/ParsingDriver.hh
@@ -668,6 +668,10 @@ public:
   expr_t add_expectation(string *arg1,  expr_t arg2);
   //! Writes token "VAR_EXPECTATION(arg1, arg2, arg3)" to model tree
   expr_t add_var_expectation(string *arg1,  string *arg2, string *arg3);
+  //! Writes token "diff(arg1)" to model tree
+  expr_t add_diff(expr_t arg1);
+  //! Writes token "adl(arg1, lag)" to model tree
+  expr_t add_adl(expr_t arg1, string *name, string *lag);
   //! Writes token "exp(arg1)" to model tree
   expr_t add_exp(expr_t arg1);
   //! Writes token "log(arg1)" to model tree
diff --git a/SymbolTable.cc b/SymbolTable.cc
index fe96c90886102178563a74a33ec3d1fd1fc42345..0657fe2af048fb93955031f8b8a1f0a6a25825ac 100644
--- a/SymbolTable.cc
+++ b/SymbolTable.cc
@@ -637,6 +637,23 @@ SymbolTable::addLagAuxiliaryVarInternal(bool endo, int orig_symb_id, int orig_le
   return symb_id;
 }
 
+int
+SymbolTable::addAdlParameter(string &basename, int lag) throw (FrozenException)
+{
+  ostringstream varname;
+  varname << basename << "_lag_" << lag;
+
+  try
+    {
+      return addSymbol(varname.str(), eParameter);
+    }
+  catch (AlreadyDeclaredException &e)
+    {
+      cerr << "ERROR: you should rename your variable called " << varname.str() << ", this name is internally used by Dynare" << endl;
+      exit(EXIT_FAILURE);
+    }
+}
+
 int
 SymbolTable::addEndoLeadAuxiliaryVar(int index, expr_t expr_arg) throw (FrozenException)
 {
diff --git a/SymbolTable.hh b/SymbolTable.hh
index 8a67d6bdb743d6d4cf43343354938094fa31e6d3..9dd260ee595842e31180dea8f57deb81ece1c806 100644
--- a/SymbolTable.hh
+++ b/SymbolTable.hh
@@ -283,6 +283,10 @@ public:
   //! Adds an auxiliary variable when var_model is used with an order that is greater in absolute value
   //! than the largest lag present in the model.
   int addVarModelEndoLagAuxiliaryVar(int orig_symb_id, int orig_lead_lag, expr_t expr_arg) throw (AlreadyDeclaredException, FrozenException);
+  /*
+  // Adds a parameter for the transformation of the adl operator
+  */
+  int addAdlParameter(string &basename, int lag) throw (FrozenException);
   //! Returns the number of auxiliary variables
   int
   AuxVarsSize() const