From c4d3fef15757c3811108db4f975e344d63108959 Mon Sep 17 00:00:00 2001
From: "Yang Yang(Tony)" <yangyang62@baidu.com>
Date: Thu, 28 Sep 2017 12:07:33 -0700
Subject: [PATCH 01/29] update doc: no need to modify pybind_file

`paddle/operators/CMakeLists.txt` will automatically generate the bind.
---
 doc/design/refactorization.md | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/doc/design/refactorization.md b/doc/design/refactorization.md
index ad801ca421..ffcc069ccd 100644
--- a/doc/design/refactorization.md
+++ b/doc/design/refactorization.md
@@ -177,8 +177,6 @@ REGISTER_OP(op_type, op_class, op_maker_class, grad_op_type, grad_op_class)
 REGISTER_OP_WITHOUT_GRADIENT(op_type, op_class, op_maker_class)
 ```
 
-### `USE` Macros
-make sure the registration process is executed and linked.
 
 ---
 # Register Process
@@ -188,7 +186,7 @@ make sure the registration process is executed and linked.
 	1. call maker class to complete `proto` and `checker`
 	2. with the completed `proto` and `checker`, build a new key-value pair in the `OpInfoMap`
 
-4. Invoke `USE` macro in where the Op is used to make sure it is linked.
+
 
 ---
 # Backward Module (1/2)

From a31ff363fdb2bb02317ed72be8768dd1d5f0d2fe Mon Sep 17 00:00:00 2001
From: Yang Yang <yangyang62@baidu.com>
Date: Wed, 11 Oct 2017 23:18:08 +0000
Subject: [PATCH 02/29] prune pass dummy test

---
 paddle/framework/CMakeLists.txt  |   3 +
 paddle/framework/framework.proto |   1 +
 paddle/framework/prune.cc        | 107 +++++++++++++++++
 paddle/framework/prune.h         |  26 ++++
 paddle/framework/prune_test.cc   | 200 +++++++++++++++++++++++++++++++
 5 files changed, 337 insertions(+)
 create mode 100644 paddle/framework/prune.cc
 create mode 100644 paddle/framework/prune.h
 create mode 100644 paddle/framework/prune_test.cc

diff --git a/paddle/framework/CMakeLists.txt b/paddle/framework/CMakeLists.txt
index 6b34c3bbcf..d9c84f3c0a 100644
--- a/paddle/framework/CMakeLists.txt
+++ b/paddle/framework/CMakeLists.txt
@@ -49,5 +49,8 @@ cc_library(executor SRCS executor.cc DEPS op_registry device_context scope frame
 #    cc_test(executor_test SRCS executor_test.cc DEPS executor)
 #endif()
 
+cc_library(prune SRCS prune.cc)
+cc_test(prune_test SRCS prune_test.cc DEPS prune recurrent_op device_context)
+
 cc_library(tensor_array SRCS tensor_array.cc DEPS lod_tensor)
 cc_test(tensor_array_test SRCS tensor_array_test.cc DEPS tensor_array place)
diff --git a/paddle/framework/framework.proto b/paddle/framework/framework.proto
index b7a63f9ba1..7739c17215 100644
--- a/paddle/framework/framework.proto
+++ b/paddle/framework/framework.proto
@@ -55,6 +55,7 @@ message OpDesc {
   repeated Var inputs = 1;
   repeated Var outputs = 2;
   repeated Attr attrs = 4;
+  required bool is_target = 5 [ default = false ];
 };
 
 // OpProto describes a C++ framework::OperatorBase derived class.
diff --git a/paddle/framework/prune.cc b/paddle/framework/prune.cc
new file mode 100644
index 0000000000..ddb9ed7ae0
--- /dev/null
+++ b/paddle/framework/prune.cc
@@ -0,0 +1,107 @@
+/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include "paddle/framework/prune.h"
+
+#include <algorithm>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <glog/logging.h>
+
+namespace paddle {
+namespace framework {
+
+const std::string kFeedOpType = "feed";
+const std::string kFetchOpType = "fetch";
+
+bool HasDependentVar(const OpDesc& op_desc,
+                     const std::set<std::string>& dependent_vars) {
+  for (auto& var : op_desc.outputs()) {
+    for (auto& argu : var.arguments()) {
+      if (dependent_vars.count(argu) != 0) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+void Prune(const ProgramDesc& input, ProgramDesc& output, int id) {
+  // TODO(tonyyang-svail):
+  //    - will change to use multiple blocks for RNN op and Cond Op
+
+  auto& block = input.blocks(0);
+  auto& ops = block.ops();
+
+  bool expect_feed = true;
+  for (auto& op_desc : ops) {
+    PADDLE_ENFORCE(op_desc.type() != kFeedOpType || expect_feed,
+                   "All FeedOps are at the beginning of the ProgramDesc");
+    expect_feed = (op_desc.type() == kFeedOpType);
+  }
+
+  bool expect_fetch = true;
+  for (auto op_iter = ops.rbegin(); op_iter != ops.rend(); ++op_iter) {
+    auto& op_desc = *op_iter;
+    PADDLE_ENFORCE(op_desc.type() != kFetchOpType || expect_fetch,
+                   "All FetchOps must at the end of the ProgramDesc");
+    expect_fetch = (op_desc.type() == kFetchOpType);
+  }
+
+  std::set<std::string> dependent_vars;
+  std::vector<bool> should_run;
+  for (auto op_iter = ops.rbegin(); op_iter != ops.rend(); ++op_iter) {
+    auto& op_desc = *op_iter;
+
+    if (op_desc.is_target() || HasDependentVar(op_desc, dependent_vars)) {
+      // erase its output to the dependency graph
+      for (auto& var : op_desc.outputs()) {
+        for (auto& argu : var.arguments()) {
+          dependent_vars.erase(argu);
+        }
+      }
+
+      // insert its input to the dependency graph
+      for (auto& var : op_desc.inputs()) {
+        for (auto& argu : var.arguments()) {
+          dependent_vars.insert(argu);
+        }
+      }
+
+      should_run.push_back(true);
+    } else {
+      should_run.push_back(false);
+    }
+  }
+
+  // since we are traversing the ProgramDesc in reverse order
+  // we reverse the should_run vector
+  std::reverse(should_run.begin(), should_run.end());
+
+  output = input;
+  auto* op_field = output.mutable_blocks(id)->mutable_ops();
+  op_field->Clear();
+  for (size_t i = 0; i < should_run.size(); ++i) {
+    if (should_run[i]) {
+      *op_field->Add() = input.blocks(id).ops(i);
+    }
+  }
+
+  // return should_run;
+}
+
+}  // namespace framework
+}  // namespace paddle
diff --git a/paddle/framework/prune.h b/paddle/framework/prune.h
new file mode 100644
index 0000000000..3e1d58f61f
--- /dev/null
+++ b/paddle/framework/prune.h
@@ -0,0 +1,26 @@
+/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#pragma once
+
+#include "paddle/framework/framework.pb.h"
+#include "paddle/platform/enforce.h"
+
+namespace paddle {
+namespace framework {
+
+void Prune(const ProgramDesc& input, ProgramDesc& output, int id);
+
+}  // namespace framework
+}  // namespace paddle
diff --git a/paddle/framework/prune_test.cc b/paddle/framework/prune_test.cc
new file mode 100644
index 0000000000..b66db94528
--- /dev/null
+++ b/paddle/framework/prune_test.cc
@@ -0,0 +1,200 @@
+/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License. */
+
+#include "paddle/framework/prune.h"
+
+#include <gtest/gtest.h>
+#include "paddle/framework/attribute.h"
+#include "paddle/framework/block_desc.h"
+#include "paddle/framework/op_desc.h"
+#include "paddle/framework/op_registry.h"
+#include "paddle/framework/operator.h"
+#include "paddle/framework/program_desc.h"
+#include "paddle/operators/net_op.h"
+
+namespace paddle {
+namespace framework {
+
+using DeviceContext = platform::DeviceContext;
+
+class RowWiseAddOpMaker : public OpProtoAndCheckerMaker {
+ public:
+  RowWiseAddOpMaker(OpProto *proto, OpAttrChecker *op_checker)
+      : OpProtoAndCheckerMaker(proto, op_checker) {
+    AddInput("X", "Input X of Add");
+    AddInput("b", "Bias of Add");
+    AddOutput("Out", "Out of Add");
+    AddComment("Add Op");
+  }
+};
+
+class RowWiseAddGradMaker : public SingleGradOpDescMaker {
+ public:
+  using SingleGradOpDescMaker::SingleGradOpDescMaker;
+
+ protected:
+  std::unique_ptr<OpDescBind> Apply() const override {
+    auto grad_op = new OpDescBind();
+    grad_op->SetInput(GradVarName("Out"), OutputGrad("Out"));
+    grad_op->SetOutput(GradVarName("X"), InputGrad("X"));
+    grad_op->SetOutput(GradVarName("b"), InputGrad("b"));
+    grad_op->SetType("rowwise_add_grad");
+    return std::unique_ptr<OpDescBind>(grad_op);
+  }
+};
+
+class MulOpMaker : public OpProtoAndCheckerMaker {
+ public:
+  MulOpMaker(OpProto *proto, OpAttrChecker *op_checker)
+      : OpProtoAndCheckerMaker(proto, op_checker) {
+    AddInput("X", "A");
+    AddInput("Y", "B");
+    AddOutput("Out", "Out");
+    AddAttr<int>("x_num_col_dims", "").SetDefault(1).EqualGreaterThan(1);
+    AddAttr<int>("y_num_col_dims", "").SetDefault(1).EqualGreaterThan(1);
+    AddComment("Mul");
+  }
+};
+
+class SigmoidOpMaker : public OpProtoAndCheckerMaker {
+ public:
+  SigmoidOpMaker(OpProto *proto, OpAttrChecker *op_checker)
+      : OpProtoAndCheckerMaker(proto, op_checker) {
+    AddInput("X", "X");
+    AddOutput("Out", "Y");
+    AddComment("Sigmoid");
+  }
+};
+
+class NoGradOpMaker : public OpProtoAndCheckerMaker {
+ public:
+  NoGradOpMaker(OpProto *proto, OpAttrChecker *op_checker)
+      : OpProtoAndCheckerMaker(proto, op_checker) {
+    AddInput("X", "X input");
+    AddOutput("Out", "Y output");
+    AddComment("NoGradOp, same input output. no Grad");
+  }
+};
+
+class ManyOutputOpMaker : public OpProtoAndCheckerMaker {
+ public:
+  ManyOutputOpMaker(OpProto *proto, OpAttrChecker *op_checker)
+      : OpProtoAndCheckerMaker(proto, op_checker) {
+    AddInput("x", "x");
+    AddOutput("y", "y");
+    AddOutput("z", "z");
+    AddComment("");
+  }
+};
+
+class FillZeroOpMaker : public OpProtoAndCheckerMaker {
+ public:
+  FillZeroOpMaker(OpProto *proto, OpAttrChecker *op_checker)
+      : OpProtoAndCheckerMaker(proto, op_checker) {
+    AddInput("X", "x");
+    AddOutput("Y", "out");
+    AddComment("");
+  }
+};
+
+class SumOpMaker : public framework::OpProtoAndCheckerMaker {
+ public:
+  SumOpMaker(framework::OpProto *proto, framework::OpAttrChecker *op_checker)
+      : OpProtoAndCheckerMaker(proto, op_checker) {
+    AddInput("X", "the input tensors of sum operator.").AsDuplicable();
+    AddOutput("Out", "the output tensor of sum operator.");
+    AddComment("");
+  }
+};
+
+class MultInOutOpMaker : public OpProtoAndCheckerMaker {
+ public:
+  MultInOutOpMaker(OpProto *proto, OpAttrChecker *op_checker)
+      : OpProtoAndCheckerMaker(proto, op_checker) {
+    AddInput("X", "x");
+    AddInput("H", "h");
+    AddOutput("Y", "y");
+    AddOutput("Z", "z");
+    AddComment("");
+  }
+};
+
+}  // namespace framework
+}  // namespace paddle
+
+namespace f = paddle::framework;
+namespace ops = paddle::operators;
+using EnforceNotMet = paddle::platform::EnforceNotMet;
+REGISTER_OPERATOR(rowwise_add, f::NOP, f::RowWiseAddOpMaker,
+                  f::RowWiseAddGradMaker);
+REGISTER_OPERATOR(rowwise_add_grad, f::NOP);
+REGISTER_OP(mul, f::NOP, f::MulOpMaker, mul_grad, f::NOP);
+REGISTER_OP(sigmoid, f::NOP, f::SigmoidOpMaker, sigmoid_grad, f::NOP);
+REGISTER_OP_WITHOUT_GRADIENT(nograd, f::NOP, f::NoGradOpMaker);
+REGISTER_OP_WITHOUT_GRADIENT(fill_zeros_like, f::NOP, f::FillZeroOpMaker);
+REGISTER_OP(sum, f::NOP, f::SumOpMaker, sum_grad, f::NOP);
+REGISTER_OP(many_output_op, f::NOP, f::ManyOutputOpMaker, many_output_op_grad,
+            f::NOP);
+REGISTER_OP(mult_in_out, f::NOP, f::MultInOutOpMaker, mult_in_out_grad, f::NOP);
+
+void AddOp(const std::string &type, const f::VariableNameMap &inputs,
+           const f::VariableNameMap &outputs, f::AttributeMap attrs,
+           paddle::framework::BlockDescBind *block) {
+  // insert output
+  for (auto kv : outputs) {
+    for (auto v : kv.second) {
+      auto var = block->NewVar(v);
+      var->SetDataType(paddle::framework::DataType::FP32);
+    }
+  }
+
+  // insert op
+  auto op = block->AppendOp();
+  op->SetType(type);
+  for (auto &kv : inputs) {
+    op->SetInput(kv.first, kv.second);
+  }
+  for (auto &kv : outputs) {
+    op->SetOutput(kv.first, kv.second);
+  }
+  op->SetAttrMap(attrs);
+}
+
+f::ProgramDesc *GetNewProgramDesc() {
+  auto *program_desc = new f::ProgramDesc();
+  auto *root_block = program_desc->add_blocks();
+  root_block->set_idx(0);
+  root_block->set_parent_idx(-1);
+  return program_desc;
+}
+
+TEST(Prune, one_operator) {
+  f::ProgramDesc *program_desc = GetNewProgramDesc();
+  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::BlockDescBind *block = program.Block(0);
+
+  AddOp("mul", {{"X", {"a"}}, {"Y", {"w1"}}}, {{"Out", {"b"}}}, {}, block);
+
+  f::ProgramDesc *pdesc = program.Proto();
+  f::ProgramDesc pruned;
+
+  Prune(*pdesc, pruned, 0);
+  PADDLE_ENFORCE_EQ(pruned.blocks(0).ops_size(), 0);
+
+  pdesc->mutable_blocks(0)->mutable_ops(0)->set_is_target(true);
+  Prune(*pdesc, pruned, 0);
+  PADDLE_ENFORCE_EQ(pruned.blocks(0).ops_size(), 1);
+}
+
+TEST(Prune, simple_optimize) {}

From fd72e9c7516af791e25ebc50004f297784b87051 Mon Sep 17 00:00:00 2001
From: Yang Yang <yangyang62@baidu.com>
Date: Thu, 12 Oct 2017 00:57:58 +0000
Subject: [PATCH 03/29] pass multiple unit test

---
 paddle/framework/prune.cc      |   9 +-
 paddle/framework/prune_test.cc | 175 +++++++++++++--------------------
 2 files changed, 70 insertions(+), 114 deletions(-)

diff --git a/paddle/framework/prune.cc b/paddle/framework/prune.cc
index ddb9ed7ae0..284541f199 100644
--- a/paddle/framework/prune.cc
+++ b/paddle/framework/prune.cc
@@ -43,7 +43,7 @@ void Prune(const ProgramDesc& input, ProgramDesc& output, int id) {
   // TODO(tonyyang-svail):
   //    - will change to use multiple blocks for RNN op and Cond Op
 
-  auto& block = input.blocks(0);
+  auto& block = input.blocks(id);
   auto& ops = block.ops();
 
   bool expect_feed = true;
@@ -67,13 +67,6 @@ void Prune(const ProgramDesc& input, ProgramDesc& output, int id) {
     auto& op_desc = *op_iter;
 
     if (op_desc.is_target() || HasDependentVar(op_desc, dependent_vars)) {
-      // erase its output to the dependency graph
-      for (auto& var : op_desc.outputs()) {
-        for (auto& argu : var.arguments()) {
-          dependent_vars.erase(argu);
-        }
-      }
-
       // insert its input to the dependency graph
       for (auto& var : op_desc.inputs()) {
         for (auto& argu : var.arguments()) {
diff --git a/paddle/framework/prune_test.cc b/paddle/framework/prune_test.cc
index b66db94528..ab08b851d3 100644
--- a/paddle/framework/prune_test.cc
+++ b/paddle/framework/prune_test.cc
@@ -28,105 +28,24 @@ namespace framework {
 
 using DeviceContext = platform::DeviceContext;
 
-class RowWiseAddOpMaker : public OpProtoAndCheckerMaker {
+class OneOneOpMaker : public OpProtoAndCheckerMaker {
  public:
-  RowWiseAddOpMaker(OpProto *proto, OpAttrChecker *op_checker)
+  OneOneOpMaker(OpProto *proto, OpAttrChecker *op_checker)
       : OpProtoAndCheckerMaker(proto, op_checker) {
-    AddInput("X", "Input X of Add");
-    AddInput("b", "Bias of Add");
-    AddOutput("Out", "Out of Add");
-    AddComment("Add Op");
+    AddInput("input", "input");
+    AddOutput("output", "output");
+    AddComment("Op has one input and one output");
   }
 };
 
-class RowWiseAddGradMaker : public SingleGradOpDescMaker {
+class TwoOneOpMaker : public OpProtoAndCheckerMaker {
  public:
-  using SingleGradOpDescMaker::SingleGradOpDescMaker;
-
- protected:
-  std::unique_ptr<OpDescBind> Apply() const override {
-    auto grad_op = new OpDescBind();
-    grad_op->SetInput(GradVarName("Out"), OutputGrad("Out"));
-    grad_op->SetOutput(GradVarName("X"), InputGrad("X"));
-    grad_op->SetOutput(GradVarName("b"), InputGrad("b"));
-    grad_op->SetType("rowwise_add_grad");
-    return std::unique_ptr<OpDescBind>(grad_op);
-  }
-};
-
-class MulOpMaker : public OpProtoAndCheckerMaker {
- public:
-  MulOpMaker(OpProto *proto, OpAttrChecker *op_checker)
-      : OpProtoAndCheckerMaker(proto, op_checker) {
-    AddInput("X", "A");
-    AddInput("Y", "B");
-    AddOutput("Out", "Out");
-    AddAttr<int>("x_num_col_dims", "").SetDefault(1).EqualGreaterThan(1);
-    AddAttr<int>("y_num_col_dims", "").SetDefault(1).EqualGreaterThan(1);
-    AddComment("Mul");
-  }
-};
-
-class SigmoidOpMaker : public OpProtoAndCheckerMaker {
- public:
-  SigmoidOpMaker(OpProto *proto, OpAttrChecker *op_checker)
+  TwoOneOpMaker(OpProto *proto, OpAttrChecker *op_checker)
       : OpProtoAndCheckerMaker(proto, op_checker) {
-    AddInput("X", "X");
-    AddOutput("Out", "Y");
-    AddComment("Sigmoid");
-  }
-};
-
-class NoGradOpMaker : public OpProtoAndCheckerMaker {
- public:
-  NoGradOpMaker(OpProto *proto, OpAttrChecker *op_checker)
-      : OpProtoAndCheckerMaker(proto, op_checker) {
-    AddInput("X", "X input");
-    AddOutput("Out", "Y output");
-    AddComment("NoGradOp, same input output. no Grad");
-  }
-};
-
-class ManyOutputOpMaker : public OpProtoAndCheckerMaker {
- public:
-  ManyOutputOpMaker(OpProto *proto, OpAttrChecker *op_checker)
-      : OpProtoAndCheckerMaker(proto, op_checker) {
-    AddInput("x", "x");
-    AddOutput("y", "y");
-    AddOutput("z", "z");
-    AddComment("");
-  }
-};
-
-class FillZeroOpMaker : public OpProtoAndCheckerMaker {
- public:
-  FillZeroOpMaker(OpProto *proto, OpAttrChecker *op_checker)
-      : OpProtoAndCheckerMaker(proto, op_checker) {
-    AddInput("X", "x");
-    AddOutput("Y", "out");
-    AddComment("");
-  }
-};
-
-class SumOpMaker : public framework::OpProtoAndCheckerMaker {
- public:
-  SumOpMaker(framework::OpProto *proto, framework::OpAttrChecker *op_checker)
-      : OpProtoAndCheckerMaker(proto, op_checker) {
-    AddInput("X", "the input tensors of sum operator.").AsDuplicable();
-    AddOutput("Out", "the output tensor of sum operator.");
-    AddComment("");
-  }
-};
-
-class MultInOutOpMaker : public OpProtoAndCheckerMaker {
- public:
-  MultInOutOpMaker(OpProto *proto, OpAttrChecker *op_checker)
-      : OpProtoAndCheckerMaker(proto, op_checker) {
-    AddInput("X", "x");
-    AddInput("H", "h");
-    AddOutput("Y", "y");
-    AddOutput("Z", "z");
-    AddComment("");
+    AddInput("input_1", "input_1");
+    AddInput("input_2", "input_2");
+    AddOutput("output", "output");
+    AddComment("Op has two inputs and one output");
   }
 };
 
@@ -135,18 +54,8 @@ class MultInOutOpMaker : public OpProtoAndCheckerMaker {
 
 namespace f = paddle::framework;
 namespace ops = paddle::operators;
-using EnforceNotMet = paddle::platform::EnforceNotMet;
-REGISTER_OPERATOR(rowwise_add, f::NOP, f::RowWiseAddOpMaker,
-                  f::RowWiseAddGradMaker);
-REGISTER_OPERATOR(rowwise_add_grad, f::NOP);
-REGISTER_OP(mul, f::NOP, f::MulOpMaker, mul_grad, f::NOP);
-REGISTER_OP(sigmoid, f::NOP, f::SigmoidOpMaker, sigmoid_grad, f::NOP);
-REGISTER_OP_WITHOUT_GRADIENT(nograd, f::NOP, f::NoGradOpMaker);
-REGISTER_OP_WITHOUT_GRADIENT(fill_zeros_like, f::NOP, f::FillZeroOpMaker);
-REGISTER_OP(sum, f::NOP, f::SumOpMaker, sum_grad, f::NOP);
-REGISTER_OP(many_output_op, f::NOP, f::ManyOutputOpMaker, many_output_op_grad,
-            f::NOP);
-REGISTER_OP(mult_in_out, f::NOP, f::MultInOutOpMaker, mult_in_out_grad, f::NOP);
+REGISTER_OP_WITHOUT_GRADIENT(one_one, f::NOP, f::OneOneOpMaker);
+REGISTER_OP_WITHOUT_GRADIENT(two_one, f::NOP, f::TwoOneOpMaker);
 
 void AddOp(const std::string &type, const f::VariableNameMap &inputs,
            const f::VariableNameMap &outputs, f::AttributeMap attrs,
@@ -184,7 +93,7 @@ TEST(Prune, one_operator) {
   f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
   f::BlockDescBind *block = program.Block(0);
 
-  AddOp("mul", {{"X", {"a"}}, {"Y", {"w1"}}}, {{"Out", {"b"}}}, {}, block);
+  AddOp("one_one", {{"input", {"a"}}}, {{"output", {"b"}}}, {}, block);
 
   f::ProgramDesc *pdesc = program.Proto();
   f::ProgramDesc pruned;
@@ -197,4 +106,58 @@ TEST(Prune, one_operator) {
   PADDLE_ENFORCE_EQ(pruned.blocks(0).ops_size(), 1);
 }
 
-TEST(Prune, simple_optimize) {}
+TEST(Prune, forward) {
+  f::ProgramDesc *program_desc = GetNewProgramDesc();
+  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::BlockDescBind *block = program.Block(0);
+
+  AddOp("one_one", {{"input", {"a"}}}, {{"output", {"b"}}}, {}, block);
+  AddOp("one_one", {{"input", {"b"}}}, {{"output", {"c"}}}, {}, block);
+  AddOp("one_one", {{"input", {"c"}}}, {{"output", {"d"}}}, {}, block);
+  AddOp("one_one", {{"input", {"d"}}}, {{"output", {"e"}}}, {}, block);
+
+  f::ProgramDesc *pdesc = program.Proto();
+
+  for (int i = 0; i < pdesc->blocks(0).ops_size(); ++i) {
+    f::ProgramDesc pruned;
+    pdesc->mutable_blocks(0)->mutable_ops(i)->set_is_target(true);
+    Prune(*pdesc, pruned, 0);
+    PADDLE_ENFORCE_EQ(pruned.blocks(0).ops_size(), i + 1);
+  }
+}
+
+TEST(Prune, multi_input_op) {
+  f::ProgramDesc *program_desc = GetNewProgramDesc();
+  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::BlockDescBind *block = program.Block(0);
+
+  AddOp("one_one", {{"input", {"a0"}}}, {{"output", {"b0"}}}, {}, block);
+  AddOp("one_one", {{"input", {"a1"}}}, {{"output", {"b1"}}}, {}, block);
+  AddOp("one_one", {{"input", {"a2"}}}, {{"output", {"b2"}}}, {}, block);
+  AddOp("three_one", {{"input", {"b0", "b1", "b2"}}}, {{"output", {"c"}}}, {},
+        block);
+
+  f::ProgramDesc *pdesc = program.Proto();
+  pdesc->mutable_blocks(0)->mutable_ops(3)->set_is_target(true);
+
+  f::ProgramDesc pruned;
+  Prune(*pdesc, pruned, 0);
+  PADDLE_ENFORCE_EQ(pruned.blocks(0).ops_size(), 4);
+}
+
+TEST(Prune, multi_output_op) {
+  f::ProgramDesc *program_desc = GetNewProgramDesc();
+  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::BlockDescBind *block = program.Block(0);
+
+  AddOp("one_two", {{"input", {"a"}}}, {{"output", {"b", "c"}}}, {}, block);
+  AddOp("one_one", {{"input", {"b"}}}, {{"output", {"b1"}}}, {}, block);
+  AddOp("one_one", {{"input", {"c"}}}, {{"output", {"c1"}}}, {}, block);
+
+  f::ProgramDesc *pdesc = program.Proto();
+  pdesc->mutable_blocks(0)->mutable_ops(2)->set_is_target(true);
+
+  f::ProgramDesc pruned;
+  Prune(*pdesc, pruned, 0);
+  PADDLE_ENFORCE_EQ(pruned.blocks(0).ops_size(), 2);
+}

From fc96463b25c1f0bf9d48541bdfb2d0f0cf3e082b Mon Sep 17 00:00:00 2001
From: Yang Yang <yangyang62@baidu.com>
Date: Thu, 12 Oct 2017 01:15:37 +0000
Subject: [PATCH 04/29] pass multiple target

---
 paddle/framework/prune_test.cc | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/paddle/framework/prune_test.cc b/paddle/framework/prune_test.cc
index ab08b851d3..790fa16924 100644
--- a/paddle/framework/prune_test.cc
+++ b/paddle/framework/prune_test.cc
@@ -161,3 +161,21 @@ TEST(Prune, multi_output_op) {
   Prune(*pdesc, pruned, 0);
   PADDLE_ENFORCE_EQ(pruned.blocks(0).ops_size(), 2);
 }
+
+TEST(Prune, multi_target) {
+  f::ProgramDesc *program_desc = GetNewProgramDesc();
+  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::BlockDescBind *block = program.Block(0);
+
+  AddOp("one_two", {{"input", {"a"}}}, {{"output", {"b", "c"}}}, {}, block);
+  AddOp("one_one", {{"input", {"b"}}}, {{"output", {"b1"}}}, {}, block);
+  AddOp("one_one", {{"input", {"c"}}}, {{"output", {"c1"}}}, {}, block);
+
+  f::ProgramDesc *pdesc = program.Proto();
+  pdesc->mutable_blocks(0)->mutable_ops(1)->set_is_target(true);
+  pdesc->mutable_blocks(0)->mutable_ops(2)->set_is_target(true);
+
+  f::ProgramDesc pruned;
+  Prune(*pdesc, pruned, 0);
+  PADDLE_ENFORCE_EQ(pruned.blocks(0).ops_size(), 3);
+}

From 58b8a1ae4c9854ed04483f14c6f93dc0d74b9fcf Mon Sep 17 00:00:00 2001
From: Yang Yang <yangyang62@baidu.com>
Date: Thu, 12 Oct 2017 02:31:51 +0000
Subject: [PATCH 05/29] prune link fail

---
 paddle/framework/CMakeLists.txt | 2 +-
 paddle/framework/prune_test.cc  | 2 --
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/paddle/framework/CMakeLists.txt b/paddle/framework/CMakeLists.txt
index d9c84f3c0a..1ba23a2c3f 100644
--- a/paddle/framework/CMakeLists.txt
+++ b/paddle/framework/CMakeLists.txt
@@ -50,7 +50,7 @@ cc_library(executor SRCS executor.cc DEPS op_registry device_context scope frame
 #endif()
 
 cc_library(prune SRCS prune.cc)
-cc_test(prune_test SRCS prune_test.cc DEPS prune recurrent_op device_context)
+cc_test(prune_test SRCS prune_test.cc DEPS op_info prune recurrent_op device_context)
 
 cc_library(tensor_array SRCS tensor_array.cc DEPS lod_tensor)
 cc_test(tensor_array_test SRCS tensor_array_test.cc DEPS tensor_array place)
diff --git a/paddle/framework/prune_test.cc b/paddle/framework/prune_test.cc
index 790fa16924..c351c12d22 100644
--- a/paddle/framework/prune_test.cc
+++ b/paddle/framework/prune_test.cc
@@ -54,8 +54,6 @@ class TwoOneOpMaker : public OpProtoAndCheckerMaker {
 
 namespace f = paddle::framework;
 namespace ops = paddle::operators;
-REGISTER_OP_WITHOUT_GRADIENT(one_one, f::NOP, f::OneOneOpMaker);
-REGISTER_OP_WITHOUT_GRADIENT(two_one, f::NOP, f::TwoOneOpMaker);
 
 void AddOp(const std::string &type, const f::VariableNameMap &inputs,
            const f::VariableNameMap &outputs, f::AttributeMap attrs,

From 7c48335b7cfe257c30b6ccc7991151d441859175 Mon Sep 17 00:00:00 2001
From: Yang Yang <yangyang62@baidu.com>
Date: Mon, 16 Oct 2017 17:44:57 +0000
Subject: [PATCH 06/29] merge fix linking

---
 paddle/framework/prune_test.cc | 38 +++++-----------------------------
 1 file changed, 5 insertions(+), 33 deletions(-)

diff --git a/paddle/framework/prune_test.cc b/paddle/framework/prune_test.cc
index c351c12d22..dc066facb2 100644
--- a/paddle/framework/prune_test.cc
+++ b/paddle/framework/prune_test.cc
@@ -14,43 +14,15 @@
 
 #include "paddle/framework/prune.h"
 
-#include <gtest/gtest.h>
 #include "paddle/framework/attribute.h"
-#include "paddle/framework/block_desc.h"
-#include "paddle/framework/op_desc.h"
-#include "paddle/framework/op_registry.h"
 #include "paddle/framework/operator.h"
-#include "paddle/framework/program_desc.h"
 #include "paddle/operators/net_op.h"
 
-namespace paddle {
-namespace framework {
-
-using DeviceContext = platform::DeviceContext;
-
-class OneOneOpMaker : public OpProtoAndCheckerMaker {
- public:
-  OneOneOpMaker(OpProto *proto, OpAttrChecker *op_checker)
-      : OpProtoAndCheckerMaker(proto, op_checker) {
-    AddInput("input", "input");
-    AddOutput("output", "output");
-    AddComment("Op has one input and one output");
-  }
-};
-
-class TwoOneOpMaker : public OpProtoAndCheckerMaker {
- public:
-  TwoOneOpMaker(OpProto *proto, OpAttrChecker *op_checker)
-      : OpProtoAndCheckerMaker(proto, op_checker) {
-    AddInput("input_1", "input_1");
-    AddInput("input_2", "input_2");
-    AddOutput("output", "output");
-    AddComment("Op has two inputs and one output");
-  }
-};
+#include "paddle/framework/block_desc.h"
+#include "paddle/framework/op_desc.h"
+#include "paddle/framework/program_desc.h"
 
-}  // namespace framework
-}  // namespace paddle
+#include <gtest/gtest.h>
 
 namespace f = paddle::framework;
 namespace ops = paddle::operators;
@@ -61,7 +33,7 @@ void AddOp(const std::string &type, const f::VariableNameMap &inputs,
   // insert output
   for (auto kv : outputs) {
     for (auto v : kv.second) {
-      auto var = block->NewVar(v);
+      auto var = block->Var(v);
       var->SetDataType(paddle::framework::DataType::FP32);
     }
   }

From a64a6f527b5c170b726c205cb6548b19171d5810 Mon Sep 17 00:00:00 2001
From: Yang Yang <yangyang62@baidu.com>
Date: Mon, 16 Oct 2017 18:17:25 +0000
Subject: [PATCH 07/29] id to block_id

---
 paddle/framework/prune.cc | 8 ++++----
 paddle/framework/prune.h  | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/paddle/framework/prune.cc b/paddle/framework/prune.cc
index 284541f199..c9a1d7d5cf 100644
--- a/paddle/framework/prune.cc
+++ b/paddle/framework/prune.cc
@@ -39,11 +39,11 @@ bool HasDependentVar(const OpDesc& op_desc,
   return false;
 }
 
-void Prune(const ProgramDesc& input, ProgramDesc& output, int id) {
+void Prune(const ProgramDesc& input, ProgramDesc& output, int block_id) {
   // TODO(tonyyang-svail):
   //    - will change to use multiple blocks for RNN op and Cond Op
 
-  auto& block = input.blocks(id);
+  auto& block = input.blocks(block_id);
   auto& ops = block.ops();
 
   bool expect_feed = true;
@@ -85,11 +85,11 @@ void Prune(const ProgramDesc& input, ProgramDesc& output, int id) {
   std::reverse(should_run.begin(), should_run.end());
 
   output = input;
-  auto* op_field = output.mutable_blocks(id)->mutable_ops();
+  auto* op_field = output.mutable_blocks(block_id)->mutable_ops();
   op_field->Clear();
   for (size_t i = 0; i < should_run.size(); ++i) {
     if (should_run[i]) {
-      *op_field->Add() = input.blocks(id).ops(i);
+      *op_field->Add() = input.blocks(block_id).ops(i);
     }
   }
 
diff --git a/paddle/framework/prune.h b/paddle/framework/prune.h
index 3e1d58f61f..1c74d3b763 100644
--- a/paddle/framework/prune.h
+++ b/paddle/framework/prune.h
@@ -20,7 +20,7 @@ limitations under the License. */
 namespace paddle {
 namespace framework {
 
-void Prune(const ProgramDesc& input, ProgramDesc& output, int id);
+void Prune(const ProgramDesc& input, ProgramDesc& output, int block_id);
 
 }  // namespace framework
 }  // namespace paddle

From 865c2c8ed870a35369c2914d7723f6359d6e8c49 Mon Sep 17 00:00:00 2001
From: Yang Yang <yangyang62@baidu.com>
Date: Mon, 16 Oct 2017 19:38:39 +0000
Subject: [PATCH 08/29] add compile DEPS

---
 paddle/framework/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/paddle/framework/CMakeLists.txt b/paddle/framework/CMakeLists.txt
index 00a9802ef8..9d039a54d6 100644
--- a/paddle/framework/CMakeLists.txt
+++ b/paddle/framework/CMakeLists.txt
@@ -51,7 +51,7 @@ else()
     cc_test(executor_test SRCS executor_test.cc DEPS executor ${EXECUTOR_TEST_OP})
 endif()
 
-cc_library(prune SRCS prune.cc)
+cc_library(prune SRCS prune.cc DEPS framework_proto)
 cc_test(prune_test SRCS prune_test.cc DEPS op_info prune recurrent_op device_context)
 
 cc_library(tensor_array SRCS tensor_array.cc DEPS lod_tensor)

From e0cee58c844ff7fdabdad9fe0a0e25341384bfdf Mon Sep 17 00:00:00 2001
From: Yang Yang <yangyang62@baidu.com>
Date: Tue, 17 Oct 2017 02:48:35 +0000
Subject: [PATCH 09/29] modify protobuf

---
 paddle/framework/framework.proto | 2 +-
 paddle/framework/prune.cc        | 9 ++++++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/paddle/framework/framework.proto b/paddle/framework/framework.proto
index fd4c0440eb..008fb45fb7 100644
--- a/paddle/framework/framework.proto
+++ b/paddle/framework/framework.proto
@@ -55,7 +55,7 @@ message OpDesc {
   repeated Var inputs = 1;
   repeated Var outputs = 2;
   repeated Attr attrs = 4;
-  required bool is_target = 5 [ default = false ];
+  optional bool is_target = 5 [ default = false ];
 };
 
 // OpProto describes a C++ framework::OperatorBase derived class.
diff --git a/paddle/framework/prune.cc b/paddle/framework/prune.cc
index c9a1d7d5cf..b08e0116b7 100644
--- a/paddle/framework/prune.cc
+++ b/paddle/framework/prune.cc
@@ -39,6 +39,13 @@ bool HasDependentVar(const OpDesc& op_desc,
   return false;
 }
 
+bool IsTarget(const OpDesc& op_desc) {
+  if (op_desc.has_is_target()) {
+    return op_desc.is_target();
+  }
+  return false;
+}
+
 void Prune(const ProgramDesc& input, ProgramDesc& output, int block_id) {
   // TODO(tonyyang-svail):
   //    - will change to use multiple blocks for RNN op and Cond Op
@@ -66,7 +73,7 @@ void Prune(const ProgramDesc& input, ProgramDesc& output, int block_id) {
   for (auto op_iter = ops.rbegin(); op_iter != ops.rend(); ++op_iter) {
     auto& op_desc = *op_iter;
 
-    if (op_desc.is_target() || HasDependentVar(op_desc, dependent_vars)) {
+    if (IsTarget(op_desc) || HasDependentVar(op_desc, dependent_vars)) {
       // insert its input to the dependency graph
       for (auto& var : op_desc.inputs()) {
         for (auto& argu : var.arguments()) {

From bdca4b37c434b26b2c6ae300899a1c562a82e133 Mon Sep 17 00:00:00 2001
From: Yang Yang <yangyang62@baidu.com>
Date: Tue, 17 Oct 2017 02:58:08 +0000
Subject: [PATCH 10/29] change api based on design doc

---
 paddle/framework/prune.cc      |  6 ++++--
 paddle/framework/prune.h       |  2 +-
 paddle/framework/prune_test.cc | 12 ++++++------
 3 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/paddle/framework/prune.cc b/paddle/framework/prune.cc
index b08e0116b7..9583369292 100644
--- a/paddle/framework/prune.cc
+++ b/paddle/framework/prune.cc
@@ -46,7 +46,7 @@ bool IsTarget(const OpDesc& op_desc) {
   return false;
 }
 
-void Prune(const ProgramDesc& input, ProgramDesc& output, int block_id) {
+void prune_impl(const ProgramDesc& input, ProgramDesc& output, int block_id) {
   // TODO(tonyyang-svail):
   //    - will change to use multiple blocks for RNN op and Cond Op
 
@@ -99,8 +99,10 @@ void Prune(const ProgramDesc& input, ProgramDesc& output, int block_id) {
       *op_field->Add() = input.blocks(block_id).ops(i);
     }
   }
+}
 
-  // return should_run;
+void Prune(const ProgramDesc& input, ProgramDesc& output) {
+  prune_impl(input, output, 0);
 }
 
 }  // namespace framework
diff --git a/paddle/framework/prune.h b/paddle/framework/prune.h
index 1c74d3b763..9414ac64f9 100644
--- a/paddle/framework/prune.h
+++ b/paddle/framework/prune.h
@@ -20,7 +20,7 @@ limitations under the License. */
 namespace paddle {
 namespace framework {
 
-void Prune(const ProgramDesc& input, ProgramDesc& output, int block_id);
+void Prune(const ProgramDesc& input, ProgramDesc& output);
 
 }  // namespace framework
 }  // namespace paddle
diff --git a/paddle/framework/prune_test.cc b/paddle/framework/prune_test.cc
index dc066facb2..a8faf1891e 100644
--- a/paddle/framework/prune_test.cc
+++ b/paddle/framework/prune_test.cc
@@ -68,11 +68,11 @@ TEST(Prune, one_operator) {
   f::ProgramDesc *pdesc = program.Proto();
   f::ProgramDesc pruned;
 
-  Prune(*pdesc, pruned, 0);
+  Prune(*pdesc, pruned);
   PADDLE_ENFORCE_EQ(pruned.blocks(0).ops_size(), 0);
 
   pdesc->mutable_blocks(0)->mutable_ops(0)->set_is_target(true);
-  Prune(*pdesc, pruned, 0);
+  Prune(*pdesc, pruned);
   PADDLE_ENFORCE_EQ(pruned.blocks(0).ops_size(), 1);
 }
 
@@ -91,7 +91,7 @@ TEST(Prune, forward) {
   for (int i = 0; i < pdesc->blocks(0).ops_size(); ++i) {
     f::ProgramDesc pruned;
     pdesc->mutable_blocks(0)->mutable_ops(i)->set_is_target(true);
-    Prune(*pdesc, pruned, 0);
+    Prune(*pdesc, pruned);
     PADDLE_ENFORCE_EQ(pruned.blocks(0).ops_size(), i + 1);
   }
 }
@@ -111,7 +111,7 @@ TEST(Prune, multi_input_op) {
   pdesc->mutable_blocks(0)->mutable_ops(3)->set_is_target(true);
 
   f::ProgramDesc pruned;
-  Prune(*pdesc, pruned, 0);
+  Prune(*pdesc, pruned);
   PADDLE_ENFORCE_EQ(pruned.blocks(0).ops_size(), 4);
 }
 
@@ -128,7 +128,7 @@ TEST(Prune, multi_output_op) {
   pdesc->mutable_blocks(0)->mutable_ops(2)->set_is_target(true);
 
   f::ProgramDesc pruned;
-  Prune(*pdesc, pruned, 0);
+  Prune(*pdesc, pruned);
   PADDLE_ENFORCE_EQ(pruned.blocks(0).ops_size(), 2);
 }
 
@@ -146,6 +146,6 @@ TEST(Prune, multi_target) {
   pdesc->mutable_blocks(0)->mutable_ops(2)->set_is_target(true);
 
   f::ProgramDesc pruned;
-  Prune(*pdesc, pruned, 0);
+  Prune(*pdesc, pruned);
   PADDLE_ENFORCE_EQ(pruned.blocks(0).ops_size(), 3);
 }

From c7ebe0e134d4c9a22bc10b14d0752b7c640e2197 Mon Sep 17 00:00:00 2001
From: "Yang Yang(Tony)" <yangyang62@baidu.com>
Date: Tue, 17 Oct 2017 10:34:11 -0700
Subject: [PATCH 11/29] Update refactorization.md

---
 doc/design/refactorization.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/doc/design/refactorization.md b/doc/design/refactorization.md
index bf24022504..f93d6155e1 100644
--- a/doc/design/refactorization.md
+++ b/doc/design/refactorization.md
@@ -185,9 +185,6 @@ REGISTER_OP_WITHOUT_GRADIENT(op_type, op_class, op_maker_class)
 	1. Call maker class to complete `proto` and `checker`
 	2. Using the completed `proto` and `checker`, it will add a new key-value pair to the `OpInfoMap`
 
-
-4. Invoke the `USE` macro in which the Op is used to make sure that it is linked.
-
 ---
 # Backward Module (1/2)
 ### Create Backward Operator

From 182ce51c6d73d98420aa91d998a328503eac538d Mon Sep 17 00:00:00 2001
From: qijun <qijun1994@hotmail.com>
Date: Tue, 17 Oct 2017 14:48:40 -0700
Subject: [PATCH 12/29] add sparse kernel of sgd operator

---
 paddle/operators/sgd_op.cc | 40 ++++++++++++++++++++++---
 paddle/operators/sgd_op.cu | 60 ++++++++++++++++++++++++++++++++++++++
 paddle/operators/sgd_op.h  | 47 ++++++++++++++++++++---------
 3 files changed, 130 insertions(+), 17 deletions(-)

diff --git a/paddle/operators/sgd_op.cc b/paddle/operators/sgd_op.cc
index 0f78eeab9b..e26a1c7893 100644
--- a/paddle/operators/sgd_op.cc
+++ b/paddle/operators/sgd_op.cc
@@ -21,7 +21,7 @@ class SGDOp : public framework::OperatorWithKernel {
  public:
   using framework::OperatorWithKernel::OperatorWithKernel;
 
-  void InferShape(framework::InferShapeContext *ctx) const override {
+  void InferShape(framework::InferShapeContext* ctx) const override {
     PADDLE_ENFORCE(ctx->HasInput("Param"),
                    "Input(Param) of SGDOp should not be null.");
     PADDLE_ENFORCE(ctx->HasInput("Grad"),
@@ -35,15 +35,15 @@ class SGDOp : public framework::OperatorWithKernel {
     PADDLE_ENFORCE_EQ(framework::product(lr_dims), 1,
                       "Learning rate should have 1 element");
     auto param_dim = ctx->GetInputDim("Param");
-    PADDLE_ENFORCE_EQ(param_dim, ctx->GetInputDim("Grad"),
-                      "Two input of SGD Op's dimension must be same.");
+    // TODO(qijun): check dimensions of Param and Grad at complie
+    // and run time.
     ctx->SetOutputDim("ParamOut", param_dim);
   }
 };
 
 class SGDOpMaker : public framework::OpProtoAndCheckerMaker {
  public:
-  SGDOpMaker(framework::OpProto *proto, framework::OpAttrChecker *op_checker)
+  SGDOpMaker(framework::OpProto* proto, framework::OpAttrChecker* op_checker)
       : OpProtoAndCheckerMaker(proto, op_checker) {
     AddInput("Param", "Input parameter");
     AddInput("LearningRate", "Learning rate of SGD");
@@ -58,6 +58,38 @@ param_out = param - learning_rate * grad;
 )DOC");
   }
 };
+
+template <typename T>
+struct SparseSGDFunctor<platform::CPUPlace, T> {
+  void operator()(const platform::DeviceContext& ctx,
+                  const framework::SelectedRows& input,
+                  const framework::Tensor& learning_rate,
+                  framework::Tensor* output) {
+    auto in_height = input.height();
+    auto out_dims = output->dims();
+    PADDLE_ENFORCE_EQ(in_height, out_dims[0]);
+
+    auto& in_value = input.value();
+    auto& in_rows = input.rows();
+
+    int64_t in_row_numel = in_value.numel() / in_rows.size();
+    PADDLE_ENFORCE_EQ(in_row_numel, output->numel() / in_height);
+
+    auto* in_data = in_value.data<T>();
+    auto* out_data = output->data<T>();
+    auto* lr = learning_rate.data<T>();
+
+    for (size_t i = 0; i < in_rows.size(); i++) {
+      for (int64_t j = 0; j < in_row_numel; j++) {
+        out_data[in_rows[i] * in_row_numel + j] -=
+            lr[0] * in_data[i * in_row_numel + j];
+      }
+    }
+  }
+};
+
+template struct SparseSGDFunctor<platform::CPUPlace, float>;
+
 }  // namespace operators
 }  // namespace paddle
 
diff --git a/paddle/operators/sgd_op.cu b/paddle/operators/sgd_op.cu
index f5ba6d3c29..5c28314141 100644
--- a/paddle/operators/sgd_op.cu
+++ b/paddle/operators/sgd_op.cu
@@ -14,6 +14,66 @@
 
 #define EIGEN_USE_GPU
 #include "paddle/operators/sgd_op.h"
+#include "paddle/platform/cuda_helper.h"
+
+namespace paddle {
+namespace operators {
+
+namespace {
+template <typename T>
+__global__ void SparseSGDFunctorKernel(const T* selected_rows,
+                                       const int64_t* rows,
+                                       const T* learning_rate, T* tensor_out,
+                                       int64_t row_numel, int block_size) {
+  const int ty = blockIdx.y;
+  int tid = threadIdx.x;
+
+  selected_rows += ty * row_numel;
+  tensor_out += rows[ty] * row_numel;
+
+  for (int index = tid; index < row_numel; index += block_size) {
+    // Since index in rows of SelectedRows can be duplicate, we have to use
+    // Atomic Operation to avoid concurrent write error.
+    paddle::platform::CudaAtomicSub(tensor_out + index,
+                                    learning_rate[0] * selected_rows[index]);
+  }
+}
+}  // namespace
+
+template <typename T>
+struct SparseSGDFunctor<platform::GPUPlace, T> {
+  void operator()(const platform::DeviceContext& ctx,
+                  const framework::SelectedRows& input,
+                  const framework::Tensor& learning_rate,
+                  framework::Tensor* output) {
+    auto in_height = input.height();
+    auto out_dims = output->dims();
+    PADDLE_ENFORCE_EQ(in_height, out_dims[0]);
+
+    auto& in_value = input.value();
+    auto& in_rows = input.rows();
+
+    int64_t in_row_numel = in_value.numel() / in_rows.size();
+    PADDLE_ENFORCE_EQ(in_row_numel, output->numel() / in_height);
+
+    auto* in_data = in_value.data<T>();
+    auto* out_data = output->data<T>();
+
+    int block_size = 256;
+    dim3 threads(block_size, 1);
+    dim3 grid(1, in_rows.size());
+    SparseSGDFunctorKernel<
+        T><<<grid, threads, 0,
+             reinterpret_cast<const platform::CUDADeviceContext&>(context)
+                 .stream()>>>(in_data, in_rows.data(), learning_rate.data<T>(),
+                              out_data, in_row_numel, block_size);
+  }
+};
+
+template struct SparseSGDFunctor<platform::GPUPlace, float>;
+
+}  // namespace operators
+}  // namespace paddle
 
 namespace ops = paddle::operators;
 REGISTER_OP_GPU_KERNEL(sgd,
diff --git a/paddle/operators/sgd_op.h b/paddle/operators/sgd_op.h
index 26f4012f25..a872d7f749 100644
--- a/paddle/operators/sgd_op.h
+++ b/paddle/operators/sgd_op.h
@@ -15,31 +15,52 @@ limitations under the License. */
 #pragma once
 #include "paddle/framework/eigen.h"
 #include "paddle/framework/op_registry.h"
+#include "paddle/framework/selected_rows.h"
 
 namespace paddle {
 namespace operators {
 
+template <typename Place, typename T>
+struct SparseSGDFunctor {
+  void operator()(const platform::DeviceContext& ctx,
+                  const framework::SelectedRows& input,
+                  const framework::Tensor& learning_rate,
+                  framework::Tensor* output);
+};
+
 template <typename Place, typename T>
 class SGDOpKernel : public framework::OpKernel<T> {
  public:
   void Compute(const framework::ExecutionContext& ctx) const override {
-    auto param = ctx.Input<framework::Tensor>("Param");
-    auto grad = ctx.Input<framework::Tensor>("Grad");
-    auto param_out = ctx.Output<framework::Tensor>("ParamOut");
-    auto learning_rate = ctx.Input<framework::Tensor>("LearningRate");
+    auto* param = ctx.Input<framework::Tensor>("Param");
+    auto* param_out = ctx.Output<framework::Tensor>("ParamOut");
+    auto* learning_rate = ctx.Input<framework::Tensor>("LearningRate");
 
-    param_out->mutable_data<T>(ctx.GetPlace());
+    auto* grad_var = ctx.InputVar("Grad");
+    if (grad_var->IsType<framework::Tensor>()) {
+      param_out->mutable_data<T>(ctx.GetPlace());
+      auto* grad = ctx.Input<framework::Tensor>("Grad");
 
-    auto p = framework::EigenVector<T>::Flatten(*param);
-    auto g = framework::EigenVector<T>::Flatten(*grad);
-    auto o = framework::EigenVector<T>::Flatten(*param_out);
-    auto lr = framework::EigenVector<T>::Flatten(*learning_rate);
-    auto place = ctx.GetEigenDevice<Place>();
+      auto p = framework::EigenVector<T>::Flatten(*param);
+      auto g = framework::EigenVector<T>::Flatten(*grad);
+      auto o = framework::EigenVector<T>::Flatten(*param_out);
+      auto lr = framework::EigenVector<T>::Flatten(*learning_rate);
+      auto place = ctx.GetEigenDevice<Place>();
 
-    Eigen::DSizes<int, 1> grad_dsize(grad->numel());
-    o.device(place) = p - lr.broadcast(grad_dsize) * g;
+      Eigen::DSizes<int, 1> grad_dsize(grad->numel());
+      o.device(place) = p - lr.broadcast(grad_dsize) * g;
+    } else if (grad_var->IsType<framework::SelectedRows>()) {
+      // TODO(qijun): In Sparse SGD operator, in-place update is enforced.
+      // This manual optimization brings difficulty to track data dependency.
+      // It's better to find a more elegant solution.
+      PADDLE_ENFORCE_EQ(param, param_out);
+      auto* grad = ctx.Input<framework::SelectedRows>("Grad");
+      SparseSGDFunctor<Place, T> functor;
+      functor(ctx.device_context(), *grad, *learning_rate, param_out);
+    } else {
+      PADDLE_THROW("Unsupported Variable Type of Grad");
+    }
   }
 };
-
 }  // namespace operators
 }  // namespace paddle

From ab8cc401e61dd49d393a72903a427ea6fa14bec7 Mon Sep 17 00:00:00 2001
From: qijun <qijun1994@hotmail.com>
Date: Tue, 17 Oct 2017 16:05:05 -0700
Subject: [PATCH 13/29] add sparse sgd operator unittest

---
 paddle/operators/sgd_op.h                     |  3 +-
 paddle/pybind/pybind.cc                       |  5 ++
 .../v2/framework/tests/test_selected_rows.py  | 23 +++----
 .../paddle/v2/framework/tests/test_sgd_op.py  | 60 +++++++++++++++++++
 4 files changed, 79 insertions(+), 12 deletions(-)

diff --git a/paddle/operators/sgd_op.h b/paddle/operators/sgd_op.h
index a872d7f749..8c28d5e66b 100644
--- a/paddle/operators/sgd_op.h
+++ b/paddle/operators/sgd_op.h
@@ -37,7 +37,8 @@ class SGDOpKernel : public framework::OpKernel<T> {
     auto* learning_rate = ctx.Input<framework::Tensor>("LearningRate");
 
     auto* grad_var = ctx.InputVar("Grad");
-    if (grad_var->IsType<framework::Tensor>()) {
+    // Actually, all tensors are LoDTensor except SelectedRows.
+    if (grad_var->IsType<framework::LoDTensor>()) {
       param_out->mutable_data<T>(ctx.GetPlace());
       auto* grad = ctx.Input<framework::Tensor>("Grad");
 
diff --git a/paddle/pybind/pybind.cc b/paddle/pybind/pybind.cc
index fcae92ad99..65e265b614 100644
--- a/paddle/pybind/pybind.cc
+++ b/paddle/pybind/pybind.cc
@@ -186,6 +186,11 @@ All parameter, weight, gradient are variables in Paddle.
              return self.GetMutable<LoDTensor>();
            },
            py::return_value_policy::reference)
+      .def("get_selected_rows",
+           [](Variable &self) -> SelectedRows * {
+             return self.GetMutable<SelectedRows>();
+           },
+           py::return_value_policy::reference)
       .def("get_net",
            [](Variable &self) -> operators::NetOp * {
              return self.GetMutable<operators::NetOp>();
diff --git a/python/paddle/v2/framework/tests/test_selected_rows.py b/python/paddle/v2/framework/tests/test_selected_rows.py
index 661e818179..e8a930cb08 100644
--- a/python/paddle/v2/framework/tests/test_selected_rows.py
+++ b/python/paddle/v2/framework/tests/test_selected_rows.py
@@ -8,29 +8,30 @@ class TestSelectedRows(unittest.TestCase):
         place = core.CPUPlace()
         height = 10
         rows = [0, 4, 7]
-        row_numel = 10
-        selcted_rows = core.SelectedRows(rows, row_numel)
-        np_array = np.ones((len(rows), height)).astype("float32")
+        row_numel = 12
+        selected_rows = core.SelectedRows(rows, height)
+        np_array = np.ones((len(rows), row_numel)).astype("float32")
         np_array[0, 0] = 2.0
         np_array[2, 8] = 4.0
-        tensor = selcted_rows.get_tensor()
+        tensor = selected_rows.get_tensor()
         tensor.set(np_array, place)
 
         # compare rows
-        self.assertEqual(0, selcted_rows.rows()[0])
-        self.assertEqual(4, selcted_rows.rows()[1])
-        self.assertEqual(7, selcted_rows.rows()[2])
+        self.assertEqual(0, selected_rows.rows()[0])
+        self.assertEqual(4, selected_rows.rows()[1])
+        self.assertEqual(7, selected_rows.rows()[2])
 
         # compare height
-        self.assertEqual(10, selcted_rows.height())
+        self.assertEqual(10, selected_rows.height())
 
         # compare tensor
         self.assertAlmostEqual(2.0,
-                               selcted_rows.get_tensor().get_float_element(0))
+                               selected_rows.get_tensor().get_float_element(0))
         self.assertAlmostEqual(1.0,
-                               selcted_rows.get_tensor().get_float_element(1))
+                               selected_rows.get_tensor().get_float_element(1))
         self.assertAlmostEqual(
-            4.0, selcted_rows.get_tensor().get_float_element(2 * row_numel + 8))
+            4.0,
+            selected_rows.get_tensor().get_float_element(2 * row_numel + 8))
 
 
 if __name__ == "__main__":
diff --git a/python/paddle/v2/framework/tests/test_sgd_op.py b/python/paddle/v2/framework/tests/test_sgd_op.py
index 2dd881e5e1..c7d6a3b345 100644
--- a/python/paddle/v2/framework/tests/test_sgd_op.py
+++ b/python/paddle/v2/framework/tests/test_sgd_op.py
@@ -1,5 +1,7 @@
 import unittest
 import numpy as np
+import paddle.v2.framework.core as core
+from paddle.v2.framework.op import Operator
 from op_test import OpTest
 
 
@@ -17,5 +19,63 @@ class TestSGDOp(OpTest):
         self.check_output()
 
 
+class TestSparseSGDOp(unittest.TestCase):
+    def test_sparse_sgd(self):
+        scope = core.Scope()
+
+        # create and initialize Grad Variable   
+        place = core.CPUPlace()
+        height = 10
+        rows = [0, 4, 7]
+        row_numel = 12
+
+        grad_selected_rows = scope.var('Grad').get_selected_rows()
+        grad_selected_rows.set_height(height)
+        grad_selected_rows.set_rows(rows)
+        np_array = np.ones((len(rows), row_numel)).astype("float32")
+        np_array[0, 0] = 2.0
+        np_array[2, 8] = 4.0
+        grad_tensor = grad_selected_rows.get_tensor()
+        grad_tensor.set(np_array, place)
+
+        # create and initialize Param Variable
+        param = scope.var('Param').get_tensor()
+        param_array = np.full((height, row_numel), 5.0).astype("float32")
+        param.set(param_array, place)
+
+        # create and initialize LeraningRate Variable
+        lr = scope.var('LearningRate').get_tensor()
+        lr_array = np.full((1), 2.0).astype("float32")
+        lr.set(lr_array, place)
+
+        # create and run sgd operator
+        sgd_op = Operator(
+            "sgd",
+            Param='Param',
+            Grad='Grad',
+            ParamOut='Param',
+            LearningRate='LearningRate')
+        ctx = core.DeviceContext.create(place)
+        sgd_op.run(scope, ctx)
+
+        # get and compare result
+        result_array = np.array(param)
+
+        # rows[0] = 0, 5.0 - 2.0 * 2.0
+        self.assertAlmostEqual(1.0, result_array[rows[0], 0])
+        # rows[0] = 0, 5.0 - 2.0 * 1.0
+        self.assertAlmostEqual(3.0, result_array[rows[0], 2])
+        # 5.0 - 2.0 * 0.0
+        self.assertAlmostEqual(5.0, result_array[1, 0])
+        # rows[1] = 4, 5.0 - 2.0 * 1.0
+        self.assertAlmostEqual(3.0, result_array[rows[1], 10])
+        # 5.0 - 2.0 * 0.0
+        self.assertAlmostEqual(5.0, result_array[5, 8])
+        # rows[2] = 7, 5.0 - 2.0 * 1.0
+        self.assertAlmostEqual(3.0, result_array[rows[2], 1])
+        # rows[2] = 7, 5.0 - 2.0 * 4.0
+        self.assertAlmostEqual(-3.0, result_array[rows[2], 8])
+
+
 if __name__ == "__main__":
     unittest.main()

From f9681459b2075e8067e6bda45a62967fc4baec62 Mon Sep 17 00:00:00 2001
From: qijun <qijun1994@hotmail.com>
Date: Tue, 17 Oct 2017 16:33:52 -0700
Subject: [PATCH 14/29] fix gpu build error

---
 paddle/operators/sgd_op.cc                      |  2 +-
 paddle/operators/sgd_op.cu                      |  6 +++---
 paddle/operators/sgd_op.h                       |  2 +-
 paddle/pybind/pybind.cc                         | 10 +++++++++-
 python/paddle/v2/framework/tests/test_sgd_op.py | 11 +++++++++--
 5 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/paddle/operators/sgd_op.cc b/paddle/operators/sgd_op.cc
index e26a1c7893..2acb96d1b4 100644
--- a/paddle/operators/sgd_op.cc
+++ b/paddle/operators/sgd_op.cc
@@ -61,7 +61,7 @@ param_out = param - learning_rate * grad;
 
 template <typename T>
 struct SparseSGDFunctor<platform::CPUPlace, T> {
-  void operator()(const platform::DeviceContext& ctx,
+  void operator()(const platform::DeviceContext& context,
                   const framework::SelectedRows& input,
                   const framework::Tensor& learning_rate,
                   framework::Tensor* output) {
diff --git a/paddle/operators/sgd_op.cu b/paddle/operators/sgd_op.cu
index 5c28314141..106f9b746b 100644
--- a/paddle/operators/sgd_op.cu
+++ b/paddle/operators/sgd_op.cu
@@ -34,15 +34,15 @@ __global__ void SparseSGDFunctorKernel(const T* selected_rows,
   for (int index = tid; index < row_numel; index += block_size) {
     // Since index in rows of SelectedRows can be duplicate, we have to use
     // Atomic Operation to avoid concurrent write error.
-    paddle::platform::CudaAtomicSub(tensor_out + index,
-                                    learning_rate[0] * selected_rows[index]);
+    paddle::platform::CudaAtomicAdd(
+        tensor_out + index, -1.0 * learning_rate[0] * selected_rows[index]);
   }
 }
 }  // namespace
 
 template <typename T>
 struct SparseSGDFunctor<platform::GPUPlace, T> {
-  void operator()(const platform::DeviceContext& ctx,
+  void operator()(const platform::DeviceContext& context,
                   const framework::SelectedRows& input,
                   const framework::Tensor& learning_rate,
                   framework::Tensor* output) {
diff --git a/paddle/operators/sgd_op.h b/paddle/operators/sgd_op.h
index 8c28d5e66b..78b595fc6c 100644
--- a/paddle/operators/sgd_op.h
+++ b/paddle/operators/sgd_op.h
@@ -22,7 +22,7 @@ namespace operators {
 
 template <typename Place, typename T>
 struct SparseSGDFunctor {
-  void operator()(const platform::DeviceContext& ctx,
+  void operator()(const platform::DeviceContext& context,
                   const framework::SelectedRows& input,
                   const framework::Tensor& learning_rate,
                   framework::Tensor* output);
diff --git a/paddle/pybind/pybind.cc b/paddle/pybind/pybind.cc
index 65e265b614..80854fb0c5 100644
--- a/paddle/pybind/pybind.cc
+++ b/paddle/pybind/pybind.cc
@@ -153,7 +153,15 @@ PYBIND11_PLUGIN(core) {
            py::return_value_policy::reference)
       .def("set_height", &SelectedRows::set_height)
       .def("height", &SelectedRows::height)
-      .def("set_rows", &SelectedRows::set_rows)
+      .def("set_rows",
+           [](SelectedRows &self, std::vector<int64_t> rows) {
+#ifndef PADDLE_WITH_CUDA
+             self.set_rows(rows);
+#else
+        Vector<int64_t> new_rows(rows);
+        self.set_rows(new_rows);
+#endif
+           })
       .def("rows", [](SelectedRows &self) {
 #ifndef PADDLE_WITH_CUDA
         return self.rows();
diff --git a/python/paddle/v2/framework/tests/test_sgd_op.py b/python/paddle/v2/framework/tests/test_sgd_op.py
index c7d6a3b345..01262bba4d 100644
--- a/python/paddle/v2/framework/tests/test_sgd_op.py
+++ b/python/paddle/v2/framework/tests/test_sgd_op.py
@@ -20,11 +20,10 @@ class TestSGDOp(OpTest):
 
 
 class TestSparseSGDOp(unittest.TestCase):
-    def test_sparse_sgd(self):
+    def check_with_place(self, place):
         scope = core.Scope()
 
         # create and initialize Grad Variable   
-        place = core.CPUPlace()
         height = 10
         rows = [0, 4, 7]
         row_numel = 12
@@ -35,6 +34,7 @@ class TestSparseSGDOp(unittest.TestCase):
         np_array = np.ones((len(rows), row_numel)).astype("float32")
         np_array[0, 0] = 2.0
         np_array[2, 8] = 4.0
+
         grad_tensor = grad_selected_rows.get_tensor()
         grad_tensor.set(np_array, place)
 
@@ -76,6 +76,13 @@ class TestSparseSGDOp(unittest.TestCase):
         # rows[2] = 7, 5.0 - 2.0 * 4.0
         self.assertAlmostEqual(-3.0, result_array[rows[2], 8])
 
+    def test_sparse_sgd(self):
+        places = [core.CPUPlace()]
+        if core.is_compile_gpu():
+            places.append(core.GPUPlace(0))
+        for place in places:
+            self.check_with_place(place)
+
 
 if __name__ == "__main__":
     unittest.main()

From efd009a063d089922098a1c766686fd1c3667043 Mon Sep 17 00:00:00 2001
From: fengjiayi <fengjiayi@baidu.com>
Date: Wed, 18 Oct 2017 12:37:44 -0700
Subject: [PATCH 15/29] implementation of simple conv2d layer (#4868)

* Implement FC layer with helper

* Update LayerHelper

* Add debug string for Python ProtoBuf

and Rename `Sync` to `Flush`

* Add check of ProtoBuf initialization

* Layer wrapper for FC

* Fix unittest

* Fix CI

* Add code generator

* AttributeChecker Better error log and speicalize bool

Since lots of types can be cast to bool

* Complete mlp, fit_a_line

* Implementation of simple conv_2d layer

* Fix bugs

* Remove debug code
---
 python/paddle/v2/framework/framework.py       |  2 +-
 python/paddle/v2/framework/layer_helper.py    | 18 ++++---
 python/paddle/v2/framework/layers.py          | 48 ++++++++++++++++++-
 .../paddle/v2/framework/tests/test_layers.py  | 12 ++++-
 4 files changed, 67 insertions(+), 13 deletions(-)

diff --git a/python/paddle/v2/framework/framework.py b/python/paddle/v2/framework/framework.py
index 3fb6efe42a..e16bc72447 100644
--- a/python/paddle/v2/framework/framework.py
+++ b/python/paddle/v2/framework/framework.py
@@ -232,7 +232,7 @@ class Operator(object):
         if attrs is not None:
             for attr in proto.attrs:
                 attr_name = attr.name
-                if not attr_name in attrs:
+                if (not attr_name in attrs) or (attrs[attr_name] is None):
                     continue
                 if not isinstance(attrs[attr_name], Block):
                     self.desc.set_attr(attr_name, attrs[attr_name])
diff --git a/python/paddle/v2/framework/layer_helper.py b/python/paddle/v2/framework/layer_helper.py
index 26d3e04310..6615bdcd3b 100644
--- a/python/paddle/v2/framework/layer_helper.py
+++ b/python/paddle/v2/framework/layer_helper.py
@@ -66,15 +66,15 @@ class LayerHelper(object):
         actual = self.kwargs.get('param_attr', None)
         return actual if actual is not None else default
 
-    def bias_attr(self, size, dtype):
-        bias_attr = self.kwargs.get('bias_attr', False)
-        if bias_attr is None or bias_attr:
+    def bias_attr(self, shape, dtype):
+        bias_attr = self.kwargs.get('bias_attr', None)
+        if bias_attr is True:
             bias_attr = {
                 'name': None,
                 'init_attr': {
                     'type': 'fill_constant',
                     'value': 0.0,
-                    'shape': [size],
+                    'shape': shape,
                     'dataType': dtype
                 }
             }
@@ -127,15 +127,13 @@ class LayerHelper(object):
         return self.program.global_block().create_var(*args, **kwargs)
 
     def append_bias_op(self, input_var):
-        bias_attr = self.bias_attr(
-            self.kwargs['size'], dtype=input_var.data_type)
+        size = list(input_var.shape[1:])
+        bias_attr = self.bias_attr(size, dtype=input_var.data_type)
         if not bias_attr:
             return input_var
+
         b = self.create_parameter(
-            attr=bias_attr,
-            shape=[self.kwargs['size']],
-            dtype=input_var.data_type,
-            suffix='b')
+            attr=bias_attr, shape=size, dtype=input_var.data_type, suffix='b')
         tmp = self.create_tmp_variable(dtype=input_var.data_type)
         self.append_op(
             type='elementwise_add',
diff --git a/python/paddle/v2/framework/layers.py b/python/paddle/v2/framework/layers.py
index 44b587b116..1821da197e 100644
--- a/python/paddle/v2/framework/layers.py
+++ b/python/paddle/v2/framework/layers.py
@@ -3,7 +3,7 @@ import paddle.v2.framework.core as core
 from paddle.v2.framework.framework import OpProtoHolder, Variable
 import re
 
-__all__ = ['fc_layer', 'data_layer', 'cross_entropy']
+__all__ = ['fc_layer', 'data_layer', 'cross_entropy', 'conv2d_layer']
 
 
 def fc_layer(input,
@@ -24,6 +24,7 @@ def fc_layer(input,
     for input_var, param_attr in helper.iter_inputs_and_params():
         input_shape = input_var.shape
         param_shape = list(input_shape[num_flatten_dims:]) + [size]
+
         w = helper.create_parameter(
             attr=param_attr, shape=param_shape, dtype=dtype)
         tmp = helper.create_tmp_variable(dtype)
@@ -111,6 +112,7 @@ def _create_op_func_(op_type):
 
 
 _create_op_func_('mean')
+_create_op_func_('pool2d')
 
 
 def cross_entropy(input, label, **kwargs):
@@ -141,3 +143,47 @@ def square_error_cost(input, label, **kwargs):
         outputs={'Y': [square_out]},
         attrs={'factor': 2.0})
     return square_out
+
+
+def conv2d_layer(input,
+                 num_filters,
+                 name=None,
+                 filter_size=[1, 1],
+                 act=None,
+                 groups=None,
+                 stride=[1, 1],
+                 padding=None,
+                 bias_attr=None,
+                 param_attr=None,
+                 program=None):
+    helper = LayerHelper('conv2d', **locals())
+    dtype = helper.input_dtype()
+
+    num_channels = input.shape[1]
+    if groups is None:
+        num_filter_channels = num_channels
+    else:
+        if num_channels % groups is not 0:
+            raise ValueError("num_channels must be divisible by groups.")
+        num_filter_channels = num_channels / groups
+
+    input_shape = input.shape
+    filter_shape = [num_filters, num_filter_channels] + filter_size
+    filter = helper.create_parameter(
+        attr=helper.param_attr, shape=filter_shape, dtype=dtype)
+    pre_bias = helper.create_tmp_variable(dtype)
+
+    helper.append_op(
+        type='conv2d',
+        inputs={
+            'Input': input,
+            'Filter': filter,
+        },
+        outputs={"Output": pre_bias},
+        attrs={'strides': stride,
+               'paddings': padding,
+               'groups': groups})
+
+    pre_act = helper.append_bias_op(pre_bias)
+
+    return helper.append_activation(pre_act)
diff --git a/python/paddle/v2/framework/tests/test_layers.py b/python/paddle/v2/framework/tests/test_layers.py
index 1ef2591cca..ce20371cfb 100644
--- a/python/paddle/v2/framework/tests/test_layers.py
+++ b/python/paddle/v2/framework/tests/test_layers.py
@@ -1,4 +1,4 @@
-from paddle.v2.framework.layers import fc_layer, data_layer, cross_entropy, mean, square_error_cost
+from paddle.v2.framework.layers import fc_layer, data_layer, cross_entropy, mean, square_error_cost, conv2d_layer
 from paddle.v2.framework.framework import Program, g_program
 import paddle.v2.framework.core as core
 import unittest
@@ -38,6 +38,16 @@ class TestBook(unittest.TestCase):
         self.assertIsNotNone(avg_cost)
         print str(program)
 
+    def test_simple_conv2d(self):
+        pd = core.ProgramDesc.__create_program_desc__()
+        program = Program(desc=pd)
+        images = data_layer(
+            name='pixel', shape=[3, 48, 48], data_type='int32', program=program)
+        conv2d_layer(
+            input=images, num_filters=3, filter_size=[4, 4], program=program)
+
+        print str(program)
+
 
 if __name__ == '__main__':
     unittest.main()

From e747623e8639ee43a8dd2b33d04f6110a1182de3 Mon Sep 17 00:00:00 2001
From: Yu Yang <yuyang18@baidu.com>
Date: Wed, 18 Oct 2017 13:14:41 -0700
Subject: [PATCH 16/29] Change ProgramDesc not a global variable (#4879)

* Change ProgramDesc not a global variable

* Polish code style

* Correct implement BlockDesc destructor

* Unify program as parameter name
---
 paddle/framework/attribute.cc                 | 18 +++-------
 paddle/framework/attribute.h                  |  5 +--
 paddle/framework/backward_test.cc             | 31 ++++-------------
 paddle/framework/executor.cc                  |  3 +-
 paddle/framework/op_registry.cc               |  5 +--
 paddle/framework/op_registry.h                |  3 +-
 paddle/framework/op_registry_test.cc          | 12 +++----
 paddle/framework/operator_test.cc             |  6 ++--
 paddle/framework/program_desc.cc              | 33 +++++--------------
 paddle/framework/program_desc.h               |  7 ++--
 paddle/framework/var_type_inference_test.cc   |  4 +--
 paddle/operators/dynamic_recurrent_op_test.cc |  2 +-
 paddle/pybind/protobuf.cc                     | 16 +--------
 paddle/pybind/pybind.cc                       |  9 ++---
 python/paddle/v2/framework/framework.py       |  6 ++--
 .../v2/framework/tests/test_infer_shape.py    |  4 +--
 .../paddle/v2/framework/tests/test_layers.py  |  6 ++--
 .../v2/framework/tests/test_protobuf_descs.py | 18 +++++-----
 18 files changed, 62 insertions(+), 126 deletions(-)

diff --git a/paddle/framework/attribute.cc b/paddle/framework/attribute.cc
index d6a2975aaa..29fe352ca4 100644
--- a/paddle/framework/attribute.cc
+++ b/paddle/framework/attribute.cc
@@ -19,19 +19,7 @@ limitations under the License. */
 namespace paddle {
 namespace framework {
 
-static ProgramDesc* g_program_desc = nullptr;
-
-ProgramDesc& GetProgramDesc() {
-  if (g_program_desc == nullptr) {
-    g_program_desc = new ProgramDesc();
-    auto root_block = g_program_desc->mutable_blocks()->Add();
-    root_block->set_idx(0);
-    root_block->set_parent_idx(-1);
-  }
-  return *g_program_desc;
-}
-
-Attribute GetAttrValue(const OpDesc::Attr& attr_desc) {
+Attribute GetAttrValue(const OpDesc::Attr& attr_desc, ProgramDesc* program) {
   switch (attr_desc.type()) {
     case framework::AttrType::BOOLEAN: {
       return attr_desc.b();
@@ -74,7 +62,9 @@ Attribute GetAttrValue(const OpDesc::Attr& attr_desc) {
       return val;
     }
     case framework::AttrType::BLOCK: {
-      return GetProgramDesc().mutable_blocks(attr_desc.block_idx());
+      PADDLE_ENFORCE(program != nullptr,
+                     "Need to specify ProgramDesc when get a block attr");
+      return program->mutable_blocks(attr_desc.block_idx());
     }
   }
   PADDLE_ENFORCE(false, "Unknown OpDesc::AttrDesc::type !");
diff --git a/paddle/framework/attribute.h b/paddle/framework/attribute.h
index 8a7a949346..9744662b8f 100644
--- a/paddle/framework/attribute.h
+++ b/paddle/framework/attribute.h
@@ -26,16 +26,13 @@ limitations under the License. */
 
 namespace paddle {
 namespace framework {
-
-ProgramDesc& GetProgramDesc();
-
 template <typename T>
 inline AttrType AttrTypeID() {
   Attribute tmp = T();
   return static_cast<AttrType>(tmp.which() - 1);
 }
 
-Attribute GetAttrValue(const OpDesc::Attr& attr_desc);
+Attribute GetAttrValue(const OpDesc::Attr& attr_desc, ProgramDesc* desc);
 
 class AttrReader {
  public:
diff --git a/paddle/framework/backward_test.cc b/paddle/framework/backward_test.cc
index 0c35a157bc..10301f7e39 100644
--- a/paddle/framework/backward_test.cc
+++ b/paddle/framework/backward_test.cc
@@ -495,19 +495,8 @@ TEST(Backward, linear_net_intermediate_variable_has_no_grad) {
   EXPECT_EQ(bwd_net->ops_[2]->Outputs(all).size(), 0UL);
 }
 
-// =================================== //
-
-f::ProgramDesc *GetNewProgramDesc() {
-  auto *program_desc = new f::ProgramDesc();
-  auto *root_block = program_desc->add_blocks();
-  root_block->set_idx(0);
-  root_block->set_parent_idx(-1);
-  return program_desc;
-}
-
 TEST(Backward, simple_single_op) {
-  f::ProgramDesc *program_desc = GetNewProgramDesc();
-  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::ProgramDescBind program;
   f::BlockDescBind *block = program.Block(0);
 
   f::OpDescBind *op = block->AppendOp();
@@ -543,8 +532,7 @@ TEST(Backward, simple_single_op) {
 }
 
 TEST(Backward, default_attribute) {
-  f::ProgramDesc *program_desc = GetNewProgramDesc();
-  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::ProgramDescBind program;
   f::BlockDescBind *block = program.Block(0);
   f::OpDescBind *op = block->AppendOp();
   op->SetType("mul");
@@ -570,8 +558,7 @@ TEST(Backward, default_attribute) {
 }
 
 TEST(Backward, simple_mult_op) {
-  f::ProgramDesc *program_desc = GetNewProgramDesc();
-  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::ProgramDescBind program;
   f::BlockDescBind *block = program.Block(0);
   f::OpDescBind *op1 = block->AppendOp();
   op1->SetType("rowwise_add");
@@ -654,8 +641,7 @@ TEST(Backward, simple_mult_op) {
 }
 
 TEST(Backward, intermedia_var_no_grad) {
-  f::ProgramDesc *program_desc = GetNewProgramDesc();
-  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::ProgramDescBind program;
   f::BlockDescBind *block = program.Block(0);
   f::OpDescBind *op1 = block->AppendOp();
   op1->SetType("rowwise_add");
@@ -725,8 +711,7 @@ TEST(Backward, intermedia_var_no_grad) {
 }
 
 TEST(Backward, var_no_grad) {
-  f::ProgramDesc *program_desc = GetNewProgramDesc();
-  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::ProgramDescBind program;
   f::BlockDescBind *block = program.Block(0);
   f::OpDescBind *op1 = block->AppendOp();
   op1->SetType("mult_in_out");
@@ -802,8 +787,7 @@ TEST(Backward, var_no_grad) {
 }
 
 TEST(Backward, shared_var) {
-  f::ProgramDesc *program_desc = GetNewProgramDesc();
-  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::ProgramDescBind program;
   f::BlockDescBind *block = program.Block(0);
   f::OpDescBind *op1 = block->AppendOp();
   op1->SetType("rowwise_add");
@@ -893,8 +877,7 @@ TEST(Backward, shared_var) {
 }
 
 TEST(Backward, half_backward) {
-  f::ProgramDesc *program_desc = GetNewProgramDesc();
-  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::ProgramDescBind program;
   f::BlockDescBind *block = program.Block(0);
   auto *op1 = block->AppendOp();
   op1->SetType("minus");
diff --git a/paddle/framework/executor.cc b/paddle/framework/executor.cc
index b3b85b5865..00caa6e1d5 100644
--- a/paddle/framework/executor.cc
+++ b/paddle/framework/executor.cc
@@ -75,7 +75,8 @@ void Executor::Run(const ProgramDesc& pdesc, Scope* scope, int block_id) {
   }
 
   for (auto& op_desc : block.ops()) {
-    auto op = paddle::framework::OpRegistry::CreateOp(op_desc);
+    auto op = paddle::framework::OpRegistry::CreateOp(
+        op_desc, const_cast<ProgramDesc*>(&pdesc));
     op->Run(local_scope, *device);
   }
 
diff --git a/paddle/framework/op_registry.cc b/paddle/framework/op_registry.cc
index 504afbd5db..c2f2438edf 100644
--- a/paddle/framework/op_registry.cc
+++ b/paddle/framework/op_registry.cc
@@ -43,12 +43,13 @@ static VariableNameMap ConvertOpDescVarsToVarNameMap(
   return ret_val;
 }
 
-std::unique_ptr<OperatorBase> OpRegistry::CreateOp(const OpDesc& op_desc) {
+std::unique_ptr<OperatorBase> OpRegistry::CreateOp(const OpDesc& op_desc,
+                                                   ProgramDesc* program) {
   VariableNameMap inputs = ConvertOpDescVarsToVarNameMap(op_desc.inputs());
   VariableNameMap outputs = ConvertOpDescVarsToVarNameMap(op_desc.outputs());
   AttributeMap attrs;
   for (auto& attr : op_desc.attrs()) {
-    attrs[attr.name()] = GetAttrValue(attr);
+    attrs[attr.name()] = GetAttrValue(attr, program);
   }
 
   return CreateOp(op_desc.type(), inputs, outputs, attrs);
diff --git a/paddle/framework/op_registry.h b/paddle/framework/op_registry.h
index dfca46b789..d25b4abccb 100644
--- a/paddle/framework/op_registry.h
+++ b/paddle/framework/op_registry.h
@@ -74,7 +74,8 @@ class OpRegistry {
                                                 const VariableNameMap& outputs,
                                                 AttributeMap attrs);
 
-  static std::unique_ptr<OperatorBase> CreateOp(const OpDesc& op_desc);
+  static std::unique_ptr<OperatorBase> CreateOp(const OpDesc& op_desc,
+                                                ProgramDesc* program);
 
   static std::unique_ptr<OperatorBase> CreateOp(const OpDescBind& op_desc);
 };
diff --git a/paddle/framework/op_registry_test.cc b/paddle/framework/op_registry_test.cc
index b860fe6cac..6289125d7c 100644
--- a/paddle/framework/op_registry_test.cc
+++ b/paddle/framework/op_registry_test.cc
@@ -74,7 +74,7 @@ TEST(OpRegistry, CreateOp) {
   attr->set_type(paddle::framework::AttrType::FLOAT);
   attr->set_f(scale);
 
-  auto op = paddle::framework::OpRegistry::CreateOp(op_desc);
+  auto op = paddle::framework::OpRegistry::CreateOp(op_desc, nullptr);
   paddle::framework::Scope scope;
   paddle::platform::CPUDeviceContext dev_ctx;
   op->Run(scope, dev_ctx);
@@ -95,7 +95,7 @@ TEST(OpRegistry, IllegalAttr) {
 
   bool caught = false;
   try {
-    paddle::framework::OpRegistry::CreateOp(op_desc);
+    paddle::framework::OpRegistry::CreateOp(op_desc, nullptr);
   } catch (paddle::platform::EnforceNotMet err) {
     caught = true;
     std::string msg = "larger_than check fail";
@@ -115,7 +115,7 @@ TEST(OpRegistry, DefaultValue) {
 
   ASSERT_TRUE(op_desc.IsInitialized());
 
-  auto op = paddle::framework::OpRegistry::CreateOp(op_desc);
+  auto op = paddle::framework::OpRegistry::CreateOp(op_desc, nullptr);
   paddle::framework::Scope scope;
   paddle::platform::CPUDeviceContext dev_ctx;
   op->Run(scope, dev_ctx);
@@ -131,7 +131,7 @@ TEST(OpRegistry, CustomChecker) {
   // attr 'test_attr' is not set
   bool caught = false;
   try {
-    paddle::framework::OpRegistry::CreateOp(op_desc);
+    paddle::framework::OpRegistry::CreateOp(op_desc, nullptr);
   } catch (paddle::platform::EnforceNotMet err) {
     caught = true;
     std::string msg = "Attribute 'test_attr' is required!";
@@ -149,7 +149,7 @@ TEST(OpRegistry, CustomChecker) {
   attr->set_i(3);
   caught = false;
   try {
-    paddle::framework::OpRegistry::CreateOp(op_desc);
+    paddle::framework::OpRegistry::CreateOp(op_desc, nullptr);
   } catch (paddle::platform::EnforceNotMet err) {
     caught = true;
     std::string msg = "'test_attr' must be even!";
@@ -166,7 +166,7 @@ TEST(OpRegistry, CustomChecker) {
   attr->set_name("test_attr");
   attr->set_type(paddle::framework::AttrType::INT);
   attr->set_i(4);
-  auto op = paddle::framework::OpRegistry::CreateOp(op_desc);
+  auto op = paddle::framework::OpRegistry::CreateOp(op_desc, nullptr);
   paddle::platform::CPUDeviceContext dev_ctx;
   paddle::framework::Scope scope;
   op->Run(scope, dev_ctx);
diff --git a/paddle/framework/operator_test.cc b/paddle/framework/operator_test.cc
index d7890ac8d0..c358f1a2b6 100644
--- a/paddle/framework/operator_test.cc
+++ b/paddle/framework/operator_test.cc
@@ -83,7 +83,7 @@ TEST(OperatorBase, all) {
   paddle::platform::CPUDeviceContext device_context;
   paddle::framework::Scope scope;
 
-  auto op = paddle::framework::OpRegistry::CreateOp(op_desc);
+  auto op = paddle::framework::OpRegistry::CreateOp(op_desc, nullptr);
   scope.Var("OUT1");
   ASSERT_EQ(paddle::framework::op_run_num, 0);
   op->Run(scope, device_context);
@@ -208,7 +208,7 @@ TEST(OpKernel, all) {
   paddle::platform::CPUDeviceContext cpu_device_context;
   paddle::framework::Scope scope;
 
-  auto op = paddle::framework::OpRegistry::CreateOp(op_desc);
+  auto op = paddle::framework::OpRegistry::CreateOp(op_desc, nullptr);
   ASSERT_EQ(paddle::framework::cpu_kernel_run_num, 0);
   op->Run(scope, cpu_device_context);
   ASSERT_EQ(paddle::framework::cpu_kernel_run_num, 1);
@@ -244,7 +244,7 @@ TEST(OpKernel, multi_inputs) {
   scope.Var("y0")->GetMutable<Tensor>();
   scope.Var("y1")->GetMutable<Tensor>();
 
-  auto op = paddle::framework::OpRegistry::CreateOp(op_desc);
+  auto op = paddle::framework::OpRegistry::CreateOp(op_desc, nullptr);
   op->Run(scope, cpu_device_context);
 }
 
diff --git a/paddle/framework/program_desc.cc b/paddle/framework/program_desc.cc
index fcb7292884..df846f115a 100644
--- a/paddle/framework/program_desc.cc
+++ b/paddle/framework/program_desc.cc
@@ -18,27 +18,10 @@ limitations under the License. */
 namespace paddle {
 namespace framework {
 
-using ProgDescMap =
-    std::unordered_map<ProgramDesc *, std::unique_ptr<ProgramDescBind>>;
-static ProgDescMap *g_bind_map = nullptr;
-
-ProgramDescBind &ProgramDescBind::Instance(ProgramDesc *prog) {
-  if (g_bind_map == nullptr) {
-    g_bind_map = new ProgDescMap();
-  }
-  auto &map = *g_bind_map;
-  auto &ptr = map[prog];
-
-  if (ptr == nullptr) {
-    ptr.reset(new ProgramDescBind(prog));
-  }
-  return *ptr;
-}
-
 BlockDescBind *ProgramDescBind::AppendBlock(const BlockDescBind &parent) {
-  auto *b = prog_->add_blocks();
+  auto *b = prog_.add_blocks();
   b->set_parent_idx(parent.ID());
-  b->set_idx(prog_->blocks_size() - 1);
+  b->set_idx(prog_.blocks_size() - 1);
   blocks_.emplace_back(new BlockDescBind(this, b));
   return blocks_.back().get();
 }
@@ -47,14 +30,14 @@ ProgramDesc *ProgramDescBind::Proto() {
   for (auto &block : blocks_) {
     block->Flush();
   }
-  return prog_;
+  return &prog_;
 }
 
-ProgramDescBind::ProgramDescBind(ProgramDesc *prog) {
-  prog_ = prog;
-  for (auto &block : *prog->mutable_blocks()) {
-    blocks_.emplace_back(new BlockDescBind(this, &block));
-  }
+ProgramDescBind::ProgramDescBind() {
+  auto *block = prog_.mutable_blocks()->Add();
+  block->set_idx(0);
+  block->set_parent_idx(-1);
+  blocks_.emplace_back(new BlockDescBind(this, block));
 }
 }  // namespace framework
 }  // namespace paddle
diff --git a/paddle/framework/program_desc.h b/paddle/framework/program_desc.h
index f29b1c54e7..514b62654d 100644
--- a/paddle/framework/program_desc.h
+++ b/paddle/framework/program_desc.h
@@ -26,7 +26,7 @@ class BlockDescBind;
 
 class ProgramDescBind {
  public:
-  static ProgramDescBind &Instance(ProgramDesc *prog);
+  ProgramDescBind();
 
   BlockDescBind *AppendBlock(const BlockDescBind &parent);
 
@@ -37,10 +37,7 @@ class ProgramDescBind {
   ProgramDesc *Proto();
 
  private:
-  explicit ProgramDescBind(ProgramDesc *prog);
-
-  // Not owned
-  ProgramDesc *prog_;
+  ProgramDesc prog_;
 
   std::vector<std::unique_ptr<BlockDescBind>> blocks_;
 
diff --git a/paddle/framework/var_type_inference_test.cc b/paddle/framework/var_type_inference_test.cc
index 87399208e9..918de1fd05 100644
--- a/paddle/framework/var_type_inference_test.cc
+++ b/paddle/framework/var_type_inference_test.cc
@@ -62,7 +62,7 @@ namespace paddle {
 namespace framework {
 
 TEST(InferVarType, sum_op) {
-  auto &prog = ProgramDescBind::Instance(&GetProgramDesc());
+  ProgramDescBind prog;
   auto *op = prog.Block(0)->AppendOp();
   op->SetType("sum");
   op->SetInput("X", {"test_a", "test_b", "test_c"});
@@ -83,7 +83,7 @@ TEST(InferVarType, sum_op) {
 }
 
 TEST(InferVarType, sum_op_without_infer_var_type) {
-  auto &prog = ProgramDescBind::Instance(&GetProgramDesc());
+  ProgramDescBind prog;
   auto *op = prog.Block(0)->AppendOp();
   op->SetType("sum_without_infer_var_type");
   op->SetInput("X", {"test2_a", "test2_b", "test2_c"});
diff --git a/paddle/operators/dynamic_recurrent_op_test.cc b/paddle/operators/dynamic_recurrent_op_test.cc
index 83a5ba36d9..36f405568d 100644
--- a/paddle/operators/dynamic_recurrent_op_test.cc
+++ b/paddle/operators/dynamic_recurrent_op_test.cc
@@ -51,7 +51,7 @@ class DynamicRecurrentOpTestHelper : public ::testing::Test {
     CreateGlobalVariables();
 
     auto op_desc = CreateOpDesc();
-    op = paddle::framework::OpRegistry::CreateOp(op_desc);
+    op = paddle::framework::OpRegistry::CreateOp(op_desc, nullptr);
     dop = dynamic_cast<DynamicRecurrentOp*>(op.get());
     InitCacheManually();
     InitStepNet();
diff --git a/paddle/pybind/protobuf.cc b/paddle/pybind/protobuf.cc
index 82aae72ba9..fbdd673295 100644
--- a/paddle/pybind/protobuf.cc
+++ b/paddle/pybind/protobuf.cc
@@ -100,21 +100,7 @@ using namespace paddle::framework;  // NOLINT
 // Bind Methods
 void BindProgramDesc(py::module &m) {
   py::class_<ProgramDescBind>(m, "ProgramDesc", "")
-      .def_static("instance",
-                  []() -> ProgramDescBind * {
-                    return &ProgramDescBind::Instance(&GetProgramDesc());
-                  },
-                  py::return_value_policy::reference)
-      .def_static("__create_program_desc__",
-                  []() -> ProgramDescBind * {
-                    // Only used for unit-test
-                    auto *prog_desc = new ProgramDesc;
-                    auto *block = prog_desc->mutable_blocks()->Add();
-                    block->set_idx(0);
-                    block->set_parent_idx(-1);
-                    return &ProgramDescBind::Instance(prog_desc);
-                  },
-                  py::return_value_policy::reference)
+      .def(py::init<>())
       .def("append_block", &ProgramDescBind::AppendBlock,
            py::return_value_policy::reference)
       .def("append_backward",
diff --git a/paddle/pybind/pybind.cc b/paddle/pybind/pybind.cc
index fcae92ad99..9eb1bf4a16 100644
--- a/paddle/pybind/pybind.cc
+++ b/paddle/pybind/pybind.cc
@@ -17,6 +17,7 @@ limitations under the License. */
 #include "paddle/framework/backward.h"
 #include "paddle/framework/executor.h"
 #include "paddle/framework/feed_fetch_method.h"
+#include "paddle/framework/framework.pb.h"
 #include "paddle/framework/lod_tensor.h"
 #include "paddle/framework/selected_rows.h"
 #include "paddle/framework/tensor_array.h"
@@ -259,7 +260,7 @@ All parameter, weight, gradient are variables in Paddle.
                     PADDLE_ENFORCE(desc.IsInitialized(),
                                    "User OpDesc is not initialized, reason %s",
                                    desc.InitializationErrorString());
-                    return OpRegistry::CreateOp(desc);
+                    return OpRegistry::CreateOp(desc, nullptr);
                   })
       .def("backward",
            [](const OperatorBase &forwardOp,
@@ -363,7 +364,7 @@ All parameter, weight, gradient are variables in Paddle.
             PADDLE_ENFORCE(desc.IsInitialized(),
                            "User OpDesc is not initialized, reason %s",
                            desc.InitializationErrorString());
-            auto rnn_op = OpRegistry::CreateOp(desc);
+            auto rnn_op = OpRegistry::CreateOp(desc, nullptr);
             return static_cast<operators::RecurrentOp *>(rnn_op.release());
           })
       .def("set_stepnet", [](operators::RecurrentOp &self,
@@ -381,7 +382,7 @@ All parameter, weight, gradient are variables in Paddle.
                     PADDLE_ENFORCE(desc.IsInitialized(),
                                    "User OpDesc is not initialized, reason %s",
                                    desc.InitializationErrorString());
-                    auto rnn_op = OpRegistry::CreateOp(desc);
+                    auto rnn_op = OpRegistry::CreateOp(desc, nullptr);
                     return static_cast<operators::DynamicRecurrentOp *>(
                         rnn_op.release());
                   })
@@ -408,7 +409,7 @@ All parameter, weight, gradient are variables in Paddle.
                     PADDLE_ENFORCE(desc.IsInitialized(),
                                    "User OpDesc is not initialized, reason %s",
                                    desc.InitializationErrorString());
-                    auto cond_op = OpRegistry::CreateOp(desc);
+                    auto cond_op = OpRegistry::CreateOp(desc, nullptr);
                     return static_cast<operators::CondOp *>(cond_op.release());
                   })
       .def("set_truenet",
diff --git a/python/paddle/v2/framework/framework.py b/python/paddle/v2/framework/framework.py
index e16bc72447..93e2218eab 100644
--- a/python/paddle/v2/framework/framework.py
+++ b/python/paddle/v2/framework/framework.py
@@ -384,10 +384,8 @@ class Program(object):
             cls._instance = cls()
         return cls._instance
 
-    def __init__(self, desc=None):
-        if desc is None:
-            desc = core.ProgramDesc.instance()
-        self.desc = desc
+    def __init__(self):
+        self.desc = core.ProgramDesc()
         self.blocks = [Block(self, 0)]
         self.current_block_idx = 0
 
diff --git a/python/paddle/v2/framework/tests/test_infer_shape.py b/python/paddle/v2/framework/tests/test_infer_shape.py
index 19bb45acef..5cfb9e6687 100644
--- a/python/paddle/v2/framework/tests/test_infer_shape.py
+++ b/python/paddle/v2/framework/tests/test_infer_shape.py
@@ -5,7 +5,7 @@ import paddle.v2.framework.core as core
 
 class TestInferShape(unittest.TestCase):
     def test_sum_op(self):
-        prog = core.ProgramDesc.__create_program_desc__()
+        prog = core.ProgramDesc()
         self.assertIsNotNone(prog)
         block = prog.block(0)
         self.assertIsNotNone(block)
@@ -33,7 +33,7 @@ class TestInferShape(unittest.TestCase):
         self.assertEqual(out.shape(), shape)
 
     def test_mul_op(self):
-        prog = core.ProgramDesc.__create_program_desc__()
+        prog = core.ProgramDesc()
         self.assertIsNotNone(prog)
         block = prog.block(0)
         self.assertIsNotNone(block)
diff --git a/python/paddle/v2/framework/tests/test_layers.py b/python/paddle/v2/framework/tests/test_layers.py
index ce20371cfb..2ffadf7371 100644
--- a/python/paddle/v2/framework/tests/test_layers.py
+++ b/python/paddle/v2/framework/tests/test_layers.py
@@ -6,8 +6,7 @@ import unittest
 
 class TestBook(unittest.TestCase):
     def test_fit_a_line(self):
-        pd = core.ProgramDesc.__create_program_desc__()
-        program = Program(desc=pd)
+        program = Program()
         x = data_layer(
             name='x', shape=[13], data_type='float32', program=program)
         y_predict = fc_layer(input=x, size=1, act=None, program=program)
@@ -21,8 +20,7 @@ class TestBook(unittest.TestCase):
         print str(program)
 
     def test_recognize_digits_mlp(self):
-        pd = core.ProgramDesc.__create_program_desc__()
-        program = Program(desc=pd)
+        program = Program()
 
         # Change g_program, so the rest layers use `g_program`
         images = data_layer(
diff --git a/python/paddle/v2/framework/tests/test_protobuf_descs.py b/python/paddle/v2/framework/tests/test_protobuf_descs.py
index c775b1a398..6ed8edf91c 100644
--- a/python/paddle/v2/framework/tests/test_protobuf_descs.py
+++ b/python/paddle/v2/framework/tests/test_protobuf_descs.py
@@ -4,7 +4,7 @@ import paddle.v2.framework.core as core
 
 class TestOpDesc(unittest.TestCase):
     def test_op_desc(self):
-        prog = core.ProgramDesc.__create_program_desc__()
+        prog = core.ProgramDesc()
         self.assertIsNotNone(prog)
         block = prog.block(0)
         self.assertIsNotNone(block)
@@ -64,16 +64,16 @@ class TestOpDesc(unittest.TestCase):
 
 class TestProgramDesc(unittest.TestCase):
     def test_instance(self):
-        program_desc = core.ProgramDesc.__create_program_desc__()
+        program_desc = core.ProgramDesc()
         self.assertIsNotNone(program_desc)
         del program_desc
-        program_desc = core.ProgramDesc.instance()
+        program_desc = core.ProgramDesc()
         self.assertIsNotNone(program_desc)
         self.assertIsNotNone(program_desc.block(0))
         del program_desc
 
     def test_append_block(self):
-        prog_desc = core.ProgramDesc.__create_program_desc__()
+        prog_desc = core.ProgramDesc()
         self.assertIsNotNone(prog_desc)
         block_root = prog_desc.block(0)
         self.assertIsNotNone(block_root)
@@ -91,7 +91,7 @@ class TestProgramDesc(unittest.TestCase):
 
 class TestVarDesc(unittest.TestCase):
     def test_shape(self):
-        program_desc = core.ProgramDesc.__create_program_desc__()
+        program_desc = core.ProgramDesc()
         block = program_desc.block(0)
         var = block.var('my_var')
         var.set_type(core.VarDesc.VarType.SELECTED_ROWS)
@@ -102,7 +102,7 @@ class TestVarDesc(unittest.TestCase):
         self.assertEqual(core.VarDesc.VarType.SELECTED_ROWS, var.type())
 
     def test_data_type(self):
-        program_desc = core.ProgramDesc.__create_program_desc__()
+        program_desc = core.ProgramDesc()
         block = program_desc.block(0)
         var = block.var('my_var')
         var.set_type(core.VarDesc.VarType.LOD_TENSOR)
@@ -113,7 +113,7 @@ class TestVarDesc(unittest.TestCase):
 
 class TestBlockDesc(unittest.TestCase):
     def test_add_var(self):
-        prog = core.ProgramDesc.__create_program_desc__()
+        prog = core.ProgramDesc()
         self.assertIsNotNone(prog)
         block = prog.block(0)
         self.assertIsNotNone(block)
@@ -121,12 +121,12 @@ class TestBlockDesc(unittest.TestCase):
         var2 = block.var("var2")
         var3 = block.var("var3")
         all_vars = block.all_vars()
-        self.assertEqual(set(all_vars), set([var1, var2, var3]))
+        self.assertEqual(set(all_vars), {var1, var2, var3})
         var2_re = block.find_var("var2")
         self.assertEqual(var2_re, var2)
 
     def test_add_op(self):
-        prog = core.ProgramDesc.__create_program_desc__()
+        prog = core.ProgramDesc()
         self.assertIsNotNone(prog)
         block = prog.block(0)
         self.assertIsNotNone(block)

From f4a21e387ffb0a864b8bb9822716fe64aacddaee Mon Sep 17 00:00:00 2001
From: Abhinav Arora <abhinavarora28@gmail.com>
Date: Wed, 18 Oct 2017 14:06:30 -0700
Subject: [PATCH 17/29] Design Doc for Regularization (#4869)

* Add initail design doc for regularization

* Updating image links

* Commiting the images for the equations

* Adding computation graph images

* Adding section on computation graph
---
 doc/design/images/feed_forward.png            | Bin 0 -> 32247 bytes
 .../images/feed_forward_regularized.png       | Bin 0 -> 46036 bytes
 doc/design/images/l1_regularization.png       | Bin 0 -> 1157 bytes
 doc/design/images/l2_regularization.png       | Bin 0 -> 989 bytes
 doc/design/images/loss_equation.png           | Bin 0 -> 1589 bytes
 doc/design/regularization.md                  | 103 ++++++++++++++++++
 6 files changed, 103 insertions(+)
 create mode 100644 doc/design/images/feed_forward.png
 create mode 100644 doc/design/images/feed_forward_regularized.png
 create mode 100644 doc/design/images/l1_regularization.png
 create mode 100644 doc/design/images/l2_regularization.png
 create mode 100644 doc/design/images/loss_equation.png
 create mode 100644 doc/design/regularization.md

diff --git a/doc/design/images/feed_forward.png b/doc/design/images/feed_forward.png
new file mode 100644
index 0000000000000000000000000000000000000000..d312371a04c26aa6cd196e0bd1f51becb425180b
GIT binary patch
literal 32247
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

literal 0
HcmV?d00001

diff --git a/doc/design/images/feed_forward_regularized.png b/doc/design/images/feed_forward_regularized.png
new file mode 100644
index 0000000000000000000000000000000000000000..677e99bfd9f8e72ed9fe4b27127af2ced202f447
GIT binary patch
literal 46036
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

literal 0
HcmV?d00001

diff --git a/doc/design/images/l1_regularization.png b/doc/design/images/l1_regularization.png
new file mode 100644
index 0000000000000000000000000000000000000000..e1b9c7a44f94dc027598a98da93ddb8133190972
GIT binary patch
literal 1157
zcmeAS@N?(olHy`uVBq!ia0vp^JAqh(1xPSB@w`k2QY`6?zK#qG8~eHcB(ehe3dtTp
zz6=aiY77hwEes65fI<x~7#K<o7#Ln9FfdrnU|<k0n6oR;1}MRl<n8Xlz;9(_w;0Id
zEbxdd2GS{D%s=huT_A(K#M9T6{UMhij|@xnO|3sbO_iQ5jv*e$uU@mwzw98vUNBkQ
z-7}y`B4Ndqyt$PVXK2mhyTBXWap(q<kXEpg9Yfo~>J>L8=O=iFto34NS4sQC8zgol
zZL&q_W0k+f-{!`DR$|?;@O;v7%l{?+?iUxb6zBy1C_lK~h<&gAiZ4q}I=9=Ww|C$B
z(z)}O{!#0mxZ`X*r!O43Xw?<G=q6u@Ze99{{&3z054xKCuO2Nq!CDpa{KYgDo+F24
zj_qXqdgAl>D_hwvgcZnE<moK4PSp3i7%wFuw!!(#aR=5Ft3Cgk^nX-)^QuI)$m~kB
z(g&7v%JKH`YSZNtnB&x3@+Ur(ox3B|pjM;&oKc3k(yvzY2iDQyrWf3|9&>Qm{_3^8
zhsuuzp3b>BJ4`C;HZe`x{=39}X4vA`!`&H1&iM^4_8hGSGw)x`^IczF^Oskzq-f@g
zvX4(9mQ*Q~2Ujlb{TyPy!%Wck!lzlcWq&W*$CW<!6@Q|4#rs!blFffg{=S`*wm#r*
z#Ow>r88)?-|J0a9T$QQfnrF0kyVKW-cQ5QFZ_(%SKIZd`&t;Njbd;IBmqF;N^uXzJ
zl-^Cy=c;i3Z8URtX|(-agGE(3<;B)l-u7Ht{UT%I&ilJ&`-ZEWc+&S};)`WBW_TR)
zI(SBL)$uItOYgT`*yzDm?el+DP<ftI-1PU$V|HAddEs}8tGDsj57#I1*or4kTu}D7
z`f6_At&`>k3pdYNXnwWhT$b)S{?BioJpb$ZHDR?|+q6ek`!1gBe<%65)YoH=@UI--
z(}A&JkAB5Z?{V<IQh(vE>C?~8j6=l)#A9zPQvH14cg+9uCt|)<mTH!y|NV6C?)yr+
zs_xf!zVCRoJLaqDx~k6AdfGN$C67k_XRf{wt{R=UgAJH2RZCnWN>UO_QmvAUQh^kM
zk%6JPuAzahp?Qd*k(H5!m4S(_fvJ^&!QvgCPorqa%}>cptHiD0(o^qppavz74F$zk
z9+^R@#ZLL9c`2EB=}!3-42H(W6-JiYMnG(4XjEdnGaRVe9IDzUwJbG<!7(L2Db+1M
zuSC~S&%jE-H?btcCABy+Jx|x!L)R%kCq>sk#1QCO1w%bkL$378RboIRT%kq;7vz^X
z=jY@X=^8NL)`>+XxH2~>KL==Ri0?Tkpn--M1{$In7?he`nv+<h>snEgnpd2ep9j=@
UKlKVQmoqSUy85}Sb4q9e06^~6>i_@%

literal 0
HcmV?d00001

diff --git a/doc/design/images/l2_regularization.png b/doc/design/images/l2_regularization.png
new file mode 100644
index 0000000000000000000000000000000000000000..d5c2fcbc2ccae75ad083162e5a2dceb0210be298
GIT binary patch
literal 989
zcmeAS@N?(olHy`uVBq!ia0vp^RY0uG0wfs11@y9k6id3JuOkD)#(wTUiL5}rLb6AY
zFHoHt14Ba#1H&(%P{RubhEf9thF1v;3|2E37{m+a><Y92N-!mPySp&(TN&9c2J$!y
zJR*yMbP5>rPdj=S$Y3w=^mS!_$R)@l&6x7ZV+&9dzo(01h{y4_Q|<k4J4hVU=TvcM
z>)=zksHMv-tGIFs>q;;7T_puq7aBJ%baLVf@sTyCX+9wCvCnbMwna{IL7}haC>*@R
z8anY-o_M3Qxy84`Kl!Kjo;#^2_b~F@zTNZhecxLxFY72WF;TkewF=W((RnTl8Xwu#
zwr2##2Ay|bR_fGoW~ROJX{VW=zc%MxzL>e-@`sD{cmDj6zOy#7db7GRb1QF`{<fVC
zjpq#|=buX2^7Tsib~QtN_5L7(;G~k>Zx&D0x-jV@gGQj>Ev*9!uWR;bt}%Mnds%8~
z6~|h2jj~zKwA;5i8~=)*#;aYysGjatpL+ayc<x1o+-s-QGE2l|qc+}dc%ber$u5zc
zy7`#LhS>?~3k0Kkqi6n)eKYMz*j4Ld^>5V?yx)#z*shgRkDV32eO~6=Q`sLb>o4@a
zu{~3_`Q8)VU5`~h&cAoDOr5EOYr4_BsxMEIr$4*a8~1DBH$CYE#{(y>yL5v2uI8Ja
z-^GHq8>+puv~<w7mG&1=-IMlx#*ag%+}28kZFgK%)w65M^Nsl*f4$Nv&HHJP*Bt#k
zvBaLw_Gzj2g=BH_x4CCKO0y0mA6xSM<LjLYZ@)|I+kNmitJHxy@#NVOuQnRg{wc7z
z`$U(;#>~NMrg7!tjSC-bTld_s@rF_UrLQ*vB0rntcsAtOA9}H6YPQ<~_7<^<<DbrQ
zd^tHs>Y-?eQ=H?$UF<KVZf?o=edy))8enQsEpd$~Nl7e8wMs5Z1yT$~28QOkh6cKZ
z<{^egRz~Jl28Ox@rd9?94BhPyQ8eV{r(~v8;?_`j%{~^WK@ns_L9vxbW>9LeQ+{b)
zN@iZVQ+@@5g++z2p|+8!p|+W!;j^rZvw@1up^AM{%TjX~98>a>Qr+_NN^}kN46GC!
zi&D#i6Z497{gZMs3rkZKf>Lu*6N^(74D^f)6S<OB`GD+mg&GlDkYD1QpOastYrx=}
zSd!tATAZ1lr|ayY>y)39qU#@G2=t}`7MbA6+@$;*pk#>eIVYfj44$rjF6*2UngC+|
BgDC(2

literal 0
HcmV?d00001

diff --git a/doc/design/images/loss_equation.png b/doc/design/images/loss_equation.png
new file mode 100644
index 0000000000000000000000000000000000000000..14212ec8d36c803de96bde8a9a4b5591bd20434e
GIT binary patch
literal 1589
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
I86h<JFX?i?$p8QV

literal 0
HcmV?d00001

diff --git a/doc/design/regularization.md b/doc/design/regularization.md
new file mode 100644
index 0000000000..703a9fbdd4
--- /dev/null
+++ b/doc/design/regularization.md
@@ -0,0 +1,103 @@
+# Regularization in PaddlePaddle
+
+## Introduction to Regularization
+A central problem in machine learning is how to design an algorithm that will perform well not just on the training data, but also on new data. Many strategies are used by machine learning practitioners to reduce the test error, possibly at the expense of increased training error. These strategies are collectively known as **regularization**. 
+
+### Parameter Norm Penalties
+Most common regularization approaches in deep learning are based on limiting the capacity of the models by adding a parameter norm penalty to the objective function `J`. This is given as follows:
+
+<img src="./images/loss_equation.png" align="center"/><br/>
+
+The parameter `alpha` is a hyperparameter that weights the relative contribution of the norm penalty term, `omega`, relative to the standard objective function `J`.
+
+The most commonly used norm penalties are the L2 norm penalty and the L1 norm penalty. These are given as follows:
+
+##### L2 Regularization:
+<img src="./images/l2_regularization.png" align="center"/><br/>
+
+##### L1 Regularization
+<img src="./images/l1_regularization.png" align="center"/><br/>
+
+A much more detailed mathematical background of reguilarization can be found [here](http://www.deeplearningbook.org/contents/regularization.html).
+
+
+## How to do Regularization in PaddlePaddle
+
+On surveying existing frameworks like Tensorflow, PyTorch, Caffe, etc, it can be seen that there are 2 common approaches of doing regularization:
+
+1. Making regularization a part of the optimizer using an attribute like `weight_decay` that is used to control the scale of the L2 Penalty. This approach is used in PyTorch as follows:
+	```python
+	opt =  torch.optim.SGD(params, lr=0.2, weight_decay=0.2)
+	```
+    At every optimization step, this code will add the gradient of the L2 Norm of the params to the gradient of the params with respect to the loss function. This can seen in the following code snippet:
+    ```python
+    if weight_decay != 0:
+    	d_p.add_(weight_decay, p.data)
+    ```
+    This is a very restyrictive way of doing regularization and does not give the users enough flexibility. 
+    
+    **Advantages**:
+    -  It is easy to implement for us.
+    -  Faster execution of backward. However, it can be done manually by advanced users too.
+
+	**Disadvantages**:
+    - Not flexible for other regularizations such as L1/L0 regularization.
+    - Does not allow for different regularization coefficient for different parameters. For example, in most models, ony the weight matrices are regularized and the bias vectors are unregularized.
+    - Tightly coupled optimizer and regularization implementation. 
+
+
+2. Adding regularization ops to the graph through Python API. This approach is used by Tensorflow and Caffe. Using this approach, we manually add regularization ops to the graph and then add the regularization loss to the final loss function before sending them to the optimizer.
+
+	**Advantages**:
+    - Allows for greater flexibility to the users of Paddle. Using this approach, the users can put different regularization to different parameters and also choose parameters that are not a part of regularization.
+    - Makes it easy for the users to customize and extend the framework. 
+
+	**Disadvantages**:
+    - Implementation requires comprehensive design and time. 
+
+## Proposal for Regularization in PaddlePaddle
+
+### Low-Level implementation
+
+In the new design, we propose to create new operations for regularization. For now, we can add 2 ops thgat correspond to the most frequently used regularizations:
+- L2_regularization_op
+- L1_regularization_op
+
+These ops can be like any other ops with their own CPU/GPU implementations either using Eigen or separate Cpu and GPU kernels. As the initial implementation, we can implement their kernels using Eigen following the abstraction pattern implemented for [Activation Ops](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/accuracy_op.h). This abstraction pattern can make it very easy to implement new regularization schemes. other than L1 and L2 norm penalties. 
+
+The idea of building ops for regularization is in sync with the refactored Paddle philosophy of using operators to represent any computation unit. The way these ops will be added to the computation graph, will be decided by the [layer functions](https://github.com/PaddlePaddle/Paddle/blob/develop/doc/design/python_api.md#layer-function) in Python API. 
+
+### Computation Graph
+
+Below is an example of a really simple feed forward neural network.
+
+<img src="./images/feed_forward.png" align="center"/><br/>
+
+The Python API will modify this computation graph to add regularization operators. The modified computation graph will look as follows:
+
+<img src="./images/feed_forward_regularized.png" align="center"/><br/>
+   
+### Python API implementation for Regularization
+
+Using the low level ops, `L2_regularization_op` and `L1_regularization_op`, any user can add regularization to their computation graphs. However, this will require a lot of lines of code and we should design Python APIs that support regularization. An example of such an API can be seen in [Keras](https://keras.io/regularizers/). As per the PaddlePaddle [Python API design](https://github.com/PaddlePaddle/Paddle/blob/develop/doc/design/python_api.md), the layer functions are responsible for creating operators, operator parameters and variables. Since regularization is a property of parameters, it makes sense to create these in the layer functions. 
+
+#### Creation of Regularization ops
+There are two possibilities for creating the regularization ops:
+1. We create these ops immediately while building the computation graph. 
+2. We add these ops in a lazy manner, just before the backward, similar to the way the optimization ops are added. 
+
+The proposal is to add these ops in a lazy manner just before the backward pass. 
+
+#### Storage of Regularization attributes
+
+Since we want to create the regularization ops in a lazy manner, the regularization attributes (type of regularization and weight of regularization penalty) can be stored as attributes of the [`Parameter`](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/framework/framework.py#L421) class. This is because regularization is a property of the parameters and storing regularization properties with Parameters also allows for shared parameters. 
+
+#### High-level API
+
+In PaddlePaddle Python API, users will primarily rely on [layer functions](https://github.com/PaddlePaddle/Paddle/blob/develop/doc/design/python_api.md#layer-function) to create neural network layers. Hence, we lso need to provide regularization functionality in layer functions. The design of these APIs can be postponed for later right now. A good reference for these APIs can be found in [Keras](https://keras.io/regularizers/) and also by looking at Tensorflow in [`tf.contrib.layers`](https://www.tensorflow.org/api_guides/python/contrib.layers).
+
+
+
+
+
+    

From af215a1a532137686a696cb1c5da5a8797ac51ca Mon Sep 17 00:00:00 2001
From: fengjiayi <fengjiayi@baidu.com>
Date: Wed, 18 Oct 2017 14:17:39 -0700
Subject: [PATCH 18/29] Design doc: Batch Normalization Operator (#3748)

* Add design doc of batch_norm_op

* Move batch_norm_op.png to operator/images

* Refine batch_norm_op design doc
---
 paddle/operators/batch_norm_op.md             | 134 ++++++++++++++++++
 paddle/operators/images/batch_norm_fork.dot   |  25 ++++
 paddle/operators/images/batch_norm_fork.png   | Bin 0 -> 23873 bytes
 .../operators/images/batch_norm_op_kernel.png | Bin 0 -> 165209 bytes
 4 files changed, 159 insertions(+)
 create mode 100644 paddle/operators/batch_norm_op.md
 create mode 100644 paddle/operators/images/batch_norm_fork.dot
 create mode 100644 paddle/operators/images/batch_norm_fork.png
 create mode 100644 paddle/operators/images/batch_norm_op_kernel.png

diff --git a/paddle/operators/batch_norm_op.md b/paddle/operators/batch_norm_op.md
new file mode 100644
index 0000000000..80948adf2b
--- /dev/null
+++ b/paddle/operators/batch_norm_op.md
@@ -0,0 +1,134 @@
+# Batch Normalization
+
+## What is batch normalization
+
+Batch normalization is a frequently-used method in deep network training. It adjusts the mean and variance of a layer's output, and make the data distribution easier for next layer's training. 
+
+The principle of batch normalization can be summarized into a simple function:
+
+```
+y = (x - E[x]) / STD[x]) * scale + bias
+```
+
+`x` is a batch of output data of a certain layer. `E[x]` and `STD[x]` is the mean and standard deviation of `x`, respectively。 `scale` and `bias` are two trainable parameters. The training of batch normalization layer equals to the learning of best values of `scale` and `bias`.
+
+In our design, we use a single operator(`batch_norm_op`) to implement the whole batch normalization in C++, and wrap it as a layer in Python.
+
+## Differences with normal operators
+
+`batch_norm_op` is a single operator. However, there are a few differences between `BatchNormOp` and normal operators, which we shall take into consideration in our design.
+
+1. `batch_norm_op` shall behave differently in training and inferencing. For example, during inferencing, there is no batch data and it's impossible to compute `E[x]` and `STD[x]`, so we have to use an `estimated_mean` and an `estimated_variance` instead of them. These require our framework to be able to inform operators current running type (training/inferencing), then operators can switch their behaviors.
+
+2. `batch_norm_op` shall have the ability to maintain `estimated_mean` and `estimated_variance` across mini-batch. In each mini-batch, `estimated_mean` is iterated by the following equations:
+
+```
+if batch_id == 0
+  estimated_mean = E[x]
+else
+  estimated_mean = estimated_mean * momentum + (1.0 - momentum_) * E[x]
+```
+
+The iterating of `estimated_variance` is similar. `momentum` is an attribute, which controls estimated_mean updating speed.
+
+## Implementation
+
+Batch normalization is designed as a single operator is C++, and then wrapped as a layer in Python.
+
+### C++
+
+As most C++ operators do, `batch_norm_op` is defined by inputs, outputs, attributes and compute kernels.
+
+#### Inputs
+
+- `x`: The inputs data, which is generated by the previous layer.
+- `estimated_mean`: The estimated mean of all previous data batches. It is updated in each forward propagation and will be used in inferencing to take the role of `E[x]`.
+- `estimated_var`: The estimated standard deviation of all previous data batches. It is updated in each forward propagation and will be used in inferencing to take the role of `STD[x]`.
+- `scale`: trainable parameter 'scale'
+- `bias`: trainable parameter 'bias'
+
+#### Outputs
+
+- `y`: The output data.
+- `batch_mean`: The mean value of batch data.
+- `batch_var`: The standard deviation value of batch data.
+- `saved_mean`: Updated `estimated_mean` with current batch data. It's supposed to share the memory with input `estimated_mean`.
+- `saved_var`: Updated `estimated_var` with current batch data. It's supposed to share the memory with input `estimated_var`.
+
+#### Attributes
+
+- `is_infer`: *bool*. If true, run `batch_norm_op` in inferencing mode.
+- `use_global_est`: *bool*. If true, use `saved_mean` and `saved_var` instead of `E[x]` and `STD[x]` in trainning.
+- `epsilon`: *float*. The epsilon value to avoid division by zero.
+- `momentum`: *float*. Factor used in `estimated_mean` and `estimated_var` updating. The usage is shown above.
+
+#### Kernels
+
+The following graph showes the training computational process of `batch_norm_op`:
+
+<img src="./images/batch_norm_op_kernel.png" width="800"/>
+
+cudnn provides APIs to finish the whole series of computation, we can use them in our GPU kernel.
+
+### Python
+
+`batch_norm_op` is warpped as a layer in Python:
+
+```python 
+def batch_norm_layer(net, 
+                     input,
+                     output, 
+                     scale, 
+                     bias, 
+                     use_global_est = False, 
+                     epsilon = 1e-6,
+                     momentum = 0.99):
+	mean_cache = scope.new_var(name = 'estimated_mean', trainable = False)
+	var_cache = scop.new_var(name = 'estimated_var', trainable = False)
+	batch_mean = scope.new_var(name = 'batch_mean')
+	batch_var = scope.new_var(name = 'batch_var')
+	batch_norm_op = Operator('batch_norm_op',
+	                         x = input,
+	                         estimated_mean = mean_cache,
+	                         estimated_mean = var_cache,
+	                         scale = scale,
+	                         bias = bias,
+	                         y = output,
+	                         batch_mean = batch_mean,
+	                         batch_var = batch_var,
+	                         saved_mean = mean_cache,
+	                         saved_var = var_cache,
+	                         is_infer = False,
+	                         use_global_est = use_global_est,
+	                         epsilon = epsilon,
+	                         momentum = momentum)
+	net.append_op(batch_norm_op)
+	return output
+```
+
+Because Python API has not been finally decided, the code above can be regarded as pseudo code. There are a few key points we shall note:
+
+1. `estimated_mean` and `estimated_var` are assigned the same variables with `saved_mean` and `saved_var` respectively. So they share same the memories. The output mean and variance values(`saved_mean` and `saved_var`) of a certain batch will be the inputs(`estimated_mean` and `estimated_var`) of the next batch.
+
+2. `is_infer` decided whether `batch_norm_op` will run in training mode or inferencing mode. However, a network may contains both training and inferencing parts. And user may switch `batch_norm_op`'s running mode in Python `for` loop like this:
+
+```python
+for pass_id in range(PASS_NUM):
+    # ...
+    net.train()  # run training model
+    if pass_id % 100 == 0:
+        net.infer(test_image)    # run inferencing model
+    # ...
+``` 
+
+`is_infer` is an attribute. Once an operator is created, its attributes can not be changed. It suggests us that we shall maintain two `batch_norm_op` in the model, one's `is_infer` is `True`(we call it `infer_batch_norm_op`) and the other one's is `False`(we call it `train_batch_norm_op`). They share all parameters and variables, but be placed in two different branches. That is to say, if a network contains a `batch_norm_op`, it will fork into two branches, one go through `train_batch_norm_op` and the other one go through `infer_batch_norm_op`:
+
+<div align=center>
+<img src="./images/batch_norm_fork.png" width="500"/>
+</div>
+
+Just like what is shown in the above graph, the net forks before `batch_norm_op` and will never merge again. All the operators after `batch_norm_op` will duplicate. 
+
+When the net runs in training mode, the end of the left branch will be set as the running target, so the dependency tracking process will ignore right branch automatically. When the net runs in inferencing mode, the process is reversed.
+
+How to set a target is related to Python API design, so I will leave it here waiting for more discussions.
diff --git a/paddle/operators/images/batch_norm_fork.dot b/paddle/operators/images/batch_norm_fork.dot
new file mode 100644
index 0000000000..4bc47713cb
--- /dev/null
+++ b/paddle/operators/images/batch_norm_fork.dot
@@ -0,0 +1,25 @@
+digraph ImageBatchNormForkGragh {
+  subgraph cluster_before {
+    Prev [label="...", shape=plaintext];
+    Rnn [label="rnn_op", shape=box];
+    BatchNorm [label="batch_norm_op", shape=box];
+    Fc [label="fc_op", shape=box];
+    After [label="...", shape=plaintext];
+    Prev -> Rnn -> BatchNorm -> Fc -> After;
+    label="original";
+  }
+
+  subgraph cluster_after {
+    Prev2 [label="...", shape=plaintext];
+    Rnn2 [label="rnn_op", shape=box];
+    BatchNorm2_1 [label="train_batch_norm_op", shape=box];
+    BatchNorm2_2 [label="infer_batch_norm_op", shape=box];
+    Fc2_1 [label="fc_op", shape=box];
+    Fc2_2 [label="fc_op", shape=box];
+    After2_1 [label="...", shape=plaintext];
+    After2_2 [label="...", shape=plaintext];
+    Prev2 -> Rnn2 -> BatchNorm2_1 -> Fc2_1 -> After2_1;
+    Rnn2 -> BatchNorm2_2 ->Fc2_2 ->After2_2
+    label="forked";
+  }
+}
diff --git a/paddle/operators/images/batch_norm_fork.png b/paddle/operators/images/batch_norm_fork.png
new file mode 100644
index 0000000000000000000000000000000000000000..aded62bce5bc268b7a3ef4dc96c89fe21d6ea955
GIT binary patch
literal 23873
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
WXm_lfd~F~T-H5*2f0=A4C*>b6=p_LF

literal 0
HcmV?d00001

diff --git a/paddle/operators/images/batch_norm_op_kernel.png b/paddle/operators/images/batch_norm_op_kernel.png
new file mode 100644
index 0000000000000000000000000000000000000000..a99ce81ff3bf42880ebbd6a1297de3bf038e09b2
GIT binary patch
literal 165209
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%0Ad{-PZZ
z#R|FI)}tHlen%K(I;6~|Q=g)Jax5EUfln(5ru>9qM8BPf=caGC*;mY%--BIKSsb=q
zXv2U=BD=9=Vjm~ww4vLlV1qQnK(Qh$AChPKK9fH5j39_Bcm~4I3tVV`ZjsOTlNZ0e
zj~-c&pr|+hj7@k}PgZ%HVCo+36(B29xUzR^6*)9tZE@12Ew$-0Pg+`7+?7A+5+2m(
zCBiBi1MZB(hh~@0ED{vXY1hDZC9vljEzEvpd)DoPUJ;{r-!Rya;Ac+2S6bF(8;7at
z*~Q~uUq8#)iLn>6nA6pKCqjQ(MMp5^nrUs?WWnT>z1kobL$xnR>S2H+#F`r<$B4%5
zHL~A)%Qvm$Imv`f-b-h(kBolG(5(-I^Uzmo?<gyGM{$gF#m2cpu@ql1>K|dWB!M+?
zHXvle?L)CZx3;hXxZz3&4%Vu)bFbQKt3Fa8CyP-T9#e--o$gFFxXHaTT_tN`^7@5w
z)l2oKXC&v&wK|p66ETR`UdNAlTU~AG>UyI3{uT$7j#8u6sU18vmo>L{F93B^jA$Kc
zQIUwuU6luGe0jYiY<yZ;TE7tW4`?s&1CS7m2^A$O!IQUxOvFIfaT>q)+WRn0NZpU$
zJ`@UqPAau3m1(2U<t`3Y_G%4dfy9T69Qh5;-ML3p2Mr<e+ZCIzWaMXUnKcNPJrC5)
ztv3~QZ|oK&SbM|q*>d@E#N5cPD1}+cBB{0|4y-u=PO@J}V<N!z>v!+s%9js15FIUQ
zXwm5=>$%Tgg}8_}G<^AMQS0>T-Fq8|=Ir~gJ9Rv2+3A{hYh3Jib<NNiqpsaq%b11i
z1_q4eBi&>@$*A`$mZ)}Wb#{*VoG#KbT@D^+?7zdMqnB1`*V#i5RJi{dO?3j@8hiWD
zVJ=eS7%SLO#?Si}>D0;l`uaWsYA-C8Y$bCjrNr{H2)SitWy*^MT|eSkcEEIIWuP%#
z)@d*!%rWC4))iWt4t&2x_ef@l`f;1^#=blfHr-7rO$96Q9G&YJl+Eq4itUZeqcguI
zAdyKSy2Rq|YoVE=uqzE5*i+1w^ew7jtG!q>V`JBCC6Et8IRL9|PR_ch%{#gjWy6->
z*Y6g}8yhcc-*reIK5<Y|Qj%!xh|~MvMv+%VW?n3{Hr=#m&%mO=u0dn0;BVc=Yl;&g
z%r1$qZ$VRp<6#JKcERb+58Q;ufbeES*&(UKjtaS<+WF>G#YFre0|F5XDR6lwupr7l
z%7KX)HI#XaP5N9((q^6(cIKpE-9dCt@S~DP+0H`Ma}dNJ(eSz+SL5odb-BsXRV2$i
z3}zm>3~x2ilj43611l23WFALS8V^~Q-T`++jK^^7*0bv#kp2BaOv0dS-eR5y<s!Kj
z@9iDCc0GAG%1w*di%uYN#A5&EhDsrC=r^TX7|UsizhW0Ty*H~tf(a#0jAR08B33k9
zw@YC6%$22qn_C+vYVYZTO%?zJo;~ew{!1i>e^%@_@X<9>#}w(bv<vHuPX?dn9?hP1
z!O|k;6q$}0eXG^0he$9B?!>$AH${K4rDZIXotUc>Hk-@qzc{z<ZxIuYRN?i94>`2R
zl0=)HgvMgqq1RdVHyvgz_xsw$`ma+Ma|{ff;7tMEg;`NbD2cW2_Rk#VQzg0<+ZEoH
zGiG!~!LW#&C?R-lup99XR3<dru3I;Pi3lo=wi~hg6s<9f0Z+cIIL50JfIo9K?Zk3V
zo=JCMQ@OL}9w<kD2F>;*Cl8hoBmEp%;CFtFSh-Ax@Q!j$LNFJ2Gp+K>aY?^HQow0-
zGYy$ir%o>2GPX^i3SYbK_Kr?ASM@C>Y)NUm(<F&m8v(&lzCFL<)s-3L>!v49=qz8k
zC0uvcpEa&0MqFU_{ZNm2R-Hl<a&T<nYesa-k1!5KhJDiTdY_RaBl*Q#KCnED-t1$0
zhgP0MgMm;FF*=2k5S#Fzg)bv%&1lqT9;bkoWqa;91Fg-Tq8MZs5)5~>784R~Zt*+A
zCkrbiS>xHWXA8kjU_?debCw2Tcv)CCRFn&(+jz62idSWZ>46b^bn4OQF;;cYL~BGv
zZnXy^k@c7nox5Fu9@7>5#}Zj%0?;nVG&19Ms*8fNbBA)HSimqCuIWIh#gi;I%{Utp
z8y{ipTrwmu!lK()8yh7!Be?Z#RKF1uPWClc8L@iswuq?c9^!ivjs`6pWPUY1ILi)`
zjXWWhr*W5bQPo9hHGf0HLKR(AajFGZv+?VgGIF)B5+=1pagKr+RuY_!gxD6ws28r^
zS9X5W;H9<apNj@zZTYUDOj8ZQrP*#p#YM66fP*G>Qpn4+LJHdxmPTA#xw|WW!gp89
zN^`@|R$kr6A}}=57FD=7mZZe&oSe6~a0pXhY~pGPuZx{o!UI1(-I<MR?AJah+td04
zFHKD2ktQXuS;YzAz`Lz|=PQY1&B+y5;YMDRP?ALV&lxMi6}2xHLkt`+_cV8^QqxZ_
zb`;mIU0Y-9k`Vtm?(ZGt1cK-6jgEeZLI6vF^TYl6n*aLDI`Vh9U4MNvS~z&Nh-{NG
zdUx>sz(}S$i+=F35FZ5(71n4?L1EZu+Oe&&-!;gueKG^nsC2e+X%h{#ub&_ibB%(S
zui>E}il;;h6j5tfeg=(<JHzpa3#7%cAaJBm1D_gJXF<l_hG>X4ApM%6l$rlvDjfa|
z63ezN^_iyiUV%S&9%36{>uD7`glRif@&!(y1U2AzW`llKS1!RyLm=7lnPMG>sOn^U
z1_+BrAo4d1d8o<DFvu?4+<D!0D`K{Ab%hHfL0A$OWH*QqQIZeywIEOkV3(R$OtA^E
ze!^7ET(!ogKLzJBKb6X<^uL`Kebg)_tLI3zJrPrM2MpN7Sz`r=+BdalH)?O!y|Xzc
zefO@}{(cd9;$XThtgn&35R_%N8f~bcJaI^qHRB|~fyM4@p14+@fs>q#lC84vp*%{>
zz!Hj+_ijwo7YsXi^PtkiC7zzSJg6$Lyq(|V!6@5VTU-Av$WiDM6mH?Yb}uyjo|9n#
zvwy;KtMCfkoRXT_$+sphU;%=GJ#$7+g0q(iu6z0AxkfM8cV~7H#Ap6jq4!OLg)e&;
zu(X?XkunEAf_BIn2$EMgTZI(Wyoc6e@_=<nHfz7CGyZ-Y{sB5a;tEG9oQ{A;ShW@j
zVg_DWhlH6T%jjRN`#2z1&2QZZpAXV=uc(boft@{{cFI!4*8(Ji@qF)pCMmO!ls<HE
zD$l%g!t!;MyTgpf8VBxCYJ|4@J(2Mw79p`iT+k|Hjd?Bk2<a#%rGVSaaORP|MMbm?
zf=Y9^c424F1v1FBEg3x)j@WEOx%lQrZ5rEEt?&8D!2ga1o)lKUe-*k&v&8isR%cH|
z{)lG?)Z+DG2ulb_%%|R(h^&K+>mIJb-^QGiSEOkl^I~)j6WqL+DJ8T`_Yeo#M=f%P
zqLN3}@qK6rL<6EBwwc=83r$$(P*q)>O<%Ffp<d%eLP8;7j|zH93C%&+@&1vi&$u=W
z(Jkbqu;JwhL~sGmoF_M41~p3L5cPx6!8<k;I~JeVX>v?B$FrvOUlNlSa_i~SA-~#O
zSvxSbX~?r@V7af$kBfHaqD0C&D~p)ELx*0~&^?ZcNYM7}ZNUC!u80W*=J;EhwcZ46
zasdE>VEbSqCHu3ag>pbk63s1AAGoOYQ3;<gr@_YS@EEJ~(!=M2XVwh{_7?^pejC<|
z@qq>p(Hz;ibVA+tvp6P*Qeuo15#E)GU)DI=t}KBIz68AJx6kON?{+Gc>J9le;aJG9
zR(aY<%a|0A8C6uq5qvkbD8Az4S>E%_5fUJR>&mSWu!Se6-^3-Ojo%0!L|h_M<m5;N
z1h||`bhX4XnS7TiFgOG+o^u{Kb9LT#SS+i!J$CG_7L)Z?{+4Z>Ektm8|MKNa7H8bU
zYt3+5Btvfk=A9muu;k6{K)~QTKC$OH>LN;UBu@|1c8h131A+D1{jSR-?g#f1Q<fMr
z#s{yf`$bX`vQ;>333RN2s6=h3G9hLJdQ`9#Ua01j5(s*L_^t%-nVVvywq%$&IcYJ?
z-n(bdRvSf&!dK_iOxN-~h4UY7$ijOl-ixNhjcPVN|A@)Wrr*C}<0)gq0eA-V@0&jb
z@(_c}H&0sTPW=E3!Ahf03W$@#th1T>TZVZkalz2*55y(TJW)HtxATGypidGT-5IJS
z94E##4$ClYX_t{<b0TPk`iMn~1lEAdw-~AsOJ5KbqkHaabJXm!;-_1ZRj)LS206dA
zSX-%Sb%0{7^&?v!?YfssO0Mi;;GR3*N<y}?UKZEEy)5nK&Tm5(E?oGPyVprg&Hcp;
z;9PRqs#xp059X!$F}(3YIG+{{ArI2UICs<CpjSjs#5M`Td4BrriAL@CblGl`l^z}*
zENy#VHPt44gFm{ri40KMAJyF#5s_os{8f=>?DAp;#T>>>dGvWFq_PKv$HYvfSzqb1
zvZ3a_g65)@rrKP@*O64ckyonk%lpO%75c%0s!)E$UR~K83!--iqo3C6#?Yc4C8)7R
z<4Lj?*?CIDV9R^iW5r53F6shGp$BEoGOeVgZ>9R~H8r&uzxl?E-u4xtYkIU2$AY-N
zk8K6K+`q%;-Jj)~Zi(!wqYK7%!9BG1WLodrqV+Zz3hTGz*@X<B${M<BU=U|=Siiio
z<@9N2$By(YDnc*ImpT_bK)bV8an4D5KkQN0E?p*t_qIX_V!x@I9lfDgA_GfBp_Fsb
zAfKxTnoxN=BV!Yd=eLYD-49*C*Qb!5g%!{Aqq@tXzc?LSD!M_+|LI)6;Sj09$V9+9
zB^y4rU5jJ5N>w|s_+3CQ@7o&F!(CiiIhFG7dZNR1BZf!s78VvJ59re;NMJIIJ@MDi
z;DE%G6(NE_98qb>8owLJM_qtx8q%^0Y{Aa`J#xvXSuQ8DA3eI}x}O`lXCe2Eb<9z8
z7$i&QZn5#X2V+-xa;N8wEFUerHabrbSN5C${g6;q?};Fh;VPC#wQ%{wolY28>QO6$
z!`@4#`&ugc6bkv%X4;*_b{2g4Lb=?LSDL_M=(I2KDO9RD2$Y6TZp7}F!Yd;9A){mg
zk(J8C7yzrTg8yexjr)gs;hc$5RY=gM6~3Hsm0<*tL_un-O2m>UD2={zl26L&<Oh-%
z!M+#qZL#Z@T>hb`FIArfkb>;@LtGFG5YFekSdS7=$YjUK=cuHl`M`0^J;Zy_YzhR3
z&vnXdPak9B{j_$>AupP<`PZJs{SDF(cN%SITnji=TwLre(^8%A<=sIRa(NbSj?;_Q
zUC^5vI}e5m^CcH#+e~E-{ncjGpCL@>s_L8F*>=BIZ!a%nQQvi*D4yqMLDQg>z+!Wt
zS0v+qR6MyCmBSm?aQWi^=!E1!f-mxwBLoB<f}fSF&H`u3LX;v>c<?CjmL-Ho6F3AU
z5<Z7BLYuc{I5{!EDnK4&K!ra^w9s1<2v+tw*(xlH7ET%P$g&&Z1qG+UA$$^AW6-#I
z6K)e%IOVMkWl#njzC(#h&Yl)paa}lu3Ph1y*9NjfgbqVIvd9jnrJ4ds$wXI7RLdzh
z;+uYhnK?1N`0Rr=AZ%HRENMW_)3ZGBv5*;Ih`@Nm64?(~-9`CE{u3r_@n2R`7CvWH
z?e3+s>fT0TK}FMf7tJFd_yD-nti0EY^0sD&XWW;WamG-lhebswo8v?_;&HG+^L9ze
z$X{*t$F!f9ax1i_&E<YeUP!acAc;y&Z{L3Nt8&2;^(`k)E@wnB?_#4^?IfNdbyr&T
z)?*buTpvEw6nFQN9+4a(K4{)Wi)}%(&Jjf(Q;ZO-JYUR6^YdkzYqMw(zK>)e$?eug
z$>Ag15L%0&0tR@!KAh<h76}}?i<K@Dc54juLMx(1WD|A>{R#qb5i)IVZXSN1p&!CF
z{yX8W(r<4?3T|(ksA%c{p-Pf#E*H-iQ4I9LruFYu%<11QD>I$&>$2!LXn44XiBdbB
zgUWV-K*+kNJP*K-nm*9iC&sX+y1F_6bBB;F@?!pZ|H{f1Y#y{fVM2G(3$2Ng;j7eP
zyue)b#$v}i7o45E6mk!aJwHFfCNz`wcq|hCiIXS0{Qh2zd8-l6HCmzcM%NqX_xEqJ
z{@3mP=l^-GhiqGEhk3%yh*@5UzagvC)}hKIao)?#4dxl1n%Lq@jaPJL_MizT6B&pg
ze)a?2k>aYoVHkj+pIgaTNru8(y{)Z1Kh?ktEP$7K>-qEH{0rI;At@ER)M9%N?0Wv@
z&n^PKr7DP@I+lqdVL~ii$WY6io@fTP1NwKrv~(2zROC-=<HbMYT9xz5#9H6vnty62
zVFn*|;6S`~(~(b~mZUZR_7tnnG-7+>1+ZIV_%WOCL(w!QLU;|bu;|5V;9k)`qD#2$
z|L4k1X%XT8fr8mL{s0us_C#AD3ZjP*0T+nFg`z=1OjjLHSv=>8{5C}v$R8SNE$Sn&
z`4AbHc)sYusE?%7jC0f$_j6Fw)>d9jx#%k?veTi!BLU6oTx@cNRSEspU15<5PCkLN
zTj%4yq2ZmXSa3ig(cB{U@~<lkxA5}!s4O`>Bcm{&J`p$zuh4smTP_B_uuqDrT%6=l
z*n9kL4R*tg*<E{=*6}N1Ap8W6D(*gX*7U=8SIQI9mIiAozJ0m|(y)0#)d$v>NjkGC
zA(%Y?TJt5l{K)8V>GJBDIb0nv7jIP}#&EC+6S9dqpR6GxMnr(|ysMf~2>=Ktq&{k0
z@_~KIm)OhdjoKfRlieP3aaLBtxUe?$+te6`(O*H3{ZKfP$%bUE##ICv<y30Y9~s$O
z(zjqsq1C^CFhW0pi45Q3cs1|Yqh9^x;->~aI&K`Ry@$2yp?uQtLx+O6fgEF_Jt}Hx
z^-`l7l|I$%ijD6);BSL%AOV<scZsW;n-TRe|6s!S@!LGsbLVjVpA?g7C|Goo(|C$R
zEOrgO0;=N<5@n7NAb-COs*oJI^yTa5HLrZDq{e{iHGI01Pcy$P=Gri|?%nf+pA+L9
zyKBUOg+{%0<HpB3+MU1s8IAQP5NdtX5f|F=zxV{hbNLQ>3W|!AOpjJVLk+*e!Hxn?
zvbnfmoWIlEPxDgOhLQ|O{&^ZDbQxKs7%Wt??S8=H4nD&4`q<0?EKq>n-%J{<8r!pT
zIU|U%<TO#PJeyBp_ScF!Wp^)K-9ZE@66S<;>ry;$Cu`vQ$}-G9^J<ZaJH-=b+o6XK
zXES<MPsrC>^rh<%v#U$@9&UFeV5z)$P*%^$|2J6g`_lEwVwLZoy*}OUtg+-}{x}PZ
ziol~z9N=g%Y=t`w<M;`Da;^`T@7vwLO(7xjWcDl$gkYOnS|*p|>;x4tq!OTyj8_bv
z*sXDcA4S!(tIHgDia3o@UAa--vU~e`;QBIbtQceAs)Y8Gwmmaz;OP3-t#CSs)wfy@
z3TmIvZSVdf;q>&=_qi|I)6-kzp6?$BHpkR7PolXX@GU?PHL)-v`ytsO_>Y6ZtP2~d
zQA~XrUoi+J8l?H_Yc8v%$bb;=tC9fZG=`p{joeF9kHWq?9{lGOgJ)@M$+!h2qQ>qO
zmZW5TjRNi`ah;&&c>gHwt@@{8NB<uxbimrZdfiJdC7*#04q{h3h2nWd%Wlee9TVS0
zFhDVaj_sAVOuAQB)-ii{7%tVA5^<uPimyB){HOvtAW}h{2A(o-&&p|!9u=e*pGdg#
z;IQF>t)i%{XnjmP^*90=I94_rq;5e3tTd?vxkd3;{qp)Zx#HLg!kQ=y#Vjik`u*C^
zXRp3mz-<Bq_&_+{t}ZVll+S4Lao_aYT}jNClD?ryj91-TGu+bJnpxUIV(N}4tdY-f
z=+`{~ja!I=AxvLakL}TU84(}%450+!@ZsHvPCHi^+Mqcc(Cj~&VJ;Z`<{#$+Mis>-
zQXjIpdnYQ+_YJ**?j<$N&YTY7!85%NRv?7@^H1jWCY3t#88LdRY&&>1%Q5373s>v-
z&z^N-CR$rB;vfqRAf?>9wdWvJ#J(#bsbrl|s?r~^QfM~0dv~po;VYjZF8AeuM$agY
z>!w1}$MlkLG~}hZlI{)+s=qeO{dvdF|4se6WaZ=tBpQ<0mLCH7F_~J*JHYAd*Mj7}
zFK^1ZWZq71juVZ(Z$_VII@)eEykkcHe#FYPl0fI-jD?WF-5qzhz!w>>=jb0Q*PpnN
zqi)0yoXK_NBSDSVMJ+}sg6gq?H{D$cIfv)5@CZl2^WxYTDcTb{+kdBT50nq5L?-m#
zCt|RN>hX57`F#jff35Jp-cwc7l%psq;3zW&xIHp5^4_YgVyR1+|1VA6dT*AoWv--n
z1SAQfWwl9iwe(l22wVZPC%P<gega}v!~M4hqGGL6*@7*8ylVPyj^7eG((dchPzMS7
zc|OF4J6Z-&B;0{i$M}JlXyhhsx_G<_Jgo|Y?|c5u3`2{JV4`Bh)Jk!bBV_jImd2H&
z!S6k??yy|U9F)S+%4#7k{ez?vP6f?PuWJ<8BHGfdr0nW&Zjwc}*|5Jn!MK0y^cj)=
z@v?gnQpLAY#plfPV=j2d{q!OrsP5ftrM;j--VxJ$;X}qR+I?fABx4ljh}FLQ_`%@f
zy#=>Tu{XvrC<N(`z*HIO*j-81&P5>NTN%A3`EFQHV<G^hKo3X(Y&}|A)xaq#q>{nl
zvAQ63%j^wDgyIG^Nm$QP@--EF1NA>aKg)ss5a@V+LIs_m*l2<)HLXbE_80?pfYV+O
zgGO`RB5GFTL)c8|anJPk(%)yhKKWCde!ka|ioh#$LZou$wsl92{1e-B9p?f1Z}vw!
z|15P^kRh&W2)c;h9d_tYeSxQdPx!~ySYaDC)ZOONbfF}wgr3?^HNMqGG2YD}CvR#S
zM`8AIgB|VvqXkIYUQ}c++IGsE*_gJ0?5(ddHt;T9;@eo3Oj+hlA{49XKw$<{%A_8j
z5IcL&#Hrgx`#V+Ju9ZBvN7?s4?<t2wa$n)&;|iVk{^BY2BD{VtlVIKT*Vh4a%_esb
z4hl-$tGuLRhhQO&06qGWpxd54%^GA$h$Cmu|MaKH@(zw_G!%adJO!~nvNqM_(VFGK
zS>F!A*J30@Rak##<QYk^_l1I5EOja^jpk!l=G@!CnNDJ*JH+f*AD_W^;WXSSo(@b+
zaU;Bb7%ezvdBCI>r31eNcf1UoMVh}DqoTi+naTK#H5(X&<L0?tzrbdNW(Po^Q|Hb<
z3p$3SC(gOt4~|TX^c&o@9i_eJ12qc1r{Ms_DA=2LuNa=tsT-G`aVB;R$y7CM{L+dG
z(TkTvxn%Oa3rG}X;#zW=p!|%VhgAwg6n?-!?7mD#o%2WXFGeBg1v8#J+0WCid@<Ue
zN>T73h_?XgdKer3Q2gbIhLqwhv1yKkXeJnt5W;TigRhVtv!<#(f)u=S=h?%!m5XLw
zl6g?EX2xAxXkhUa@KqDjo?IeWtv|nFeOI~+z4H5qbLG@Nvuwh9X=~SQwuKwid(3yA
zEh>7qhr-K%N10le(;o*j*v(GBcHVKh6Xwk6LO_a_tLHuktnG1!(Q1nIfz&s1lHFt5
zbq-B`$Mq9aNsQo|eyXpF1YLOZ;lobwSU|}WykcQ(khp49PF`MbiZ&<<@V<LQPN7PK
zrD!Y+5QIARXzlpQj2u3AfBW3Tr6VBEIXaab_W<`D_sdSRZ4&a35~~p889F;8I=a-Z
zyEVinn%TEVJY6}{6hht=Ssjc94Ql!FL)=mbhVP%AhttQ-dTF~(+nU8a9eGo(0KX3K
ziPpc=;raQlV%36J+>59wf1w|(6^0j`klJHc!OYt`Dye|_7h)q6^g0!7k*`%n%ZBdk
z*aboCO@JY9G`;yqiz-A^%wd7w!e&G#tdnnEFPvN{q=i{3qgxDS{wfH&n*IwfXq+o1
zBewD-V;Uz)(a(ylo9fhscZ-V;!raZC`s>_QY4^v{=NvX27~ot!-e#sxXeJ5BoS&Wb
z;6cUd^J&^zT3R%2p^};-%v^Qs&tZf+=CG0ALqb&#i5U4P>Cz>tn;x7|+Ta)*0e@IK
z{&_svfaOx#z=bIuGO@WQc#OI%w*hr|Z>-*UO@*3!0iP;>UjlyDVqnpg*TdO9i5X9C
zdyAM9GO5@xI&osw5gGG<d`ccX2az2M*If#E;n$&TFkhohn>J*?1LZ$>Jv||CU?w38
zvS~4fulcOO6@CMu-|}PRm!V>V1@)AOfHgH|-whqtEGQy^+`1Fx-6T*Yz!tl|I1(Kd
zbrN8VF_r}JD+bIdDl+cNruq1$AADB9YVj)=+r!;HtXi$|s{hCV18UNn(}|SU{4jDu
z9E?l;fPFm{^o0f>^NQ;WKCyzfz|{XNGck0Mtf}uZ{O2NF-2~mwehh@($CT+d$k3EO
zzu*;yvr?=3tDvuuTwoL@Tj)XfnbRd^S6GW7cEB+v)yFU?(tWjO^Rmp>?4U?x>&);C
zmjXtvd4n0nha?}s$HHYlVW@KOcCz~8GiJ<f$L4^HXT~pzi&c5n?1?*-9j?(_8PL2P
ztS@xmJ_}AdmS|U^YMUn?gtYxuxoh6M+jq>PAC2oKX1;`@Jx|%?ADTWxqy354fPnI_
zu((O)OY|ykD?9{}s`Kkh>0%H9WU%`4%WUc|(D`1&hc_6sX!3~X`@T~_)y7Mfr8OBG
zJ<Nw)v0QrK;xPIJlA45&{BT5>Z92>ajhw26!oMl>el_*z2#;AfBU?oQxuTO9y2=qJ
zzWjiisPB42;HucE%5&D)ReasE9@7{Ab!R>+EM`^c=B@cVAtn)b+%7HEq%{}7N8Edh
zZqvBk^Z?XDN(><YN_B52gR9X)PZrj9E7Yzt7(ULHYzm6t3-LD5_@Kqw%N|IQCN?ET
zR5N=TTil-~^+H3$K<?YaKASuFhQ`ImivjM!6>9<Js;jH74-pmuheyo4>i%d<Wv>cr
z%(P|67dU-Q;;s=-FGiJZ^ehg^&4-xV)pe}>z5^#a`cC<Ov1;A@Bpf%iYxst6uHfWf
z99l=whJZVNBCB~62gH8qW1g@m7P>Zmp)(rz+g##P?K*b2w4AEUZq4<w5kqi#Zni!c
zzOEyVld*(Q^tsb+toFh#hEi?!JH2^Y3wk_${20;2-s)?W<YWi@)<U<)?fDpYaQ-py
zm-xNM2*6yZrxrmbt-1a23%gMYJw(T_HYQ;yZ+OZZ7v$ipmUr;Yv9+@kQYEHg-Xqr$
z2Af34y`iCBi&`AHWg<9mOtALZP1A!Y;HgfQ;|S)XnEi4{^HYbnhg;K2xb&HFpt_yz
zRI}2Q`>*c=_;l+W+VYtO47yi%^}rS70^>e7KDVT?!O*AAv*+fs)RGtfEvU15QZ|H|
zWH=d$VO4VBL*yM+^I&UJz8C4&i<$W%qcolbP?-{+JICFBS%-^S#Ayye#`jUa;ChAL
z_V5?n|NfaDH8nM}4;pkAvnbS&Xb6llAJ3$kx1Bc5+j7pF2oH~}vY*x1W)_Z)4hvf_
zC#Scu@snhSDDFPKTCwO=30+apaifzPr<<34)vtTW4AEC?UMgnI7i9smr_Tll0~-f1
zMK88yXKt8xdGYiQPtQ&UCYbIM>M&ZS<!t}&wE>qdB_(zH{ZOBIf!$@FT3()~ggN&%
z$K?j|6u2+)@i!r$y8u*^TYX{u$IgR2WlWpf8hb*0+Z@~4dwRt{@_rlc1RBjLNJ+2;
zOz`z7S7^7X+o+Jqj|R+^YWnRV(9b$0pbj1DKTWMgqzh*sJxC4H0otQRMRPTgd$OtL
zZ1r0|QXfnBhOwjdD8AsrgBkKk2sg-H_VzFX^f&Lx8P~Zz$W9ob&rW_BmEojCW6cjL
zjQ+u6H4f}f!nlV>@l3CG^rSrqO|%PJC_2dglR)C%NxxWDCSzbQY^~C%8G)rY-ozao
zjC!d@&z@UQK?>y*c|z#E^yiKE)uwYNmrr^74#;fUWat(mx?G(-LcjE1e{>Z8ur^~C
zd}?}Qog5lHH)`Mmg`0jg`@0v)tghL-Qw7v#=KMzxwla`@grr$%e#0re#J(!=hJLmA
zS!n(GbNjx14PDzlh)fWDT=teT)204?<G=qaG_{&GiXHPpd})K!k$9=6TeJ_b`9_zq
ztbp!1@`g~YJrfp=B)h)$Cy7fPfc7R$8N98to$ak+)wJe0ohY%wCWtWmUw^{dG{I_M
zLlK3x#)hj*DLxhQSI^~(x_ZIcu1lUv#Z4Y-uble(lz8P2qemX3nP6f#lVbiP#RU?t
zzS-AOD-h7Vk<2}~<+8p9vuzdAN63m#@b8~&7g|cxS}LYZ-#d}k7x9cZ$1ja!j_hyU
z+^p1Drq|@#yEVW3{up5&nyIXz@qpGlc>jJCuq(cGW%E&6yI7YA!+bjmu@C?KUkuIn
z(Ai0>Hu%q<ur*@sEFD7~x50)(57mgjMaV+=S56xPnmcXYg7v6NW^X9YQ&}!TP7Ofi
zx@eK;dTFUv2H4D=U2t0U?mhK`2VbVD>%|2}L2#N3`tZM=*91{E3uN}oYjdI%r(TzL
zc{wDbtGtqugt<9%Ai)2RkDj*Ux-nXlNe|tF;v#nJb|Y$2)FEHq+;4ByYm(Z*gJ*2a
zMbWE`YMWp5@1Kgl<9gKc>^_YYA{WFH;tu5cwxZ2X^?hB{_RX8upU<J3m_qnOZm<n;
zALUQ|htuaD{8di8ynerl*}ee=efi<NXK?C{8vW<T^M6yXJuWQ7#;p@2z1ZB&oSIGC
zBo%(akqxrpx?66JI^(G5RkD~bAc|6I+b9#?j-(u%yl}qFYT7hlzWlOug&{*OtR7Hb
z{}+kBYk?B-zyHj4B69(E2a*$QQhYqnW9aoS8oV-oV3Dg!tNt^@S(PTbS0g?{hJTke
z6SPI&+8PILzf%x<KOkn*+*l##@(rR+{O>;oC!zhoNXD{w2{oQJ=x*@<j~xl;)3=58
z%y`k|z<^ecj=bDXeu~0y14m-PhW^9Ox&J@uYZD82u>blKs#>rtHXdw9w0Ia!qkgy$
zHT1#~b@}e?XUs5M*6sU;IG(!{aHTG45sW6p+W~Uk`)A9Dl`=1`ZeRb)sX(jTJ6wF`
zfLk+q{f|4~dy%tN$O<83C01}DK|6Q8rDICw7cAA3SCe@D+;CMt`EF;#FTj4#iOCyb
z35v!^xNQB|lH#YHn)>>_f_rhEnu9W*xuMhlI+=A+1J&e(vo?v)_NbX8orMKqS+7!I
z$uo&j>&#|!_G=y<((SDH`CKceNjrex2*KIu)1IFdKm7D^F98|axJ`le;Y*%uH|KRW
zNB!^T-<ALd3PKjv!55U7(DKipmkwX%R5IirUBJs>^<Tz{7r-%d%G%pQ0*mor`dKdU
z<HFd<s>8gc3At90e7wKvfySBt>+Gj$2|fWgkL7gofOvF#bMju7zrB^&=JDg#rE8oY
z>!42P1aG8;o0-7Q!Fy<WyaQ~WKQFj3bV*rz+?K|M#7+8}cq$BLgC%as`5!T2!E?bv
z2<T5pAc(27yl3CZZ)n+oQf}m$qkl&T`u7(BV$#Hk?9<+l=w}cRG7Ef`bZfP~cGMwb
zIa$?h^KKlS`i}s@q$AnwzyIjHr0YD)E&_BQ!krDy7vgYFw?MatTEo?Uf8P{0Ib)98
z)F6{{{~z(r&wHx(7xt>D>7gx!NvJE4A*-j||4cY{H$Mb9h1GDzw2vaD`qj-F@8p|{
z`hNLB8HhQm=(>9Z^;qD{3EDzl+OF6=o}m-`0mDHfE1GY?N$8s|TG%=xqu^|$NNE<`
zf}2PDkE43ghU(ajfxTIC{|{YX0*>|CeT_oqBvFz`M1>M%2$4!<NJ@i5ijvG_NK`^m
z36(OYWN0un3K=t$3`tQDLTEHpX1=x2IrY8g-_^OU^S+1Y`3?8I@4eSvYwhi1eNw`%
zFjrjTWn7`b#*&ML3@0?vvtNkg5{+F)Fmw?HVF|c2&|stUlEEesGdWCSV^^Rn=i4A_
z{Lk*<<>i<PZZ`qqi0nuO;!%GB?pzm|Q^J8d@?$CNZ|&_Xa8ODB)JDd4%HRJgiga>W
zLpQ&5IOjtXPJuQ0eyJAbPbQ77AXVOl+LHf9h+XD14v-xA(SyeQgMInL@gK7C6$gux
z{>Mkj%KB!wJ%XTt3Z%j+1qo6(Hu2$Uu-P7PA4T&Vq?B>(L6TRZlK%Yyv1z+ej1jVn
zjDrZ<TVvwj%Dz<|WChzDCr=tA=rpq-zX|;Jlzcv?%DIW<p6vn9%lEU?d)_n%!S)zj
z_}A{;B}&ua$vgsVj*<TAYykSV@LFG^k=Ixx0w36#M|^9~)5AFi_=12{6cvEw3ecEE
zlYb=3Vc*lCff&ytO=?LESLq9M|Na6-D2FxR!iDO5H%#Zy7EC`Pl=&FR$&F2CO3I0*
zzmi57VagOr6L=@oscPyX2e=-vsLJTk;uC)Jt0-^K_fh`yxVrQRB_(DQtVY%^xZHgS
zSTpw{a_h5s4!p&<PJ>i2;`wD>rJw_x`x?weQ3a8TntZPZycY{%%WX-Yy7t2Hnl0d|
zj=fX<zoNpWR4^=GLbn8cM-J?fE-5+1wQ#B}7gj!aeBt&h9&Q#1?XQeMZq=Xt|M%YV
z-o8Z&_bZnbJP91kUuqc7%oqy|iGL+=Pu9bDuoB8&;H5<v_D9ZH_=-6b(hvEh$j#d^
zW7n>RpVgyZAtl9zG#`ZUQ}OYVAoc;}#+Le6?iZt#TUM5q{BW#p2#P1Z;=h07?}1y4
z>X8an8l8v;3|<AK7kBSmaj~1k?HfE7Fqr+J*YtvchyrecU0gm6Mj$f=C=Y8zwyc@-
zqs`pJ-}dPg$je4E2mQ#uGN4_il#2rb1*pqS4A#yM1t7>R7Ho(f0a4n2>LMAfc!-1e
zKtaBW&G)3BU;`Qo0HAHax!IACQ!jGoF032J&R)yEQc&J*2T-+ut>t2Mw_|b~-NE+l
z#qA#6j7&_k=S}Kr^+RCyJVN1rhMLDR=wV1aPV8Ao8~~M*c!DSPdhR(<%B0sK>_kof
zD|SAAf_w>x8#8=%;hK{IRNLmj!o8h7*zWID?VV3_*xS1h@iB&2@-E*@h$RmVBNEE;
zp%rr_Fx$hvTcWo=uX^YHtN8fl%Xb!o^m~C$vhhFSE|HKHQ27jz6PmMVj7)%V@?tlO
z+R#)9eU`(Aw`9+H``{IQ2~^Lp@jHR~UsP1o8A@V+S?70i&L19>cXiEqecMc@egihd
zt{?)I|M~ND4=Qg6VyN|vmk68HIe>uh1(szekfeY-a(nS1M}(FC1k1wMO-&~Yu$Gmj
z99}wg{-~-i$VzYBi$4>@t0>eyw6qkU_5|Yvj)GNpG<A1+A-rteo_}W#BJUs<k+a6A
zs)d0fc6hnB7PP%8L63juEJeG`B>q|%C3Ntw>z<2jlCJyLm#vsJP=jg}FePOtHq#+B
zWSQ_hn#Y?JS#6X7XpSIT5hENLnmd><*e$q4gW-83$K18>8>b|mIL~gje?J#yv^uY$
zZAZSuD3;IB!T>2AY3JwHAfOl8%503!YkPqLK$4s=aSb$l4?ndBoT-|(Z$A#_6bAa~
zgyg*7eQ;ocvGG`__&b46wL)9`3ciFIBgE(ek^(amN>TDz+Fo-lmWSA^F`tKaavSmz
zx?db%M99Yf8Y4N{bnbE;IFOQh?A+wG+O4D8tUU7mpM^%(AYvH#1i&0y57eSJSw}MV
z_=G(;Ab-gE+4B<)O(0S92`yf{m<BB3^eqHV0mkP4rngTO{t9%elBCK9aRp|(L4Xuc
zifV(KfDG<Q!PwTx_&y^vVM>tXE;&I#5EfxQM|K=zNp^d!NX@YcBO;~|a*XfYR*zoz
zqg8(`9aWm;PE&aRY_g)ZCSzd`De(ng>UrM3w{PXfn_jWPY|r&m{BD{68mTQyQW=yZ
zu-&V}CcZ4+@QHn?ZO#~zkv6g8g}-vd@*0SA@CLYmXkLYVCh=5IkZ&y$TIN1AOu@T(
zciT(Wi!#jn7qW|X#UeK^LZihSvv)w|9V_)@cCrWvKpgS*zITN|%KcZA1FcD-#=t*+
zny0VT)xD0ZLO*aLOwn*71puq8mFyb+%!5{$vj$}o2N*~@A5sb=5tzAxSW%aCptd}4
z<}qI`^CIqf1{z}zOV7&<=jQJ}s&lA@fg=_`QPBCcFvb}#dCHX2kzue02I&1t8cgY7
zUpTv=zq}5BATm~YBthV~x9{Rq*mRpcToI=#LWHH(U)50*@eiOpSc{G%u`tkt%Iqu@
zLX42vaa=;TVbE>w`<Z$9qC3@eZx!=lo`@itGNO=uQV|K4v|16PLyFGdx%XFVK5~S;
ze`c5eXcqU}cUsQ0e*zKkGl)VudU_<$1t5=W>;)upJ2F^IO_9ho6{eVbBa!pM{6aCz
zqQmDitE;PL^?#a=A~j(HexxyPGH=XivT{lIuRtAjmFh6uG@Mg_N|~c^30CFyGNCkw
z{ItQ^#Ek|IlNNn3NVy`hxtVS5+_{Y{Eo5K~SZ=}g2b}x&%crgEDG<Oo&zg7nJ@s0V
z%A)~ekqUOh8x`Cx;3pc1V7Z9;=^HT30Fbvf_#zT({#gM8sgiXdaDr=~M!=zY1DL@G
zCJ${_+}v#cVPe%Sws#L!r0xpa5=1oNwa7k5t`C|D+UVdKog0|2{XV-||D;>D&0E$2
zTOC~kmQPW$IURxk47S7w2`;Xn!l6$Gs@+F4x>3Q6RFAwKx#RNPLAknbq)5amZ`sOI
zYq_7cr6inx8{xz2yHYRvVnV`9WyA2VX1niNm%NRTejp|ltaUp7^uf40${ZK07u=lu
z)Vy$Ja=nQ0j-3yhEUiDLe{{&MOaGab^eE|a&*!0ZHK*|D<)4StTF!4w*mQFm0=;^S
z5;GIy@X&WJA{@R)9RfgwR5+!ug{Qy%k2GduQ+i*5pCqj*Y9k$bv!`)mPOf)F99QPg
zX;n#FiHQcOSI=DVjLFPY9q#Z`Pr+btfcejWp~Kc!vr*rs&oOP-ebPj;=YnmoOD$pZ
zFE(Eqh6yGt{My*hA3g-glCNU~Tyiphz1?5WHW%Z7&VlUh2qIbZPbCWr3muH}mi6l6
z5HNLZl#SYsHXZ3>mM#qiKfN1t(sy#B*DIcQDFYM<w=bzh7_CG;So4$8#5^RTgBW#m
zQXJ<RC3D|2);cpoag#D5QE$l21npE{=Z^2)TKR`#6>U$<Pdb|K*ZBT$qpVlzhG6l;
zHQn=+`L|NugKMO~hy%>yyWTqBGcCdEWcuDj%i}r#91{^5jf<ZFtry{w3ABha2QL>r
zl(SrLz#M&?sl-aFu?XA%F(W7u!lp5CUu@dmDhOKN*rw3yrKMZR2C^$%7W#4WD2A`{
zTKE6hh=n6)o&IYZ2z9II>6M#>_{RdDL3Yd_h@=Reg#KXxd*>w}>&-@!&UvN@daFnJ
ze~3<=bYge_&v#3v>!MIocd5yo%h2ozfcfxufpQ1b(lI+%eoJfOMhEdg#Mng|an`|$
z<MgcM%2TbaAxG?8uO=z!%K7R;fx#okj^0OM3I}dDGl8(4hpd^}8h}n<pODredEZ6$
z-hS2$7p;<u9bfKF=HGKyT*olTDn&=T5~EzWGyq5oqFtn~HVkf#n2L(fq^PZRSS3wr
zo^SWXlP?u;109&nKo=^Zt{#myiL1m+1Ya<gC(x-I<@$k5NOJ5|^UI?n*9_^T1bzUf
zDN*2=`j$6$cU{pJacvK3N%_qM_=#}~j29Oi>n?woSjh&jG;`2f8A!7LxP9ty?Bc}@
zH*Pju3&iWYq%M->b~g=|y@4*f45d8qZ4L%91Vp{4-WP!`CGWxKDjdTqH9u}6^2?j$
zFm!cyKP@SNbFmK&sgVzl&}dR}UiqF+Uv-72XBOA_@t1!pd+4j3YHx!#pfNf40;4RO
zr53_7vEkzOh5~^Y54Sbzy!(IB!~I=Tm6j55ME&!bciHI?Gt)lKa2-0hY`|tq+GNkd
z?2I+R;{5z9;YQ8i<R~opR+ad&+`SB?`>C_sSrJ4M+iDg0(>rkaubH2*i?abw>{P8r
z$gYH4J_DU?`;#AAPQcU+Twm-ik_*-ztloi`*NIU?j)+irniCiWRR!bLAFI3$L05x}
zOt5Dva;F!l%s?mA1nP`=2{JRP`*oKxyI9;bl5%Zs-WUI7fllz$&76vf#h|`0&z6?<
zXHjnoZI6hUNlE}y(^+V)!|m>qq=?ro)FBZS9)Zh+4&y;98jQsqfBSOPZcfN5RFI31
zK^b@eKE{mszPV3MO%@TUeSCf2#&GG#qo8v}ps7Lh2tbO^14z%{%jhw6{r1T0Xy+^A
z#t0{yi{d)$DtJh-1bqJZ;mm+WC8AQEzM2(es{nhL&V`2dco$V1*$=8tQJu`;<J*&F
z3E4OnNsKKssXMxn$`=r3Cgko2w|&%du|v8cm$fly^_7)uKy8xJ^5WJ?lD-fPlc1=m
zGIXS#p<x2~!@|K+x?vLo)z}>zI-bq9?`u)S3=p5W-n!C;fQznGq@hQl{#l9UH%UuN
zJ42KAQN6zx?Ay<2JEal*4rw}}9p}Dx5VX9SmE%{V`51lGAD^oO2M0X}mPc^TyLl9)
zO!JzPr;fEoLlb0!73ApXNNFOm;!!wYV$C_opr#H#u`FeuwRAc^v%Wglfp>4|Jw3pC
zTBCGm>GkNl+xaGX>%MrA8|sLFvh4G%yPh4X$25+@UHM#iIEMy0hZvQq6r&XF_)IFM
z6Go{kW=~ED8hd4iClKhkt4$9tgrB|YU`KwfQ~C17O*y@t_N|eaLI<aeo^KR(@qu`o
zK{z{swNh9DuqZQl3iGwAcd+*L$+<82@pV51jxF*vv0^Rop^51%XH#rxZcYIsx2vlQ
zA%`4G@Tgz|LP3E6_yS}>%R$_bT+#~C!UnWI7%*@iYUGn=#&@4sF;>22OdKLfcf9(L
zR3`f+Wq#Z2<!OgYo}9v=Rb$jXkqa;<a?A~|ctL1b3m$Q!zV%B9csks<gKa+PAw!(F
zPGyfAt_zG)$tA;z3w~ITv;#>wLvcyTH8hHFS@;N_LoUxsN}4Wix0O2QCL(lJ`PUZJ
zu@|V*xDW~q<NzTTE)?u=snf=ra^;5?W38)&eb2?!B0k}E4-lrpU_VP{z3`$!yL=;d
zT3&QjS!6}la*v;z>{mbNY&w8D^PiL|bId>3VuB{#d;im-<ZbsqrM*+1X0sOLL8O-$
zAp<{7#N&nVHa>Xl`2Yx$8gf<6S5-8|FGqUDa9_EXBN*LID8y|uzADawHCl(X*?ZNr
zU)zdH012A48DO(r!TWXmeEZ=P_?v=83nwUDJe_(qYDay6{T8M&H>8GOG4SR@TN}kj
zxPMBF=}axE96Cqt+<bf!G;r|1<*2YnO$MDcQVWNKApNB&gXUo1FfVR}g;a&!M&u<t
zUnh-)C2=W_+mMbU38#LyZD!{xK)FJu%(2%&jXM`Ifk%}g-}en(-EEUc!Ss>Q(d9cw
z`i+w^zNP0y8(B(>>O#?=m2;6fzhECNt0!{DV#KcFoQ~=A8t#r3IbwrRM<6SS%E|^J
z=|-FS=i|V4pdcCVILHs77)Bya78WiAIT=aQYllD;m_1TtqSF-YsoCo4BUYtuXu8F8
zzOjlvz&9RG<$BNn8#ka@k5kkQWMKf0?9oiGZ+n+Tiq7Y-&ET5lUX0*Dk21zW3gkDO
z$6D-OhHh>ZH;p^OlDF|sTX;M~|H0N^ajC1WQzQM)cbBOIqW^$3LqkuGX*95om~}uo
zNZsqw@^5bSO1|IjmaAdmOsDe=9F8eRu^~FUN@UR?{SjHd6wo%&!e>u5L->P$q1)>5
zyAL>y+0O(#QF=SJml5Pa0r!Ka2x*Iu^$>a7^=l>O4MC|qQ;BJ5Ekomjm*<TpVtP{u
zb**452w8tF48Z&gpV(##!++DCUsQqr#-_V;@gLGGLj2D|bB>ajAqOspy6*1%4kA1g
znSftKAu>UY8q%bx57h^GfC4~5ky?PqSqk#F2&xN@&H~B|;n~`FIQtiv_|y6)Xk+bQ
zx<TJor}t?N7JF;q&K5pzY*qUtBEbm+-S;jGi<2IGoPn&78BroH{-{g6Ppml1OWk|m
z!y_7TC@k3j3Ua$3WNgSE2qps7xNwGf5v=~?7(X<b4|^;d@d(FT6${Rl;8!YQ2}Gym
zNNo|7G&s(L-X=;R$x^!*6qE}}%G1(Pt~vo!*m$RxF$oa7_J*qgGX1&9pwaJK>*@5(
z8CGG;S3RGBV!!~Z)pZ=FzmGk3Ey!g=jZNKXM0gV#Zy(`CEe@;d2==4%lTQGLT_@oB
zar(($(G0PCptBRhnh+Jz8UdA#@mf94C`2;<B=2Ot2`}TdnhNQ_(Y}?CllpXW;v{mI
z0j4F1bq;$=04yJx)P`}iK%DzAdQg?pSuB&*=8;C#cGSR~6<R!<RU7qR0QHNmy-!2D
zfNgstlh|auqX3-I16RiKnyHp*!@U*+;Q_cOgE;WotzS%%9W+6u)crAKzp-5H5-+tA
zF9)xS&BK@D)LR6UjVc7BSBaaao^{`zHW~AFYfS{zXR&bI8C~uL=@X@`!KKSns5Z$5
z-;Sg>=qxr4T0Ahg4gM}pqP|yIzi<dK=IjaG@hc?I>%%EY&5Tub7~`m@KemwB<wu5l
zvQazi21*3JaTq8ye#Qy=in!OT=kyJODV|$5r-BZ11Ket@@C2zAxOeX!l5Y1VuC_Pw
zg4S#G6svHX{>&~mhC%0Xyn{x&8Z0eg_=BMs%6?jX1c}mKOgEqr)b&}B@@31KSVab~
zb~`ibht5K{lfHdC`=9DdgkW$yNmfC>vhL!77-W^GroPqXMutJlF+=f0mC>a5zIED0
zj*g2dyufG(eBBuWKG)u>4KH(Tu6_TwB3oT`=-wIJV!?4%o11HtaZ<ZB9AjnJf)N_!
z%X?~*hZVrWXnX%y1&1wqG(&q6pwSKmH`Ea^9)^yk@I|tHIrjQu<?bBrvBkuS(W|OS
z5d{v&oow(D-*aaVj*1uB=Yn@7=twhQ;+Xl9lf0C?qO!m<LVl4Z{|-MF0~6W3*AQD%
z&5<;}2GWhXZ34s6I%hthJ^h=q-^1Od0F+A|RC|E)e*~)iLWJIh1A(&5JPuiqDb4bK
zUr#C+uY_qs7qkY_4UFfBfp`y3sd}f@y9X(5@>MrkOD^U<m3+6Qed2ZC{y3W%a4w*2
zu>;YQl}FQX3VL>-J6L2NPfSgvO~5ZSOFLfdD^5QWGgB)Q<v(hm$2*5U4^?H{p%Qo_
zWW)?n9$h*Z(rAafp(PY6M;ao>0)As+tjJ_`XwqqE2qr^^R6|2<L)k*;NWQ*>2~C7&
z`k4!Q6(IZ&_lkJ^$lNi#L0~u*)>tuddrFR152PP7NDQXhy1*Z?#0?D*Rm|LpIQ;Dq
zp!lm5t$dRvx<VsFytdFChc0uCt>WOkCqP8WF~csaPog#IunZvP5BFZ`aYQpMUVL2C
z@51~T_n&47iL1DT=0{$k{2T$1l44{HsN5YJ^`+HC+<%=2-RUd6$!y3y*+nPVXu))w
z@sAhR&O|K?#&t2SJ^}h9`uNlGWs{<r?%Zwsbkn?ZSHd=wsQs2!ZaUeuD7EzPS|LvW
zRpu0e2k&-l;f!uQL6vEG%50l&9}keBJ)F43{}9{QV-(j3T7bqL0xZp<1O|x_8}sw#
zSDg=;P?yfErF&t%mi3Joi9`l6`M|LQCc&d0mFq4mIa$7#q;O`IFsH(Wd5p=KSciC*
z`&q(&e=P5Od@K$r0`-wGuL3S$73F5xJM~;B>yiGPo5|?IrR-*l@XEr=G0@WkvE@(;
zq>@DW1Y69Is@Uk7)6+ZR)mJz#Ss%@Pd;2>i#YVRfe#W0p?3(i+Y9oGZP2I(eypzTr
zS8>Kio@HW8YnkTSsXcG!tjbDsDDdn%uJd03`y)0k4hrqLXzs2DF_gn=S4n98&uZ4>
zp+y$QRqoR*IDM=6eGC4}unbI`N)=*qG%-;PnKyC-ra#Iqro9z8g=?A3u%}3u0NP$E
ztmII}V66)+)r{9W7s=K0p2MZqoEELzzaK0IX*IcX(2e49$hW_*@sP*66mvNTu_s0O
zc|H~Q63<*<A62kn3OdM1&tbmTuWc@HPhZ`KTezXa968_^=pcS1|61GB2gtu`Fx3Rj
zAPf9M&0m0y01x_bTA>9fj@JQ(XBc@dKrp5w8MzW=9T@0K=y<_tG8YdX+;(#D1bo|)
zw|49)n}2y{01d)jRAx*R6+xM9-1NkoCvQ%m#;GZQ^h_Ll=t@yoJ%Xhl5-C!CgQXJp
z->5@y79x?kIr1**mg9U(#rDOiw+b>$JZ|P+3gC_;fd7u-h_)Y@SwR+PfDj-wdpw6Y
zh6;-$K2ZIxL30+RYzu%C?qspTvpzv{L?u|FywuVH0%G|dz`U5~Bc7gWD7FQwcew1p
zj+-+fDIGxIJlCq`!M<D#dN-O^G0iP!kHLn!Xbr=eAeY1maC@U!Cn=^kuyQ59s=bbG
zCNZbLgnB!EEr}=L=?qcn(fBBLe>~e1bVtH`-*p~<p~>xsnpnBvEMC3d^n{=uB0C(C
zlQ!fWgL_p>hvbD2K28NN=d7Z+K3C_D)#tGzyAZ1jv6;&N+heCmfRZq>bw!+=%NB4H
zt^ga2aIVw=3`IydnE<2wLuxLGH;h-#JxjG1rPNb!vQhdDw!-T{cuy$25%l!R^gT;)
zV>Eq~8qa`EY<?q4#Z1Q-2zG;k5lw&xf`zn!*Hn9bBs)^dV+`xVCN8bFvAE8Z0!IMS
zr6OWLx<Yd3*~-f4DcSp&lY3gDyw_eZ`?_se>r6_^ek?};YXCGb5C_a<6e%QI0V0##
z<3N-@9DhspRi1#;dk;9>;ox~gcgkTSgDRDdYXr;A*W2w<QCgBZ45{gmce&EYV0Syd
z7T82H%GmocV~f;Kw6{rQr1)B(+FGcMFRQr7Ko`rA%w$>a8?{_imS?!%SWvkt4qFxL
zj=q$7*jKeVAg$KKF9hT*UFiB_1KPgBefnvGj-wYpfi9jV3ZX~27?=>YQg(MIQhb_U
zhg4x7-X)HLt;c*Xc_v{&zV{kAg8Y*nFr*CaJuHz}$Z3!<Jo=oJv1a}Hd%0uRT4~n|
zuO16zY}74Pa{71<58IUac{nRZ;Rarxp}_9TbvMzFk@hUw+t?vA0EuKl0O{Dhc7;gf
z<{U%IFgc5T3@3;c!H&vK1X9}dgil}2s%$1g!P$W=kfopuj|HMmx`UVg4O=VGfJOxD
zLNW;i(*rA|H?qjYK9`w9S<pcUtQEwGOq)zv2DJ6*i*`*Mk32V%(xo%mfr6bCMtwBP
zm0`3#VxEnp5gl|mQ_uV-X}rA+u=48#y<Q`-u2bve%Qfn==$vnt6tt<dgC@}j*kK@i
z9D7tmGH{Z#gMNU}e;vWod?PtqfH$4lk;k!MOG<;vira7mj6^aJiena*0<8h?t{uHT
z4HQ!5D9Xli9%pz%PB&$~wVl=2lx_9doC6PY>ql%iUT0bi#W}=68aNrYV#W@HR;DP8
zU)^X>01q)xm8qxJg0{aWi??q7rURgzpyP4}2Y%DHKp5bm`lv<Diu6?Z%jZF)hOVCy
z<LRGe_6<1>A~$g$!yHx)^?Nt7=vZvxKMEt3@3js^!lYa~_{j(qXns@X%wgqw`zH8t
z=W;F0IWGnL6+5ZptDY@@5%{|zDQE(Q5T{#lYr4lzesIJ1B;TT7ij9717UIbdLCjnL
zs=I+b7k%Ar1e4~Z$G^6H%j_<@+R1&2=@5vCQAd7l9scz&I~AAQq;?1@4r&{~W4euF
z<=7MJ_n{M2cWK?koDhAr=`;M!px#1LYs9myPAKXy_tk3$ZW(FRiy+0)2SN=c&Q)Y>
zKI(~>NxWeWCJCgw_zCR%5f&=0(=Q@uV|a{xBGYN1rDy4Ff*$AhEs(@1;dT)EUEZj_
zT;W5tsHCJHSl(TzR#Lr2hAW0(0#OT3HPzwXCX8V%6TrYpy0#zcuCS<UuTB<0PE4j+
zc(_3F@_8T^s(CDw?tJXByr|-99JI5sdI)f+tu-NSH~=UPFT;UfD_+K>>{-|Gb|+{h
z7w;jz(HWTlC{J#uM<+8JMVnmCM(#(7h7}V7(5}E%mkPvLZq2-unL>!yHjIEKhj)dY
z{f%Sw`16_`<u&X^Juf;ua9Uu=y14SE9M~>bgINzIZgZbU+vTi~o{c(^{JY@Kb^>8H
zBqGA3Hv~=LCo8u+<o@&;)9o9ZLk<AztQ;ve3t^|BD`Ys0Q(#h^F*Y{v05s%wrS6Ol
zR3E;C?p8QeLf-;_-XpCbRcr7tqt^H}tw_%7Vn^%~N6nBu*dkkttpOwt?EYKRW8>kW
zkYX=-UYZsc@f69852_)!WQo93NM=x{rG+^#GF+Y&l)RsxW40-b#yJk`OEzNN!)Hhy
zubsV40N$ynRkTp&AWqu{on7SgaXlzjuC<-c=<<llW_B>4$a8>MJY84p$YR*E(Sd?2
zj(~r-VDlt19s17wt?EakUqy;&Y#b!(ikqbw;4h#A;|L;xBbOvmxXp%T?;SeKP|!<n
zKB2I`VX%AjS;_83NUMpD_M|o*#(g=pW!)`P4uIyM5_(91HdexnNurKcV8szUej4e4
z0^$Yp*pmv*qD%~g0MhMH+c33g7S4lT-+ZPmH0!oZYZKd&ReLQVmI-~V(as;Hf|L?I
zjO=$F%Be>E1xnK~RiW1vF|Y8<=rysOJjC{69r-098J{I!{R#Ga<mM3*7j2IwNhk8G
zF62=geucYO3afcs0+QHWJSQ-1JY-EF->f7Q;AqmOHJw$-ldbykv$`T_hg_9W@~j2h
zEm6tA=tPO!CCIi2=ONgcTb5|*hDfq%=`LC%cO*Rq$agGL!&%+_Xo9}OZPQPImBxT`
z)9u@%R+N<)0p05T4c<KDnTgRaTide2?XoUoQwf~;>Nt*nX;K$3DYI)W`UH8{LvV^R
zapkvfo&?tzbeR9Gnb<Mdj3kJZ+ae`Q^&D~^&24va2xzvJoeSqcj&o%N1@}Y-z(~WA
zJgOZG2tZsuVJNjZ(J|VW&@ONTkbqrgC(D^Yx9UPf2I?y=^XN_C7+*cRTH!rH698xj
z3E8F{qX62tNdpLB+hlarlV_>=KQjn1GV|pYeulgfBa>z#GA*1D6UQZV#j4yaK}zY3
z0Sb9TMsx;-Y+&7?j;L(kb_n?m%|-yJ*WN+T01JW2UZ6i5b=8m+q6V0$oTN9lUi_U2
zk4Jy&1LDh7h-Fo~pUbaY?e}89>F!-`l?My9P26;o#l`x@)|ZGwyUFGeM<$X1yrMOj
zc8Y{w#A~LiqwROowtA5$&$nm>iu2EQv8gQY!t0>bg1Q@d+|nu|4UCX{3JAUko&j1t
zx8a{O4x$R6ZA3eY_d9xW*KzQZn+GiiklIfeCrC*`Ps`yOCT;9nWu&ER$QXvy5Iu?c
z)QP#g`1;-xVNf4Dd4h6Ni}lj77o(RThfC0(frA_rtC)AliYx%8K!s9S(8o_WB)Ayz
z&ML?=fCF3r9{Fh5_ybvkykXQ$9vclSSsqRau;R;)KbonE1H;sVSK8=kO9|+QLi730
zp=`%Q`t4ZRuITRyF5bPSQU6oJ3a}d9yRph-EO4z0m9n^tn`6I}D>0M+MGgExQYyZp
zK1BZ|*#JFPfmY)m@PFtkQXgLAoPkwDu7r5N0^{+Rw*}c9I+7qY_qD<`=pxEnpXzYw
z35;odmKgo<EYxpL3HpR|IY`xC0CVJ?xr|7qm*vdSEs$0b!j!4%!&u(7!bUfC)75w~
zvxNWfhVPITipaiSb1N~b_+xqW_p%k)K}E9;pGGuRaXyTe<a%eJ?W3_yT$^Z2FA$K>
zrQ?rM31wxHbG7g2O+**&>6E>1t7vtA-a%ChO&dg}4ejrS-ql7QTeZrgI=V^>uCs$}
zuV7t+Vm5ZC&ibxYtJ6C5B-15i1{DwksqdRAJS`|tPM(y4(K!q-Kr6m%74>v(sL6*9
zW2;2!3#QJG0KB+Jj&-PzQXuq4F(7QJ%_+oUQKadi8XG$?@OrS(Y{0-p{Kh7^6i(p_
zK_<EWg^4UKb<E|e6C@)i?%QYo-fc8TGj2v`Ig3`Q)0;h^ofy-@U|*)xN-#Fq0?Y#O
zlWXnsxd<3x01%vtcm}BSW8U}$*%0K6nBEPin@V`-QlkbXX8z5Sjrol+erU?Mw(z%A
z<l+&D%gcwLJBYk~HIgS9`thQ7ssD>>-p2~3%sp;i`1<x}#7%x~7IHQuG;}puC|mCA
zW@A9j-bB#?MW~FPs1opgaDAH4RuEu_k32L(XsIp9d}Yp#g_b;6C><u;n9xaRc9z4`
zf+{D}uQjRE`{J7*Z>fRa*JkP2D9B-lABl9Fgd`Z&tWV{>*Dm}(vMIb$fmhX~Q};Bs
zUgO@nD;CQ;awf!p|LnX3r{VFKIL*!IY>|}$E|C#dEKA8ZMpm}GAZYYj47a?=aFGRX
zYd0D`CP3~Mz)5vbQ<qO-q89pkat8@xIa-Ib5p}d54k6euZ$s!Gg(tLTGXNAMfTevY
z&P7oQRVZh-wEfcJSxzITcU%&?f;<y0^r4U_Fr*+*BenVb&x@J4%>F1!>@Gmc20+)K
zm?@NskC-xA-94<ER-3x#!^+-#5t~~^M=9;cJPqWfwEtk#o{cizVGf!#Z{FB{e{5eQ
ztO#JBeW}r{vsXDLGLeZJQY>$@Z}pVh#o_N<dcoKfa~i4w)i7M}HsR7>cAhjLy%w?V
zAfo2c0Ez|sk%6ZN-Phdj{mlh<VYeSYU5hk}fhtgHbD)&Uz@#SHdD4|+nM7D<b@p(9
zQfov$K&53vKVD*ay}65tQRs(d5A*wS-%mwggu@ILu_V|BSX(bZk3n`F9}R*VSe7P-
z7p{+<#W{8x8*Ps3l4TBly49OUjT++UG!bi{yu6i`3?*Es{y+Ap^<Y_lM1mU!^&(Eh
zg<{oKz!6n{RA@1v>E?^;Cbw=kpQ(#bz!KjP(lDk9>;o#@obQDvj|Gs#y~=Q6ra+9P
z3kQDM-vHC`GM-0^sJcr_vaULF+&rJ&1sFeR{hw~4aj^#s0M1#eV?++jDiS#|apCs7
z4+R~iiR^ed{a>dBEO{bduBwInjoJ>AYabD;jH;AE#~Pft#l^+FWlr+)@>(j*E3I9d
zANRbsfC*pBJHX(IRYog8hwg%_N>kdLcEpnA@uicv2F8%HfhB^0PU9fJYC+m^{^GRS
zM4U$7vg>g!=lo5H(4JFuK8VqH2S3Q~dna=)oncLHZz`{d4YKQ5^j1(af{rv>kQ<G7
zF5$ZuLqm%IjidoR&FUV+C5X_>J)qBvmS{elHVf09DJYWjHflikJyXpEOzauy$Fv^$
z!HN%C+(dBf(eg_{)k-Kbu)q!2#f0O4Xu)r)jlwWeCI7`W`*#QA9Ag2-RA4($js!HA
zL}6oSu%lx`*nZHy8^7E&Z`7Q({k0`Nmp}NVn!hbJ8Fcf0(1c@1l`bj*Jdjub7(_Y(
zJ-Qn}1^ovQD9~)6@#>hw^ff$shf~7VyAmS+rm6datmRCa!Zx%5a5PN30-*zq8VC0A
zZvM5C@W+osLTmFrbNW#n${{fQN&CI_r$7UVIfWc3jUx`d-FFKeRkRyrGyPqgxYn#c
zq2<@$D`fU;YVXI=JHdMYfdUH&ZBGkfp9q-SseHxtwNP<IIGrW1TY4q$V~dx_HcC<V
zGAu)2$AGr!a0e$R1{!lpMvAn*U+SrF9YxtCp&vEVeHf-nxTRsfev=^dU^|fD_}cQo
zSj}MLB~a9!I25t!!43{L`Oh6VQ(_BhC7=$tygz|rF(2vgw+u`tk*li8Sh_yS2I;Q`
z;=CAE8={HK;~$2YZojn`X8(u3bNPm?4fQqNsX!ecqlqiOoYe(ob`b&Ys2QEgl>9(%
zII~etspYUp#=*~<KUF7}BgsIRaO&;I=K%$%320FZ3g5=#95N6V)#F9r?3#us%|O~y
zVjsqw3(eC4d`=8NhP1wq;coapcT62$TVYtUh_MAQ8-0R<@j2O*;cG-pwLN-8m)LQG
zTNNrJ=Oi)JC&y>1D3LsHoa4ZuEslH}HW4PheBn#jSh!E5r6EN-u$`)}v3o(UwDH~Z
z*H~d*a#a&?7`HmWFKI%@i`61z#7HMQdE_u4$B#NWI3YjPYEwPBUA|#?6{#7D%aN+a
zRNopq^L}hE0owryY$mW38e~vaRn@_vaNr%w!tE?tx`0RIEd{NE*$t4||AmK};Iz4G
zncI+?8~FzL>u5sFJ0&$Y4$@<$3M4!-kh?~E400{4ojfBME*ro?8A(P+Tq%do@+c7>
zKs%a4&j!8n%o%xrY)eT3I@u$%1gY-tCpq*HP$SyO4L$;<4Y475Vjx`*?cSJI<&efM
zu`h3#Z*R-ZbThaUTZ(-O2ou(iGjOU}U<cq~f)$27#^)sOK@Y*@Gx~qs2N6(5d(9J;
zaD2!U9Bq(tl$E;=;@xZE2tR7pCW*lolfLbq3VRKQ&rV;0_PEp?6o3mrhxMe5#52%p
z0%713s_L|P_$d7CFP+H5NS_9dAOYl<MbdDmM1~_-3^lE97=&%+`FMjyQsMLYuK?j#
z45$TTGca@f(2JTE2mYm{oXp`<#V6+Na26N9dDc4A#_K%t^_|F7EC!v~lV>X`UIaEM
z^WpU#9F?%2n}(5wYwcg^E_IuGA{D~l2o#!3=fFn6h5YmQEU^k^Ax5tR>I+?7EKWE;
z0Pi2?HnpNnDU&|Q(6Aw#k5Qce^ncPqTJ`qU&&uj&2b?oTR59e8`gO`+G<8SQ-T|zY
zonfUSkb+z>Ok*~K2Kv}ycM3m{6Ix6sE(7PH%ZBl#b`#KtAmQpj3CIS@#G!y6mx5kk
z#-YD@fr$)%lR&DkcKUW58MvYw-oSglG(7*_zR6$JFH^A99zK8QG@^ru%Yd(t?a8zm
z=$5)7;n#Wyw<^1)IT}dRm3~%jWTaLHC?JRaxfXY{S<%3BZrhTGeAmyIarIe*la7z!
z1{sRL9}4`D<!PW&y9!-6?7kO4;)l6_hND=GUZh#cw1n*fAIp4#=Thcr$h#+{T@dsa
zwlm;u3VLRr9O0x*igz-x0XSeBP8dZsCIWDA{`lI82$`Y)rPag!7E8UaJ9=b2Ks1ox
zR1pO^lbIIFqtSSOe~kM<;0Z7FA0kP43n4KccPlCs9K_xZO@$!2c6D7bmIZJGgho4{
z_PQ=g>yz>|&ZqIGqBs3>(j1JI|6mQ5RLi{{m`*U|>+2i5*N~9JbV5W~Tv~c?{COBP
zAOS2vMg!oP6D2QB`B|u`!6N_4KHr$dn`^$YCb+hEB;Yg5LHS3;3IK5k+_o(lUjE_N
zI~Wr;e6s<8_;%RnN%3L*{h3Wb3t}7qq0dRm0_g|YfaXJlTg#VoiqYsNQX_K?=y+Q*
z4&4qA8+{zHObVDs45(5MV7M#d=_7DO@^2oEnA!GvVcNQNEzfezv`WM1Lg?)NRCNl-
zJdO6DLB&t6+E;CNT)h4gLuaR)ml|4ybS3N)Si;YCmZ^Mapy(r$)^PmfO*_;XF*_1H
zdot?Dog#deIp#NLHh~VDHhXMOOUwNyZxMW+c%ICDD0&&zT@<uA$3D2Y<Qjxh)SE(r
z2`E?$|IGlATb1CTOM;iwgl8-z+K-NTp4rQ#)NIKf{wd4gIWkbcdiNRFkno(z|MvXw
z(1N002XR$0C&$;t6GZoR=)fk|-fsu_j4hcuiE<1mq|uoj?^5!osC-NFrWyoBj8IGe
zW?-;zbDkX;c4@0Dpqkz%XiMnqz36*2fBeX_ve{Ob0X#*{Gs$Tm*u!TXgE7}y6O)-Z
zZ%0RM@65{Fn<=zv>>-%%N8SmA<cYr+iW&?oJlx-E4AYk^*uuayqh?Fu(KCP@0UGh4
zQHXW5EPLLUlMl=%{P@E5=uz&qw!E(cK!Jlf6_3nUP*7Ns1X|9MS1uqLQQO|^B@Fw&
zDBk2vgd7|xjt|y2n&&tOF8p2-e83s_K?0nvU_F%*x%}j#2&f-co($yqR$F=NvhD@;
z8l=?VuM&S4qZToRAOsnFkqGiH;8f78<omrNd|YmKO1luTBF@a|oR?1SsFd;&8Q|H)
zh5KL5F@kprMG6LlGi9p?2jAb9u=5s>U=#Qcp}Q|OD537LOtov$lY-n^TO0I#86Lw_
zntz$d+KmYhcVx_7#QW<Tmv6X)-aR^T%%7R@b>OT!7Zt^wgVJ0FjEOl(g@mCl$!ZQ>
zCwAijDjsmz3WV%3bCHYed!MO9987@V1zkVkDPRY)jfpv+5v|8G3xP*t%fvrA)dIEh
z?9mpcpzS%MD}QI#V@1Hhj@jaKbANrcf3v5fa^2+5>VC8=Zte|bFvTrZqyZG*-P-i9
zsDcsh(&}Q?&&tc=f#Xq`f-a9dh-T;oXo46A-p&FdYUQ@V+cgxR{8`eC0IWax>1XQD
zk)Ar2$2nuDq0u0=q04(Vs#T?bv^9pUVTJ|#0m`<KL|5QzP&opPN0nHr&{3uWXNiv9
zr;GOx%hym)zGh{|r3ZEj0Ttb^)QMo*>ykaNqo$fjVAy7b*c+&FhRTXippeuM?kV*H
zg9LA)wGe{QB`6TYZd9WsjF8K86kwqPytQN<M`MgQzX*h62Oh34G6E2zKA5Wz#9l*G
z2q;kCTq%l#61fTm*X|eu*9V+8jE>z~l3?_d(t95zZ{5NAMF)VP-9zhFY(F_*Yc-*g
z^EtQ>L9+!HDvbK6|3wk>7_bP^ShcFqp+^MxE^zt@2tgN4a@;L=^2Gl2Rx6*^4K?q_
zJ7~NIe%YjT7MkTWzF6J(F?<JK;!!Y@{-#h!q|(|F)oN%7ZHx_>J(n5w0~A_#bIkZ?
zVNG<|uZ-kwPFLvZ-+aLh_`;MV8VCafd?0NAVHL8`InvUf(gyC{y_@Y6*Mr7tad|oG
zycye@hS>qwYFc>X9HB=gJq@ze{mDL=s)Fb;av#)<Wx5EaC(cx|*2U}<GmJtwFU7w4
z@tIj%fRIj2A$If&ZNi46GzD##$itTqB=EV!?qpeLX<$zky5y-hlF2jNV8xs>(8nX}
z6!ccSH>#9qoC~J>IJYeVQlhyx0&f#N5C(#AQ4IzbM@2gnPOpFGHTEv0#IBDMNPFse
z@_ipk7%~E8AXYUrvQ#?2<_c!?AkNqna`wKAo~=A1PTy|~FEX6CsAeM3DnM&RQ&V8&
z?jx|&;sSkAcDf|>++%Rao*}b0Y9>1bK5Fz8qG}oTQWKAx#{p1ev<F2XC_H>1vYdb4
z*{|KHLlo%nSF9}kV8tW(nakN9*0Ic4oi0(C{5R{PvPqA7-jaXe8g8IP6rm<rq$CQ$
zHqUFX38+aaNloB@PPhW@3j$C-tH^ekR1vGU;wvc-7!V9c7$_}7by3dyuA3TZOWwmi
zUSPb}BKA_qP9x(Gf?%z^R>wSP9cEi#(RiM|fJzB|0xJu<@PElCV&`(>cFo52S|T&W
zYR8BsOoKSjh<J3YxO&ZNutf!4eL(n`bEpl1ERT>i1|V~Dz;N7k*z?N<kNVfZzUWzK
zpGV*D*Vo1hQNX|w`o0PCs<oxfkaIVq2A&K21YmUqw(A(;f_U942gK#{j6Kw66*IcE
zZgL;0S*<2yx+e|@kJj=7@9JwX`-(DT$RvPq=7C^AW4x|q^%Y3qBXJb1b}r9e?#lx!
z=91q%;GmX#p2lbMse@U`9OcGx^@vEaQ3dH#;028x(2AZ<6LO~cgF0X9glZEH^w`2?
zHR{M~16+#XMEM#c&gSOk!JYZ}9-&uNhKp|RMm}4NuVw&&inRfZl8@&%>YZwf5)m?!
zALs7Gp1gww;PaHjE?`btusrFHw@thPG2N+g+BlNA>7(fPZ<5I*nMV_`>Et}M9^(Ez
z!|cqZSkUg%Y=YC@u1y2X0wx`i1H(V!)wMn9ihSR!?Ohj1PZ^J@;H>buOOrAVLEQ!;
zl9_i8KZ-q0;}|d|q8vyFkuR{CadR!rISSP|pOf?7SZS?gKfjPD`oUrmc;5{*7EjME
zznHXa+1Gn7&t_l~?gKMnO6Nh5jCC7zMpEXCepBokx*hTs;u1oMh#r89AtN}kBG3mD
zwv2O%nxj`a1`>)i7;MwoAlTWc?^6)am_0l!i#1-n8*6;t!RN9)aKS3L0dphup|p31
zcJrnkw6e7Hv>O@kJf+-ov4c#BNBu;AjAQ(?cH`jxVajSZmEHwqs(d-?^>z8jnE^jj
z@JYNRhqo0mDsBK*(tp#}5#eSuZH-bB4imrI0sZ~Qlg1w0)U2%G8IY2ehR2vLN3_>d
zdvh>|eG8x&^n-R`QPa#u^bts;4u)B*PDk4{qEloth3>SaN9P|@v&-0F^X85^)P%@q
z5!vAo^J1<s5Z)zfiXDbC!Fd*laX@tm-udR#gn=5hXmIL1<Hu?MLsw<TiOSALm)4(n
zdml_|k2%plZc@h&l_@tulQ;@qpwu{!EK85)dW%Z4M|sY8`(U(?Em+_ACRJ+kQIxn=
zNyax>LQSTq1`c%=&B^)!`H){>5z7&OZ?HN}6jqx!>82*)t3`xt#%qtfRhE`=Rrd}p
zgq9ANet&yXz>oQY=>0Sm1xkXgiU8+;S_-_!|E-`43_95qg_pC#6TNPrTt)W7x@189
zdoyZqx~ITkcGt^acxFC@P)N!s9`qu(!~p>2klvW&E4Cvzl50ms-m?pU&pSpGtkYx=
zAwdKKvIdz$J`kgQP!f!bHk4f1i;gndmoFy}Ht~|QT5epgD@KKX%O2?+*nV%`v=;O(
z-$0`f6T0RhuDT*^&EVo+LYU)B!|Y<-`5YR2pX=@EcVYC6SB}U~XUtnW;EH2QL#I=g
zn|}W$GM)IFe5&H2Iq<9Fm2t&mmD3`lEK>i}wq2XPG7Dg6*N97ohg*Vi@|N?aIP5E2
zfzlUT{Rn5skdTlG8pz{Mot2p-+XG+<G@xS*i%x)VHF6-!-gH)GpM<!i*5}t9jeh@L
zkc2D`oL`K0g0W-vbjm#T)w^_f_d?Z9g&t5e8f5Yhc_AE18CC#DFXL7?-y1Ep3U>wU
zD44%lWBq!2j{^RJkE|a!WYUhJnrG?&8(JVBj2zf2(v}Gq{X)$3DJ11(@<73%FO!BH
z_I2*Un&%dVIKlVclC<V2+4*?J*yru7921YP)_dG57U68zVYmM0=L~v9|CPgCzFd*W
z2Q25{=e*iSgu~ziq(Ax_r(j{Wlz4ydKW6qe`%+r(hXAc63vbyV8`L5(4gmH2b(0B~
zs^|r;Ub;p<Dg=(S!#gjv5A_6&q*3phE@WuRF$T_AoFS50?Um@xF4^0Vz9#$l|LVnv
zt^fyR>ek(!q3Yi?#-a!oQ>{6Ffmuiq8`B`3d*<>PwS_;n*9+M6H}lnGPS;an1_JWz
zd|#u;o$R_kDNYmYRba`ypzlH<vkd1N5-9)Pon=`E;eRU-9^j4>v*_p0i6iw%>+6dQ
zLVk?A$>{D#C~+ET`u>#Z#15te!PsY4t7<MvTl4LjT(WD$ij@YZx6d7%xMH6}%vY(o
zzan09tqnZ7@X12M^UF7D%83OCp4C)JouRPyhW(Vpqw@}**u6MgJ#JN^e?rds;GWOv
zX<c;^PUTMJ_CXzeYJsCGxIfObljG8&IjSlpSGDaMea@b8<^=W654H4Nup@!6mBD)N
zR6xM-5$W`=4?3*W7xA*QUpaD^AVkdY{itk{JG<6PJ;HHqFKfdJ?<?yB(msaiC+~Yd
zQ!QhCb>SJfoS}mQ+BIyU{J0wv^+tBs+V--3>FeHKdXAc@Kz}A2B?1bVdXMz7Qv>|{
z6Oxixh~xhK$oIoPKTJ3RmXWD@`}MFP(D3bk^}R`9l+b0b=dX^LaC+wS;RPOB6B75V
zbN#hdYdqQP@AvE$O6xH_8R*B%am8+D(Mn|&>G|_<JWkTq)}~S)c~?bqiS0MFC<)!;
z?Jq?|84(E658bB}_{N4FOPjaZ>ND575BGI=db5CHfz{vf>1K4<ovOQ%PX^~#|LiKU
z?<{Ei8Ls~MT42Mo`T2J%Oq@6LZrQ{?_{FNRqv+Sy`__9wSO#p)Xa)o^wz~0pFY3<y
z4}b+cckezn9F57{aPQ~Q06%>h#MfuP9NYfT*IQ@Z#S`Cs-`xLP9DQ$3Nry$cOOKt=
z*y=s99JNNBi=UU>z!N?>v!fPb!sr7+ZoA6Bz<}^2Bp&f-5eLbF16TZveMA@nve-D%
z^N9;zwJohN+QDUP(z%Z&9l`!)p474E5mk=`f}A6L;#GH@Bu(6<zPuCg9L(lmLDitX
zyr*ho%050=F;<&yzv<hGq$KH0SxL#wmv&z$V^pC2P0~`4w(?&;?+y*;_58H5+N0dJ
zJ8ihXW5I6Uu+ile?5v88SJtT|5-hX4X8LkDt&g>6MkIkyj_h1J0cc^Cd3>?J{oQOH
zT>}H^!@Mj!52(uRk4WdY2~+03xRAq+m8o%GK!!8hcb@5vZTEqCWe<0SMweweLv+4%
zKV~$Pltvyo)Z6>c&M(l|IN#1oNKMh&Xj!dMz>lx*LII~TKz+ah?cL`uLWcp417ih9
zBdFxK`*EKJYyw{@yaNu~9s^GdpNN@)%1bi!`X06Vem{YgrWunw^3UD;&|N;ftk!*h
zZ%>-MB~qVd5|xV<!(pFlTEax9Ew}>iLXfO=opRcz8y(Wq!I)h5um;(<_>mZmc|UZg
zaBbLIEwg4VdwJ$mK0Z^wp}Tjd=tgr}6rOk(uD~HH|IkbQo;CllU$?MJ&XJxY!-u1e
zD4xHNduC~#zULIvFpM`>wBs(Hw5fz{?D%mehFQp?3q2M~9ISx(^Ln%pK9%~>oC!%K
zrRhhJ3*Q-f+_U$5G*4fj!Inwaudn|8G;FD#`q0z+Wn+oakDs@<@<o|v-(dfiEn=Hp
zw<zdr5VSpuJ$mgmV<!J*E;k3fO<R=NT>I-QhGWQE5kXM=NMf3D_gcJFU=wz%-qAZH
zYzzE5W|U4g^_5XnoT<mo5_904zSXY&ThkUc2xL#v_X!K_*(WDH=h|l9FyKD3O!#cv
zQO$jFPDxbr2~%sgnt6`#wC$VVRS@M{m8ZJhsmn0$wI5*_KWeL8x}G)~y!`HIm7t^S
z3;*o`+@}7)g9@PjXgHq;dth_y{p0+YIK~Ni@(*ao_-$~pwE0vA+c{3w3oupk=4m*=
zm)CmZX8t<6ueH<Pdo?f$s;gx_wimr;E6lBOBxqzn9a6Fii{!^FBVp6yAM}9~vaGK;
zgcxcJu$Dl<Io)%L^`lRptf?Azb5qhic44GbBqHO8%Jay9_JQHO%AG5hwTrWwjvhBU
zJ9j!Ru65=!aSpN&6`lhxeh@Axk0yyO(vmqltG?AWjs(DMc-i;N4z70HFrsFN3vaGt
zQ;c+;VpBK6G-SEbbkie0UpgU4jNT#dKID!urR5#Y!+kr49;2rtyPdW1^G^4~%{;G&
zX91Q9LoXU+WvHZv#H$<$c?45<Is@Xu^~}r&G{ifey1YNuQqp+Ys^L*<!_Jroc3+b+
z8ln!*^q_}^zy4w^EiFi5KwE-u2l-QRLz*455UiTEdiBAKPi2uYDU;vcOQm4hzjo2V
zj~BkY7apD=G|-n)>CYc+yYv8id?btdpy-dUhj)txUR<bNm(?D(P2C7MtHQfLz+H#c
zx8~{Je+^2N^#c&J3iY*gfs=v3=j*L2;wi|zw9fr=tCiS5`nSgd66@_d#@4F1)LJSE
zfFo_(ym=MIgu6i&Ge^YwMw0L8)Ak5!86DpfxD;>??UP<bn!QYn_s!nCX@y~Be3ADG
zaA)lsq!g#Y+^?@S--UIFjo@(irYTeMb_yvBMSL{+%>_UM+<M61C!j;izDGzoyI{=F
zr;|_sGACEm;crR|pdvj&hc0{YL*bdmB6VMcEX4!Iy#^-?54Lt}`?$JmYp;v%Z!L<H
zw2_e!jfGjeb}c|fOPFLW8I;KGS^gIOLVew!nHHA}{90N^$*5_fN^YD}ITvdv6Qk?M
zP)F*swLoz?DxGp?pU`aF^C`+>vBz-by1*}oy%t}4alzPkq;W?HkRibB+wTGc9*KgI
zRGsU7l^sq$wXGYv;BMZcQr}k=q~5#t`N!R9<L@_EOj?jLI4Ed^xw$B0R10>bpT8Kr
z<BXW$w@0jTdOj>%W{sM?xjY1)1!rB<XbV}n@<7kSY@g68H<P%_Z#kDNJQvMlm&vOp
z!pEmpeOm~0zGclnYMmP2?B}*Zq5DdD=4to-eQ96rC@(UhUMY&dm|M3vkFw5kC6evH
zsf0aP(wk83uEO?37Zp`S1;F=f-KF)ea|WkBEBAx-@7)ODvL~m`UD&g6>?9FyUnYdX
zGw3K#(*RBI3ee7r1r)6GT-nk!W@p|hykI;Qm<}A=Ul^x8GX2AchNeLCu4a3=YuX&H
zz2+!II}U1VBZySQ>=d?U0%$bTy1!ZJ(@E$WI&bbAx?wqjS4@uFo?_OQX;jFL9b7qJ
zmAL)T)Mcn2vUT-uXelu-;w~<QAbYs$O~kh>Aw2Bxv5tedPSFNX{pboIXhD_THc8?3
z7GBd0bEdM7c%2!|LXT)2v?`3#$IMiCShcjEz?1V>cF&e;;8*UoK;Lqg&p2&`xK|vx
z@ZuW4*gQsXpg&g`Y}&lJ^8S9~VN9Q4um?2S{dwoeTYc??8@6m&1DidPjJANBq~fWb
z;(16hUSQ{m39M?%Tc3~TL&44_aFYo^#cN};0Qvz7wA64&!KUgBA9$&3d<{L>4@VE(
z!cV3t?R!<eE~&Z41~KgM<H|i<z;;UU;T#$SzhRz(5<=qF!{=`%B}u?+7B7Jb%&es-
zWdm2mU3z@Dv9Hzq%^mxSechJ%|9t;xgcO>}aO1`eR}2(_Vd47b0QXkmH9E&`Z_i&E
zMXo3QM2PJ7-8J)geody*Olzh!`pF@(#BKd}>uwp78L&e5kG##QW_lT~pUei1N5#?l
zm5yv_ak}Q9Z9lgRSIqsKtOaqY^@THIp)5Go!VF0^r;y_58#kmS^dba>W8!$!j;@no
z^9ytT$)0@GJb`vaeXzWua2ZG~Pw(B9&1BfO?_k#+=vFU6WO?J}O-AC~3o6=N8VWQ-
zn)LxmizP~b2ve3w-N_xVEp#d!Hg4Ot7Gf>bHBE8hwqlrq(WU*ho=0FOCn#L45qw#l
z_n}5cEQ_@(ogU5|pD=Im{+@N{A}J3nhWjn`{rCSWIz2rf43RHhQ`vnq2eU_dMyxe;
z>j&QV^cKi^Hs*};G!2(`fCUkPP)GxhL7Xp-29i@OuxTrsu?a7?LZqj1bIWw%zf^9p
zNNKm%Q<^*Y^Wyf|YFT>ORm7VIP$GPkN3HkhJKK!XVaz$XYq`O|fI$QO8`2eU%~)b@
zHoor?&%V2B#RI_93M-qKYRC^Dh!A*lRZ~<@Y0AZg-mh<qs*C8Uz93Y)J;6aLJ-O@s
z;b@kKPiep$IshzQ(tkgNXdO_BX0cvfsiVUNkX#L3>nvta77Rj;>+<in-Mn>cH;9k$
z@2p7ND9O&j0pHXE%^Vq@WzxQ@?X4Az^2*Xn_Jrsmwiu=hTD8tEbyd5H=P(fQ2~uV!
z;0!8qyuZL;Z~&~gVcRzL(Jsk`4ZNT=I@<rfD{c-SP2v;+hy!RSL?$HEao$;@#gp6i
zqLE(~%AL0A^09kzl2R5XQc45}9}L840|BQKJtrkOUZWj5N+Czy$Y*U0Sq`j5ml9KC
z^zY9cs0xXiPE<jNf6tsXc$w)YXURE{NzN&5G#&`cvxGa-2=j3^F9RZf4;3n4>D$|j
zHKW-muC6X}6bkD(fvTF0j&~-EL1*GR2WtVoUIO0?j5$bFjzU7Mos|I6fBNSu=`#?_
zZPRjB(Hpt6s3x`?Q+y`qFaJ3esu~6&Xu#yeaL10X4KuCieS@T*^d=ha5{Pxz|M&*f
ze$x?j5u?#kf}D-7@2Y=5V^>LI4kK{<Z<#O0zJUFNX3V+#E3!nP4Fb~r>PtP;7Kk}~
zd=|65xn2VO3f&Y*K~5$*3xVo2_m1}}422(pg$BuY5r9R~D+{W7dNc<}%le(4I&Z#r
zj8@}Q$=rHl{B%27IkEXb-llr>zl^s21=*`52(EA&v9~`PLmD`As>2Lk5<w4u738v)
zz5jVsTO1q~p|eBML}CC#s*IAuf)x&t;dYwt%Blkkme}ki1kU;Sbel?ZA5Bpl2?fz3
zgRNl}$XW)GQYqFtp9XdEq<OyYhE1E8b3oBMLOKl)1BGXfzwjIRC^ATzeCyU}{M;f8
z_9!m@uyX_B<HK6!q8Q4{A)CV{IhN!Jl=0rkhmwViVL`=6`d9<0qaXrfsg0(xJ53~o
zq<#~hwK7qovOFIB1~GJQG?8MQT4?j<UjsfyqLv^Y1!nJaLD>0o=jK*kAFaNeO>is5
z**d#+xi$x_1`97iiKc;hc7;Tzpx?yWHg6Jk0Q#o8ckhNBIa|(js|XlvGU6mYbo8HH
zax)=;`WNTVpQm{eXo2h#<XZQ*?vN08>8DO1WPE)`;#hHEV=UyANRHfoyjVS5&BL`c
z74-=^$!<8Wgs<53P54X}0Vmk_dUx+BCPf7ROovJxNu_a-La>n^v-b*^rp#NgKpc%T
zP$%I@R8lOUxNizHxNK}4KVDYczgbE#%>h14s~3#9pn%Ta1KThLSAZ(;Cmy9{9L+jL
z^coVM0mFMW^YhDi9v>f{-$ki-;w&1%i1SPgsRS<b?dtqnYwlXE*gWk?VcwTF=fbS1
zWiXW&9PRrk7Qdx`mLXOE%qTnB)9Ya=BqqqIyk>P9_Vji1dC;=Q>jV1&Y%j8V;XXJ1
z_+B|c_C^{8Y;aWn?K8OUia~ODZMEOSk>1sUsx`EIq;@gI=)cYi&Wa<gA_W$xSgL1c
zG#uwB26G;y5$=l61iS`>N-~O4SXYixViBBsh-u3(zVr;2pF`6NA~vu9i9ehBV)E>5
z54qic9zQaWx9-Kz$EAdL>VRFMQ~zvasD8u&4F9{Jl80G<vktzA6e5DM#)u{Q^d_Jw
zQ9md_2~kmn?6p8YYx(1wz?(#?FX6_G58#OH#tKF@(Nx$G?DX!TmZik=h<&4v&p}2z
z-j4LWEyTCV9{!xYx8e#T10L9(=Heh~tf6Q9as|d!c4(2P3P0t#CSf0ZQpwii-<K7&
z1+%&UVP3m&!ylZdRjU*Bl}u}^Q<-T!Lyp1nc?xAN{_JHnvDZE#PicC)Ke+{yWe=C8
zqA}%(SmB5j=!8o1b;hE^Teq5VFtn%-H>smLf4H<0!N?wpKpN&$KQ2HBHqt+T@giu@
z&u|c@wa0}QmzACM*Z`WHyD~Vr5iYZCZDAa*)wG$tb(L?B*M(<a$<D5NJlTofxnWHU
zx7}+n&hF<Ykp$A)TLKoTkmu4u0xQ<FxD&QC9iRuof2H|1MI!jqDO$9syvSC7#BlJS
zLAV~TyhJX_`u$mX`Om<HTb~J*E)4?&C@kVQNY5I$>>ix6<Q-7<_?wwrF~$_r+)K1^
zyF^=+UA{dB0k;GO2H%9n^?AXcg3xY2*H;f`B*tM`0kB$f>c_1$uU^@|+64Lw{M(?;
z@#Cg`h|Y!rFyj;PechlMMSxfE^;{F3Z^+XuF>?phi|cxW2K{gg!@$4Y?;&E;DvPww
zV<Q_esP>ZHKi@oF&groKA4mPbn{u;HMv!o9PWBZU%%LM#>JzkLi;OpIDj>BtGMG0g
zA4FRbZ>Fod$}O$6pMcrL5^8E$n;$>G^X`B~&1dy2w-e~s3p*yk!MqkDZwKLZP5h}W
z-rwOZitYbM0+#pW$a*qz&CoENHP~A;cH>Y)o(+dmnWR<@IHot6m<&GZmW;4xB2FR1
zB(b11ZV+;GM<lwe?xm&==47j-6%!F~)rZ>kNu<87Iw|tZcxN}(-I|6JU0w{s_OMh4
zlyOVb`mVwz=QQV}i4BSI_)PM13ch+VS3=kYSRX<aXt2-0QtP|=&<xDI>2PL+b*PDJ
zqmT2+hV=Jj6@x%WD%L?5&kyCv@eyyW?@hU9A@;^P07N$Teg`KD2sL3dXDbS*l>pIr
z{b-zuyO>QJ*=DLv^6H&%TF7d2BfsKQl)||m;D${^XE~DK{>snP4aAnE0%RF!qiY|@
zBa$rt^m8VB8u4$iHDodM=+q{g9jcy@NoRNTgC@C{2yi?idN{(MU{~CPMMZx<J^D}J
zDTNUx6^{>_=S}P#`abqJqH-m)eGKM3!SkZaA$#{*x4z65al&x|XBsOK-yxUlEpy2t
z$5GN&o#4}(4Mq=kJGoB5E<6JuGx<w;^fvm@Kj$x8K&rT{+Y0p&c5uF$9scFfmpdhb
zXeJ_G0P)iIw<S;T#2ipZNZg1l4LQp!GrY$j*-w!!AW}TA^=ZsE|MjKA&>44Scph0x
z0w22%4Fq*VYAUs0L2OFOIc&4lx1wNvRJOdw1TIM{;6VV}n$&fr<MBLLEj}&n5(*F+
zP=$``Wwj&j%>n%l6V~YZJgoOMeLP!TWX6(F&c+RXyq`}vJgKS%<v*Xy36Suhp~j61
zT=uD)Ur1;j*mg=yr{&>vNHanpuZTv>eK%?R>ncN~Wo5}4^Uj^cpnevD=V!fn>d8w(
z1C1X7Ftw&3!pZEFG*m{k853V4@!po0p5E_NQhXsav>SelWcf<-4jAZqCG9$~q%p#E
zHA;qkXgJa<Ktzbcv}}cSZzC}zcS(mH|L^avCc`#*2q+8?iFTvug=Ajtj`pU_d3!>0
z@9aTCk(lGISLyUOybY6r@iimfE_5Ry;R<MoQ>RS}MuGxnHLO<l><(b}X^2<%DVl}i
z1ZY*d^C((%<KV8DOuv6OHd*%n!$FpGf%479mlqQUXy>vOOn~TK7yo0P5&VOTbjLX1
z;S99~sS;44K#vVP%P02Kv37Ps0c&D^j7m?#+c;+bxy1d?o;{=D0Tg0b=B>ki1oHP!
z9U$@J^XM)!y2-2=V^D1VJ9p4grm<Z(l&4?<AE<DGs;>6U0oxvfc<eKQwE<S7Wh$fF
z!Fu^`k`2CbHJK?Phd_#201jp`M$wAxG;&yE;wtL#gZK0dW_im|IQkXazkVsfXLFE%
zKWe)gfDyzZn9U<TfByU~?F*sQ)4z~g5!2BeGMR5wL}vsk{qOtI>1V%w{W?VbcTj@b
zrngIgT!9+{ci<w6T^3t=JKVgNSdXgRjI93nHRaQIY#|^??%O9tq70}-FdVCR+NS?X
zlV3^wah+LDKzRj2B0eGEB((o`VX=YHVN>2*J)YZf$0=ai3d1S4c5sX*q_31@?u-*h
zAoOPbqyGcq7{c93HSpcv9cVPzxJzv6R1nkg+9LmaZS^Nm1)LV7l$bn=VLgg;U{zL%
zPKa5*^O`kBYfakTz8c*QWq&RaJKOA`Lm=VP5JL<KUH}Xc$-}?NWyLkW(IpaT`NtAL
zB)*gjk{tYLt>7R9y~4sS?f=OX6U%;+K@cu~$Rab`13(lBDv2}ziePy><c7h>jT^}L
z>Kp?`zvuB}r1_$LD}KMWS1xFmUd2g8W$ZX4w>m4~j1c$&5A6J&ufL=;TGb`K|JOAp
z_|xMLA9jIsOCyNT_OV1Mh?K8n8t|LaaPu67Et#O9k0OSjxc*&@iKg@a|DXb&##1)`
zol3o$|L?0de0=}^2noWflZFQJyIMernmP?G{G&(nPrcJx<E|(;N3H<}g=QR)jt$b&
z1sL<y6%+T#y100fUl`aKtx@t+p~t$Hn2oa+(DQRSo=bz&D2iZc7%W`(A&N9}2&vBk
zh2~=^j69T`$AaxcPQ~9_JJ#I_>L@A-p(tc$XNTY9k>-H()>&|ooU!Dn4@V=b`e=4~
zqx#QZqRFf<sR=rFP6HVpGL$nO8=OAo$a=9sX?<9c@(oJWf11t)1~il9_qQ2|{1=E<
zz>ZEk#)}PiunI0MTSY&-%;Mksl7t}#rddyA08^IW2VX8Zd$VO#OU#dt)|2h>5vjjF
zU;LFDRKl%jpzp$ckijZup%n}KEK@lb%(VSsUPoi&+%_i0(Z=skz(2TGuu=Slf3js%
znX}Q_(}<n05(5Ae6VW$C1Gu?W%bR8NMfG$3u{z4$f**?xDU$6<(9}>Mq0by(vtgho
zzd#^=ooudBE6!Qi5mD3+9zOHOS4w_Gj~bK+e}Dfr)O=tegQqJIwD88ADKZ(HfTUjP
z``zE)_=Jxr_1OJ?gngrGqs^Na?=GH9zY84}oP|z#BuGs?9yABtqu00dOUg%qv*4`r
ze|%y5{}Bv;ou(FH)(af?z>%hCpyLNm6uMyg`%22C)`1m_=q3AKp9VLUeDm-~E3{B^
zOcvqc5XfT|7>&p6^Z$sD2jM6nPwv{Jg^X5@7J-2_w%dDEL3tJ?#!E_k{Xg$g(NoEL
z(rKJ}gy6M<##EprTnBjvyfi^pS~Us>^?!~59Q0UV91g+}F&WSzxA*uZ>f9(rGff+=
zV6YZpARRq8J2=$}3P1;d4oJ>=>hnvZE>f|{xqs}KS4aqTFv%T~W5BXuh(CxTU5<zd
zn1r!x@-&$fHCsm4$`P(V_Vw*erlxvp*Rt=~vxiVw5YCa0@x8eUx6pe_T)TBKa0goI
z4RgkRQ}@r`y!U@ZgiS^o(P|wZ0?tKn0=t!rFe4l%)^2v8=s!p4eO+yBW(<->ZFK^3
zQAvN_XRuLj()8&F|Atc*?D&7}efdAt`}h4Rg%G8KB56P<Q-x9_QmJG}MG7SnqL9j5
znbNG8N@f};4OBvgG)jg`5h;ZxLS+7~ea=zt=X3vn?+>5Hqu#^4obwu<&;8tc?X}l(
zWWm7QqC>XndYS)`9h^eyitu0M0=f?<*?(COzWhTka~7r!kY>W)X6ne1BX1uIX1tCw
zQ1R82mez4m^7zg|7UEn{OZ<8MY8YNWhe;!FjKQlfQ4=4&_<tQ2;YauD$T9im2@I|*
z`L}le0qH*#hK5kmmHj+YfvUF7R6BT_8WIk|yfADG!*0F+G~KC=X7#CeByB5^)-$99
zW%Btj{Wt56{1sAJJ*0F$6qH}pogWtCGN)RXJw9?gf^TS@9~X;R>A{-`TmLsF0G0y)
z18U=o?<Of)A~jZb4Iaj2^K*0PArb(^w+%T0_2d6{R<MjG)U!Fb-2=nhbDI}{r4=!U
zmBy8*+Wg&O`WOGBc=ZTqq;BQ^teHzxg+GqrK<MFd4yG0sPcbkir=Spn#B?V7%Kz)2
zke0L^@_x&3nvygMp+>j2k-QgLt4Dk`L6D-it2lFB{ij8oLRs_ikkyog`Rd)IZ3`IO
z9D|PRte~@+3lhi&xRE*bzUN^@eNDmP(Z+K1Du1qWS){5hcY3uOKY{_#o6-5#Xw`pt
zew@{Qr7_U{+CL+eH5O2^Q@G*py)BCbTMjoRGlo|MI<~A%)G&=2-smwa&$9&c3^a>|
zTwW+x=OUmcYn7LmSNjk2(R>1{Lxi0yI0>MgP4!#}D%&NuD(Q2i*1_~l_>U50u&aaK
z{W-1qnM@*;#(jJ?WQl~fwz`p}z>FETz<Oxv{2XKkMSnfw!ODW!-$SoOe%f;!*!!4w
zNEUMR0nG|Q*Z|$s#y7X7gDMw`vh0MS<A7hr@6CIfWFY@#eupnYokip^4a}cADA*_6
zv<HR4zmZI89bbd8KhlC#3ng1yS^2)f*ddEjQsa@$aR{5C2>}z)&44y;LwO)gKS)=_
zO?sv!_jSvVvr+SZE@nk5eF#jjcMf)4^?wx#<79Jek1YaF_F^`yt|&VTj|mv^OB-l9
z40>N+&SRh|9-itbDx*W*XZ1|ho`itPuf)nGOi%H$@b*6$&(V0G^I!*Js@bk4b1x<}
z=C<l<_08F^bEMh2ylKaBMr*JR8TqjMd4C^>Ik0Nd0%MR;yr!<<)pbCe7pd@e);O`E
zVVG{w-^%Ccc`y>)U+atAgtrtLY0Ds91ejham|r>YnD&0?K|dB?EfD=Fe^2<Pb8?D`
zGT@vND+vu}bVBy&Oiue#S>)`)!q0!qVkpV;{gs|HSo#iwbcCbdzI_Tzw3Dcs;L)??
z(A%3_=-<E8n4%?#Gagt5o$k!|AqzRy5xju7#KhHRW~5PUanDT#h9*ckMMP-a>i5)t
zf$;KS1w&Sd1JJ=OFZ#u&4srn?^2HPpAzgc@wF&>%iE(A*(C?ng<Wt?8&r6vgAfK+T
zF7VsbTZ4{B@SrxKDgz^LtTgD~zxLti{2!Dx5ekIm1&D59R}6S*+e#--8Rq65?X-^d
zWXpx2SU-cZc3@CT47Ef=M39t74E8t%h=>GqXeEe9Ktvis7WQtcKNO+HpO!XRT@-S3
zleAa|g4rQRXq9;bilCN|R!lul5#syKXYz>z@PmcFeK0d9_x@X9;M(+Q`p&v6Tt>yq
zV~_V2GY))haA)NOy~_?Am~tjxc&f9&juEqJ1O4Ep{Y!DcK0-YYQK#vG>6QUtYFk;-
zYmJm-w25de8y&*q;o-R$Z(NB<cUHPa0mBQZ!5WG}X6x3u18Z{!riT1t*H^eQT)v`^
z$$WQCl@%|q1Pz~3QEGZhK~eD&F2N4fHOb0hP`%ZCU!1YrV!$|W&}kg&UyFM<fr(Zq
zo`KF=n{*d)JyE2c4alQtLEB1F-T+*&ox@y<^NRnE==L^atm*1aJ)TcqK-!*Few(c*
zz{vTw@Vv_ob0GN!p?*dD-`p?dS0ORnTTT2104=wCdprTQ>#tcO!T>&5j~?=8Odx;2
z-x!22qFe&df>!ii(2SuvH5+!C-AnGML3@Cp8j^&;`A9~vD7|b;@rdY8xdi&^WIu`x
zrV7MllHcz-SD)EUCb#VP+rLfd*R)|Q_&Fj!pVe_nKI8USRzDsjV9ZmyF<_&i4U><f
zc~;gNHyR>a!CVGprOyC7xCs?wy%Z?S3uX7bYbJRF$D@FF4}ogv^HI|^qYh-g-kq2`
zrg`<bIFq(tVqZ|4rYl||QH{gHg&~ah6b&2)#CYu7hY}^Fb*I<8&up_P;BzR+XQj$_
z5Hj`Sk&$6|Y!^ftijZPCw2CbBflS&}A8=Yy-}n<<piRap!FpHu8cK%oO2Lz^yuFQl
zlWUWT@J(5`N@2bri2v|n<)`muJsT8)w^0asb^b5}(FKJd+H1j-!re_ezynKo^Q?(5
z^}}GSp#&>@m%9~ZUrD+J0Ta5I$rE)Q-A3##y9Vw2<9&b~{F?5dKE!GyEDw@7xT`#k
zlwU7qzallrkv3rVK(Vo$n<_W_xpM1&7L-GYO7r*pn8!-EOeIk)n4nEKPpt~OP%EYo
z!#NR^mF5f_$OUB85nln9<o@G*n6`3V(~OzD4Q*U~q-HN6$6f=;MG#y2+soSjsxM1z
z>R)!zfo7jVR#mtw5YPG|wp*Dqw9vY&_xj2)Hv{P(abOWp^rrHwVo;7>ky?wrGNnh#
zxBYec6%94DJNDlAnL*&w^dex=0?@XWEn7AjxD8-b)EM4B_9d^5Uc_a7gW=c0#g0`|
zxFeZsz;87I4oT!QFkDx4JuAc{d_~|%JQ{%3ArJj9MH2E2W?$Ww<vy62Dsx7U;<-AN
zHuz(Dk;d;(*MZ$)hZ%1yt7(+@aAo((<mcyng9~dq>kR!e{(xbaLUUG+60#Qt-1E9Z
zC*4BFO0NSmczY|q4s`ktoIQ8WsJ0tj;xFk}=BcXQw4aa(@r>1L*4RzsbR)_q49Sfl
z-uRw{g;(#H7O1PTch-iz@$B!KOy7lFr&fg)&s@B(^>?nwnwP<$tq79ac~((TQATpi
z;Y44S>T6tDd*!pvWaHIND&w~Ru2(l5yfqTa0nWMv@c@7ur-hcs{Xf&Kaue2b{9d*0
z);sK_)J$zA-%Y??c!KEj(azVI+!9{_*)sn`oR!!cVECXDLK9`R_kW<UD|c>w_n>0Q
z;IjO+e8q|h5H_LNYlya@Xa;8hguwp3P0d#0wI}*@&S$^CP4vau7Quo^=YyJd5PnZ>
zy2%SHOV%msX&|MHc)wa@JaKs!D(up5D1Pr$uE<`H2Ctp*=^Nah%3w_M2#)VIP=h9Q
zB$Ryo019UK3Y)KM8_W48`7)<&q_QE-R-tH$F_cl`3|@8s)yr<}MvF!=%|FAY)YA1K
z^?RJ`oxVUFKy0JOYm;Pe6r9$-#n}NzI{7YzDQum1+&+GLHfrDxAEx%!jsl7he>S(u
zH4i94sZrimm$^hFHPe`9dot!3G>FY^`AR=Z0AZx!#qm?fKQV3jPPuPUFZx&sX=&j)
zlSwP+9C&78R+bhPU3b3rOII?1qoeuZ9LN54VBq-4DSE-i$Tkr8EYh|Z)VqGZMoDGB
zS*!g3Au<<mFmr=n$n^A2L(Sy6y*I7<hw6Bhn+y2<yvncqiMoE66j%nkxuhiC03wB;
zjzq8%yyt>m35^#LQ7u-gFBHt3_o0rU|7ai!V9<2ZiEMYy;}6f;hoc0%a5*_S=p3kH
z9uk%lRm;RiPFtFrW><V)t-c}e;B;2jm3#@t7fIy(vkIiI8sE;1ND8|^m4&eQuPGHE
zFB)4}6=9)P-n8XmAQ^_z&q>lpLj8h>TZw}Tq-Pr>od_e77hGM9dI+tJfogY}wS`2}
z!~lrN{RG)P3R&i_8BR4Y!HhQM4WPa8XQN;D_^;yVKeFX7W3l@*u@1)4ZfAhZkB9Q$
z^9DJl=9Z55SKZ%T{hzz~_f#qOWkFO<4Xl>W=sNW0wnc5+pK||x1WvLap<nu{YWvsT
zx_IWypwE$Xxh4Qu8#vXn4YqvzAW4P57BXpn&yNF`56T#$l##=VqQ4HWcrE{hW})qS
zYV-7?USxVKcKvZ~{3@+qW~6%nARW^(MQ1^AX0@K7VOI9dKP|I*9W{TPF1Z#%wvc0J
zWO^MAdmO~Z27McLWrw`|uq6LJ#)}K1`nqY56Kn;(Ky3@X6=A}70hr4?4KXi>H_nHb
z>dFn(i6;+9A}2&LGcZGM70yI5S+VZv!bmO&F+)dx3kJkP9(tl$qJM=KrF5@e7!qlY
z9GfTUa`7RMFl4f#kOgYB>R-2#6rAPTt6J@?T)j7u9scCc#;h(wo$(19zX1Zz^B{0W
z=Fg;6uGWAl#$^!FIr^rpp`n2b#=);rGd)2qP#bm?Y|6?(x0^dla4LZ8Fb~}+8-(@O
zV;xaRJXaP9iCA)E7J;+U<?iU`Cz+u@$01mN1Zo~m5IK4IXaJ{$y?dj;#3g}L(ABUX
zV}PMrdwr*9(V5k$Mal?7hTcDt-<cya9k(7nbQd52gjNhS^w64x!m;WJB|cNr%hv>;
zj1$BUp;uN?^2_`%@>wPX2#_%lvl9LCk5J$GY`(RHbp42SF30=;X4V4dq~w^G{Z1+O
zf{~Jwr!P6(RnFmT#5=j9R1NA0z%HVqz`OcMNCc2BZC|vQ0Bd}aXC(oUGm!U+PfV;B
z5sbNp>>XGrQl$-mLSs?DS9?}%M_DM@@fJ;NYN;aaB56rvgXx>tr%8B>6&v2FhsV1#
zL~zM=4(SPY`~hwvIJwQ5X(ez(oHXR54M56h+)WuZ=8a#20)bUD@uwH+t)*BX2ho4%
z@9k=DuC0~j+(nodRvlZLcq*nQ%pr17@A_7NdsCya`EB0taENZVEHR}YCh_n)xp)iu
zQ22r3l!?hJbZAM8X!<3z?oP0Srr8V<e<b`HK^N^hI8r&yVUENM+UBX(EVy2i{7-mX
z(q9lYPE!ehIl;RC%+ZX2a8js`$w^tTb%3cY8n&4I5M$t;z`5k`FE{?9AbuHv0I2Ic
z6LQysUo!458f2zH6jjGEIR=DC#6c64Sz*)e(7)zXH0x8X>5$rZ16e$gaBuAVxCD|z
zxd=YVKow9Jk@YB=S*uM<7NPz^)Q!gp3<JD#Sh}SMuSn<g(UNW~OCE>1Hb4Jd7Y8yk
zdq5}~N&xEE<sTf!rp6BG<LGm4@63wV$!p)hf(S&8S;|?zr$SO+6JQ(A^E4m@u^kgp
zSHxk(AOSiL4?9#<x{i(tXkFbL##twhK_w-opk%$l$TN~zFdspjn!1r07nd_+vZLSM
zd-tS7_lE<>@n7zLDs2B`J)c37ndZbdvWpi>oL?Tc>Up~1LFvA3QN`MmVIOZ7%de6N
zdN%7!_~u~aaK%+ws;8%>2^`(7KD(m%*o<|7S&HYJQubE6rr+BbwcWm^xuU1-o=f`q
zsy44|8G~#H6Hk4M#YeLizw!4RcoUewq+G0UV9}@%bJ4PPfPMv%HH@^Jht5{P;N38H
z;uYwkVte}J$z|O4%1aB*XJqJF<zSOI{3GyBN)W_#N~A;GO-9kW$OcL|wFo<sfOSCJ
zTM==y6`pv2(-3?%{3^uKAj~w^A^9H8T>@YLjsQRinYpGDrj0jH$O6s;Pe96V&3p=T
zz_3XZ4FOefFvjSngH{JE3TUv)lY%DN>}Vv3xx{+@2&~_N*+_AXU<d}@sG^OKybL|`
z&>L`B!3!bXL!26zSZ%mbL5dEa&u^te8EnVJ7#&VpomgbDQPu_5Qz!ESk^32VnHFI9
zjIClq-=r*QES+|^9H2RQ!`SmOfS|CTUxPslEi(g<x-1Yh$W^U+$*0f3_6}eYB(3HV
zof#1Odtd`SpVu#;5nT=~!9o&<MLqt4rBLNs%&K1zyjFrQM@>z7Oh3NAc=~kH>lpny
zyPs$af*_?`e;;KFX1sF|E?0meH_?W(8w>SS#>auDNL>O<`l~|z{R`wbGma?81vsVb
z1DV0G+@{|rY0dLTv`*WvPH;AjCe2MyzHHH73)$%S17%hm7C8X|5Urd4;cfQrW-HY5
z1z%IMS7DVy_b_AwF@N2`^(qB}G1oeqGlXMm1})VdstwV9k%9a(vKdjoSTsa}M;~ze
zWK%S8Zs!Ib%8yH25x@$|L4DZM7##v;NzIf7=&Tum;DTOa9auk#vwW#%MR~;$jT#c3
z>g_$Di3xWiwcmrUF1njPWjSpJ53|uy+80Pr4>S)1m1k7E{XXK=Y5?(_<);F+m0sR%
z$@yYnj)nS5mT)7ln+)1U(UeC~xI4mAh|4m0j9f|IhKF8ikg*s}+aIh#o{Lwlv$a|C
zJsaE(Y6P-_Yh3JR;$Q(+0r6`_YNjr(oiE!2?f7>Opym1T@uG?pL23)c)v{<@I7May
zw4h1^JmueeU;&+h()%8s7!)r0nY;Rs+RY{<N@`_e-Op{T))(8D59fs4(A0cCnlt&(
zw0i~G@<_uGQ^3<SatEbO#4i@8lc3~e4Y7VG2)(P?$9laFz)DqZ12^dqiD;uVY`F>D
zOBysKYfS8$m@ICh2;$s8nspA@WXQ3?!ot$4>y!y~z}C#PVBf5CpDZ>0K*yl5Akr@a
zfiSv7;?5qTJAA7d-PaRxCYE)aEX)CS>pt?P9Z0ajORGO{R0CcNIM&=ycQPMDklO-*
zEcgUieDt>bL?YJ)vo=~&-XA$&d^by-6%ofG-9-}HjSezE*SXuvAUp;o_-*4nzH(!h
z?@Y|!FTDa$iXG1t)5%b)<tEO$HmoCR18%mC0*S5^24Hy8BHE(JH;Caq(BFqHXqzlO
zEBx_T4Eiy4`hL_zCxFi(J2Qgd34gkYWxDPydw2|Cc%=CukIeG9=JfOZD&Qk3U}2Js
zdR~%Atl#~6YyvAL?!LJ>Eu0OaBOs(al<v8Okgys~Xoq7(%65*-hqUBWoVI|fRH3X+
zvZ)9)$z<58?$~SvTR-it5k(87AVjxv0uRvvOH6Q5`&VKGWuSH^yQthka_9mZwyE-F
z>_|;OEEOfUwi<!aJWhKp)TKbmm&9>sH~57?pCH%*2oQ%KoB+9Lh!RgEs46LQLB_XP
z=Tx~M0Eswta+TW+dM1);s%Lck^9flhiF>*zIstc*hLTv%a3BO9d*aL)np(?Ut?!EJ
zlkNkfj2yvlY58lUpo-2m`t@vy#{`=(E)Uh1jtJ+93o%*9x+Cny>?&+rR<j1Lnn5aa
zh^?6*@JY+cuD@)JrWP~=I#uwDzy#yYL9;ajP$D@Apy?;diF^v5Ny-oSoe`MB2pXia
z8C09ZGbsS``Quih30K!%D#^lemR?-(x@k9Y8NnsA8Tft@$r0Kvm>Ih}H@g(c{VS3=
zgG3Tu+JkSi9v_o3N;Zw3$q6-P0!Jp!3%7K+7las02qZ9Mgc@<x;Xg9CU|08y=}=q4
z+I}7@$qS<c@f5;I*)4uhsiM{+Dui2e{fmKfVSM-N`8nH6e<RWRj#5;un!OOEMP`Fx
z(hxQyh0>h`oz?C{=)~QWnLz`EkMF(p00imSH&cirsYzomre*~B)b7Ax4XPYv#-%2v
zPywO04{ocJwmM`R$(Y>5C1p@KKkOj(GK-gtCIexaPk7aU_f%})>goaqiOmR>q{_g0
zJMcG_1wkK5TXHeoDy+F=l5e{S%oR?w_@M|n2WAjxKDRlfUQ_0CqzM>vfz0W70t&p^
z9bmkJWerE}H^N}PV0ySNk8=YTpcSq_ArJRyv?m++9Lm?z$P5m-3uyJW<Spo^w5{ty
zmZbtkE5K)p9NlMT(0}D58Hf<wzlv|mLk#w;wct3}fPq+6Z+2on3W^<<?TVH6A|oev
znV#7@km_tjYY|GsZ$C`51#^z*7(QUtGk`UPq1j2b-ysg{uYVr3&uh%DWc~iYk8~j)
z;2fX-<K7o59o~sUYcc%frq(TTCb_Jm)nfyC!G5m?`kM!Uwu}SWcz_XYTne&*fSTl1
zoSahdD;U+BjU|9NpLZN3UIUY<;FLl4n!FegDPE$kN+KO3b%h!H;M44FBah_yVhUzE
z*c()XCIPT|Vvw_wUI_!}*dZd#ojSE;=h0g@naI8mb;3v;tl@KLR3hr94Zf$bVglSv
zXzqb#lmN9hf_#Y=>k`}AHbrKn?5aR<HJeAnlPpR(w^U$0Tyho40?4cIheY6bIHv+~
zOM<R2?+7Bkz!p-SWPC{>62k9~K5$~W{su4}#%p<z2NgLu1W7p#2d5m7U?q@!))XnU
zgK;P3&?cCRn9rpf9YIpBh;-}E>6#_1oIpyLP=6VQrO1V2D)I8=oIjsl23I*6<3ZCl
zv#+D-#83aqeOwrggVF$$i@JZY*I7`m%}K$ZT@6ufu+ItXBvB-63CB%SVIOygl0ur+
z!O$>umH0VtTx1cF*F*>fg7;<R*JY=KH=pZT_FNf;2xBDpZ6E8jeP$o=y5o4c4=j3q
zxsQrFWMt&4%b?W-xEU45zC+S9`a?6`V<MhzBL}l9Yn~6jbp6F(q#`|_Nqth}1m!xl
zMM7=6IP6EhRq;S2XZO2LIuz&>%o5gk90#<jFws%LB28NPVS9LV0x#65g?6Hu!9_VP
z(F0$|aX?6Yn$Nihdm@1Hb?AMC9yTsbjDn|Qpspbo4@<Qfvlk#HZ6f;_QraaMW=`+B
zB6o2TMnh01_Xa^1mjPX{r?8gUvWXq0;&|@@S%nheGb|cpZJUr91P#=c92RhR%fyJd
zrOUpvR&JN+hxOrW%;yAhDzIn<98LT;q4Ldt{CNF2UQg^sGLYvo&hptymMscvuQ~kr
zhEo`%L@sQOmO1W#v<~5FkhVkO&L%FXC4ecPxJqT4aDKr&)`>iI|D%LF;>}_H$OoTG
z3ghT_kPJ_`Z$Ck86)Ef!2Iu;PUH@3r2#lqIm!yS(J~E1t1d;*a;QQA<ckS9t<PnA7
zgwi|(dUWv+^}>01asHHf6VMlZd}LFHv)snFtPR3c6;PMFeED(!nl~huoQ9u|3S;uZ
zOja4mnfRUA<JFJ}!47UXbm@1u_O`w9)?<zxC%Y1zwv^$MG0BRnAO-F}7Z3`iL-g;@
zVO$Ib7w8p@gk|il9TKM_B_g7m4hUUdC5cvm!W#B@t$%9#ik4ETGthFLM)J34GsOX%
zCnb8ErNRQ-)bZL27IjQoGtNlC5GoQ10)}yAP6;~>ZL89Zowk$PlT*<fv*aiu%kL*F
z6r&*UT-4{B<NJp<)@U&uudG#UXOnqMN6e~hj~&Lvt%68Ty{ft(vEOKVVS+{oG&No$
zo?fVqA3&|JWKA|dAK&=7J8br3V_y|@tj@>Y!qLsF834rf6jLg;e_p-{rdU~HU&6u!
z)Ur?XEZ@5C>CqeJL88;KoU^*54;bd)741PO$Jo;pf0ksJLJy8Qod7Redd-abPoILe
zs)vc<QQJVqhCv#LNbhPTVt5^4T#fbugL*8awIQlcxgECJ7HA@E!8jI{DM|mLWoCtA
ze!+N@GQu+NFYbO{?aq!YW1riMBWXmS%hY{=jlzQZUU<7m)F`dFVrKTM55<UpD+<a;
zxZ${lPW|$;P)f-47}VULuF8?BgaA2MUGAg@t%BwvJE!n!Ger5ad9%%n@eWo0uyP9K
z>oDIN@~EtUss$pKhq$fVlP)B;x1c^f`F4H9J(KpP(=dPy1D&0LSMfV_pj$aAbm}$4
zUf5Oe24F=4*|y^-$j0g3fHWrg)gW*cqWXRTOYAkjk3?umxMYsqzi9ld5%)cJvG;K1
zW+`Vc$k8$~Kwl;maUo4QKai^I89@3z9Uz}$H>T#5#|m%{BlHDr<+g)zAIQQg?`SF~
zXndqz2u?UM8Kp`DT59~+CWqV#r&tbh0mSk?oz-(uf&l14@A)hMH!M)+#`x({c*3U@
z)=Y)11mq~w01T0-2j;L)Ys-Q&j1W5}05De?l(b<~CNARp>gCH%K&9<*rsz1VuV0~b
zFMoOrON1TiE9~ba1K{}-3O5T&j<|f&+{!dNe&irBxJm#RG*^SC$d_(n?LQiFcQEg|
zZs~v__#D=bH<Qj6X(;l?!As<E-Vxwn)nyO#WD9w3L=zX3y+aYk<6s508XzQO$<Je2
zpfYg^AL+>hASEl);VpP{5`#qVqX&>;?8L{N1cd_wBs8H}7ZQOv2SG_)Voai~%cjmK
zn1=l_^`LNCc6Hq`1Ua|^;alzP?aLIKpvIfg(m|a|<V(KdG5I9tU2_Rp8i*2u3tTf8
zd{s!NTqS2;6b|<6MCd+(>uzNT)LgR~-4G=NY2cW^1Jt)mUIyJoq&&eiPzXn)OCS`2
z?=+M2_hH)7{jt{Hd%_$C<FfYoILCm@2Y05z`8g_3j_N++*d?PU&-wKW(kae^YtL4C
zynq{~+(}iOL?1C9xfC5x6kHJOjpz4i9d*G|9P@~F&)5Z5*oDm!&V1YlV0R@Ez^|M+
zCII2<H6ecKE{160Lk8h_ZbdeV0}M1T)~^K+@)8vbgA62+*QH)E(q&=@2AV|jnG2D|
z4sJckX_#9ln}kz}mS=zo8ly{^yWLoY7pB}W1~C=R?3{GLBb<fcCofaD`zQhHEe&)N
zD4gR^3VE1-%c%Pf7!)e5V?=zT)STAt>A^nuB_FEG!yQS@Jbq5`F3E-A+^ytjS6J8v
zT%WLGWE5ONuu9DxH9e;+8S@wHlw#_PlnhUwfmt3X7-Er~g*>zezk=s`;p4|k*3=He
zJ%3+4CI}c9fMjx8pdbJjMZDCR9LqJ2Q<+F5pnej9k!C`f*r*6fl}lcHC{=PtfE>UI
zD`s&bJvOTW?;qXs5;JUhRb<Nvp!gTs4JQ#fhDBdqi!b-(i!sK08)yboNRu2V9gR?;
zi?@Do`^bHT_%Tppx!z#Nal=!EH)n<NqMi;xO4{S5rkZm{ViV(dW?X>w+tN%I<P7=w
z`M^dgV5q9<`+v$p$`KwFC6t3P`{~GD8di^qNAR5_*kFe_>cmx&f8Luuu!~PfYVc(*
zIHilq9+mcQP46l34C5=9Re2j-KQ#3P#|U=yR+G=BmbW?sG!eA(mg?7vft*^Sje)8|
z?<!M~@KfOr1A7{4ZZgTt@&PKAR|QBOr}FQk94elE<mnmEqnt8d0ygXL#)x2jm$+)d
z&C;H;(Oh)o3C_z#+6?clXD$73c3+O@6C2Y^qS3BsrrayAf3fbG`6BqPk>My5JEmY3
z2*)&$pYFQ66F=>%y~9UnB0PdwA=6}YpBH%Nm06NX*%L2$7qP!kp+LLxR7AvbU>Fv#
znxJ|SLI~uXgu&}^P+hneNa?s^x8M6~T3avfT6=SRGnto=<S04FU|y4mIOIv9T@kIv
zgYYl5t4|v{1<Q$tlpMaHm%W?QMv`B@#a<V3?=F(ybY<)uBjL1>u1){6j>>oe(L_Np
zCi6I|Xar1_y99czn^Nc31&(70P@n~_s`~omz?BX6W}$^O%m(EHD*S0z3cbPPAO;bR
zX9{|=(Gs|_E_D?en<S*e>N}!+OXH45@Ap?+w>%4eAOq5$7S6exh-qr}{25<R#OIgT
z{x&~0BpE-t&w3x41ul;hK)|4BCu~y^F2zh94Gc@m$j~S>0Xz_9cnKor%Yh!aSYFXJ
z1cd=w74Ypcfaqh4*EM%Hw+xJt0-lb=%Ana|Fpapzup8415Svgg=-Z9{f|Xm-kBjsv
z<TM(>?)UnzQzR3v8s7>|n?+<@wPxnR9Mfz+UqWpVlR*}&HlEqtk8?LL9eqLZHPP4e
zCd_k_requiHC;2b;C~$VV(*cdyP`b773$mH*3aj#fXvE%{TMxNy6)zw=wYfktsh5=
z#^h?{$Ve!n4WolP?43<>)b&xiD@yc1jOzG_>W5JbB+PNr=VLuk+XaJ;0ZF8`m^4A2
zqiy>>Lh6%VZ8ER;+%cE@CkYGNv~EeV<}7o^0!R7#pyT4)<)WTFJ{-`GV&+AhX63$y
zMn+rlzF-=)6Re#{ZvD7?TSPAgwAJ?^5HGQl6r9+Aq^I^LYh{PW#eDg6c2n`>&?7;r
zwwL$1J5iLB{~~gALL{9kSWbAzpn;}Uj`joza!(IN3q!wTfde**_vMRU2xsIg2Ds0D
z`6)U0kw?9NZ^sDu*+F+GDiO(_iA4xkVOP#i&J?IwAbfgvSC4%=NnJp5_gxn77Z$Wx
z#QDnlI|^7W^_XXl-&_z@;Bo`+KDP>36uu7NNQjPueF`Nl0LJxFaEK5snM5GAOJcd~
zt^D%^i+#G~H@J_6xZC=$A1M#69mI{sZH_e`83}8U7obF8C`bOxfs1F)iq#xFcI?<&
zzkZA+Bc<mKfJ>T+4}45m5fVe<2fwH;RH-}_8Ts|k%RaSb3#=M$Y!w1Uc|mKa8nyY%
zuH}oQ3yM`3kJE8>cHZL+0K=r}6_Nb~xIv_iL4+nRHJVc=@;3T<csw|qK)H9rTSA*r
z_|BqKt~_VdznpqqVXC?_oTN5AKVzJ+?e`AWTS=}|Z8APQF{5|GoL4m`p<1m2jtw3J
zWzq;X^_QK<8WsgR<xfaUh>oe?wDWzdJCqn(2gd`#_QPk?cB%OTQS@hae#{Y4qB>O}
zc=OCfKX=;Pz_iW`$DVmeDoEWucbXL};a|3NVAsXo6-8lM_nqr(JZFzFqut!=u3WWw
zGYh?y1j7R*@z)Qr9`;k4)v7FmcuyolW*sC3P0#oDC!10vdKAx991DHWfUWxuXi{o8
zd%eqti!fmlhTekl_4SQ+Ol7{(T1>7~sBy2bw}T4%@lzvsW|n%I&zlFGUc85uD;>IP
z-HYT+-(B~}k;>uWwu*U*c1EtR7TRcn-Y*eQ;gGO>&j2v!BX2Exb9ScGFVx|z`zQaT
zD?^v))C``|M7`_l|Dow{)0=BEA%=L1$JA8UU*L?==;;?2<yZ4U$7c8Xg1P?C3liNJ
zq64bF<HtQncYdoh*>d0dp4+FE4v5dixP_Kt$J0*6o<Xhv1%o;Zs_%Xsnmu1+7tc|5
zQ`7L~J*>@bU>e6NWcYn~J1_3m9XLST-nh*vdqzg~clzr^d3JSJRzB!V{HW$MsmmLp
z%P{wA*Ah|Caceb-3O}zcdEZlU);mbY4oAAiMQTAN^PI>&-0!CkRG9|a77lRHG9w=?
z4`!;-Ksi9zbf>N+CC<a1^{`7;VEmZ%itN&cb)*RwC{{viO~q%A!{_+E;lmu>w6;_n
zlM(`sd)K=&_}AAdT3WX!ZY)iR{wU?g>)s%GUYKl>>b_HR_Db+>9M(|RU{E~+Oy0e?
zi_khuC}(wjmS9l8MWqqj;VHy@fal0gU_ShbQ{KGED&+trOJ{kjgMc>TfXbF-C%RRx
z(~FXHQY}a+Os^GexG2Uq2P*qQA(k;;L!_XuFyppw!^M`)?2t1lT!>!$O1yoCbuKR(
z8HskAM2!_}smw-y@3(7YAo*B@e9|1`Xe0nz!4;YVEhS``48l7SjG~}lzqzdD3z|5R
z-u@TP&x9NYpNPW5DC-Tzj6-4}2}M8Nie&xH-Myau=$dwjDuccef{Do5h3&&weubvy
z8*YC4)&J?)X4~jpU-PViaJ57Y=#*bUdnn`*FcagX<jV|U;jonz1JI!UiM*5R28>h5
zPFXGQ{=!PwSSe=pby$*jFp3qydnw5INEpH-drlRAa6$1-TTCGC8SvfHtc97VyDp;@
z-_3QGo#Wg%pY^2BN_0noBsm{#`r_*nz299~OFG;y;Ww64o0R$8nRBkY`e{o~m-2$j
zKLnM6?+!Hh3yxN@vwPIu6pbS39$x4VjRljpxY@MGh`;Doy#bQ&LOjmr=v6(!MO5B#
z5}O|7GmGY%q4yoTUDYDW50is+-;wY)H}<#e9}bd4jjx#fivYmMO?v~PbPfIcZ#Ac}
z*L=yV?eF*`H3R#_;1Z17%;>5BE8gXXExoa=)8)x?{vgHAMSb!CV|jI+p9!&AxJkFM
zJAZLwO<!@_F>SsFo<VnCY4R&&-gt8ALyk=;<XMpXM{ju=uJ0F`J<#t>&UHj3)kp4h
z$S|O38I&qM<^g8#%&<5w2+djc-uKwz-I)uv+?R5YPcVcbv)o*aUajWgMnQGZ*J0Ke
z<u3@0vb_yKXU-ftI0|B-sgul7d>T6qBbZ)>2K!WP-(OFMy{(+3x<}u!757Z8Fb|81
ztS?CkO)`z=0|(3wwI_HiH?b24wWtr#R8$-tfK=N3@r13+9-jHA7GRnZ*y&#}UW}Pj
z5)W15=+yT1V)ynH&&~?He7}X&oS};{vzp}5G(5^@c;ZFT^%E|yoWKf;2200We3StF
zvHM@a<T`My+1g7Hqpy+c)3w{Z-Q73UWEOkAyWdig9jt4-aNQLqPF?@56(?qph5_+V
z0*oiiiSIXrC&e&g&5gK_b{?Qu8V~^nf!;XCd%tGw{JM783jUGjp_6w+!oN>h>t}xP
z;Z;W@dWsa-TcK|Qm1yGKHa4cF4)*OQSEVV@n{Mad9Fwwi@80NbKAj;Eu-JKXYZJ`s
zf0ae`2fTO{QeUr^Jy2>iW&Zp*{HrnBBJ?8fX_27f&UGV@^eJR&L4P1=d<U8rk|pUM
zzQIFmv}^jd($7!CM434s3Q%9%-Y(%~1^1=+vwq%5+di*kb4JjeJArvVn9N+*q1&hz
zlo;h=NH4r;V2tl<b*<hVa!*E#5fh78^!eK@y&jC+L}^EV*LmOaC;`viDKFUgp{7sU
zXw11-SVY_1#rX@0*2dCw<qe(|jax;gKxUn2u0UbIQ_Kg^C7JqflREmoH>2}sq;@<a
zLcAsmT2n&WT}$olG$;PKDrJd(m3ypETar3vBk?iy{3q&yg#mp%`LYqw#-=#a9w*%2
zCA9FR>-zPLy9Q=z#IHbOZsA2CZoR^eZ~IcS_Cw9G+WnB(`DbU9jR4HT4NDzeI83Iy
zRc%ifX^M_Qivg6>SnP{}{^)*q(06?}q|BI$V!)yF${Gi+ubnmUzOg9?D_&{1RPRk%
zw9$DP+2Bh&?00Iw6FGZ&dvuk~<T<OodOA2!B)*Z4{LhT4MvmO^{SHr5l-dmD%CLj`
z{<$vH*I&KC{Kn+lzI8z%1Csk-(m0M!eUaP?ll=XL3@|6{JC4n^JThT+!V{iIfFYpM
z{W{pcbHNJ6x?$-uvf;*8*E*a@u-#Oll+n8U5a)Q3H2Cxkx{F5IP)JxWL>JaQdN|UC
z@giFCa=;uQr(N7{FuiY%-Z&!joN6y!sb*UUP<>+WZ0&B|^>+mnH>KMyb+Au}dj3l2
z`o2q%5^tmCj7rIfd2-qbX%oWj5xhy%CGfTaTR~HMto{ZNd~cVovc<u4VML~P=es%8
zw?~<-o-)6uaUeHNT5erYF13L1XQ^Aqn;kvhp^5yDF8vd~*v9iWo35t%@u?L&&Xqaa
z%XHjd?2*l*lzsYwKu<?d${YWUUS5rNOk(pwA|~H%ukJ^xi1CQD4PZyzcCEdH`9wg&
zRCWMVj5At1wiBXA1SK$971q{Y!`NH6jNZOXyXP=#-}J@o_wSFfw<d11mtD}i!$Dy?
z=e^OD#Kp?VI(oIDn%Umapm$OhFG{N?kx|-z{@^O@uJ;y^aFR-eSzmqaY)|LLh7rS!
zZ^;5M+OonEP5Z!fxHKB9U3-Qu08GljbZ@9s0H@cRfAc0nWpVaGu*sl1XzBXsdb;ju
zh3o+_?gQuyw^X}}TC*Pw>pvyeydLMgeC2{Y137l(`xilQyIov@AJT{QPjBp;c5S`L
zec9<C<M84drTTZHO_&!FVt;=WceHD*aZYmR7tAT&@xQQB0VpGi!*|nTcr9<)k47=-
z()j4;L29DRZ7nb`D84hJw=L?1pO#O@gauvFbDTU|R&LD>uKPob!vpaUSZs77*>ij7
zd>gxmTwF`JxN{=Zq8Us4{IKf`PU<!&-Ir^>zhjeJ^#~QGwGQX+bNRLzHok>|S<exP
zJmrx~!*bsj=2NdAxHAgUP;MO+I{HPBgOdBbbMHMA48{#PJ8G5ZiQk$x!DYxJFj#8Q
zJ|c4YnLwqDes87J_+aHA;S%uZfKZlaxdKXz;*S1i1EYba-U{oyI~Bq9JHSwaAY5^{
z`_*+JMHQ(+s}pp5d`>81OTSx!u*e`VpMZ5Ag|N#2zh*%dt)*X2NUOcazw*^q_lSj3
zlf2}Ze%<jCo^^yo1`F-xB)Y5xTOuWj=Gdd8rk9<yA@-(kZ`5slD1h;-mKtv!Dc9F1
zCP!U#EmvT=X!bap-~7<BaG@+W{3n71gJ#*qBsg<g!$J&z=~IBpg6Gxa!JM)V6L&CP
ztov@zvsHTjTbOezew}N}jWW3EuH@&9GK^OXt?ReW;hegx3kjNWf4|`vKDEA1|Gctf
zn8ZSl|JZ`zFC!iuQV!NNSlG(|P(N)+pnc-gqF^)$tE-Cz3>kUBP<e}X-}O}&+y3GF
zva4ddG!{Wj0H!$HwTRgaBDjK&*x4jERlDcgY>bGkR2h$cOE4;UGFG10V|^h?YJKj{
zhn>3CFsVJZqVC^s%ipYhWTf9Q90Z3AA#LJ2pPBb2j70IkF%{53v#<+c6t!IIsDnFz
zMuE_Evj3xL7+@5j@ilT69y`As(VQ*CH}B<z30`LeG=^@;TKUJqWBAmEq3KpIt84^K
zbgo+1=fNO-jZ~|LnaW`Sz|w>D@Wnr2cAnHC4rL!mHL7^dbgmJA`L_L1%Nsc?kdXBZ
zvC6W~Kavf&eY@BxQoZ2r2$YRf48uh*2h(0?RK;{I8Bv8cEr=BUdj_(4e#9ceop_y5
zX^ytwB;Pshoa38ymF*Jum>X9Kq7b@wFFK$!NKEvr8>vk8LUnccWmGS{WPgp4Tw8u@
zBM1?b;qn*&tc-^D@Nexny&~47nVRi*oFFWNmKgf+N*R|c&)S061f+>809sA^z#Hj4
zwfHhL2}AS@(W^K-abC$_QpWoIFomMZ5m4Dvwa@H`go+nf(|h;$1E3_rwWzEv>YHF1
zF9W1R9-Wg=?ArhP`yu|AcOQrmNw*H8BabALuzN2B$#0=v9Gdjt74QXMGT{hWAz&$6
z4(b`w_GPZQkgzP|7Y<A}_)HDE0peW>{N6wtcHYEif)fG|A0Mmnj>bSHn=Q-P_RP})
z>P<J`hxQ!Y9(n7m1q`Yv2wc?AsQADPCxI>u6Y!9_C8$cj!AEfZ_r=eujGLwj{BJK7
z6`E)7WC8eo#J+!A&VMZXrfp&C?~lhqI(r}=30TMJU%y)x23q`ko#&UQC0nK|VcBm1
z;gbP1kaOs2mjYcp<bHvuK;VL$1hT6Gk<q=MPOr<|H+$$(bzt&p_8sjP!V(8LW)?(>
zT5jT{wSqune!+GoW?O+Fg`YjkqXV#ys0?67-r!IfSWiLz3ixiRz>bMV2vJOp+(M#X
zVeEWnk!mXrHFpR@k<~}w8Sa(f(4j9Z%JH3N{l30dMOsNJX#ibK&3Xn2MG<Xvk49to
zmH54QEa{7AL(GOhVtI7!rZ*vDlf53?cn(l0DCG@b;CpDRR6f|9I#P2vahQuyhC(-H
z7?}^8o5ztO9lUk3YZ=Uoez!0yNNqT>-qrR5U~>}SF0eDjVyUFB2*Z!TFcj8a3;3I;
zn8=Ww_YLkx)@6J+Y}oyhP%ylH&~ldM7D9P}MC#3NJDeEVElK+wd6^KO8o=zsFg25K
zWZg68Dhk5E!XcMkNQ1T_+Q1V~C<lw(VAZP6z|sm2=J-8?28cM=xKQr;T?raMKHzkC
zbfpb4iddJ!`kX1`j|Yt3?26ea>NjG)>Vu;KX~BmhyGH`YSpZvg>LkJ9T$Fd@WAKQ^
zlIIv0ku!&0l)~NNixU5NZ9<G-G{G^;Z}Hn4W-HWQ&OmjlSp13<wZTih<c|TyI$I<(
zB+>`Fy4M_7hjn{#n_o?c^e`&}fQ&L@77SyM39`IJDTJc+z8P7U=qU1Y$B{M$L(KE!
z%F2Mo1B7IY77t!k(^8T?{6P-GFfO%0omFQGknsK8DwmI>bqH{Erl*>`oSY4W8tE?K
ztgPy@0F8ZWEmy;858ZCpNrSH*k1S4#IGQ)X+n}WiCf~dk(W?N;vBW<BK9N;YN-;0{
zfRw5pk<=EwYaU5g5QE9h96h^^V1fV#|8!3PAu)kGgz2-;Y4a)mNqvPxBdL_^elPHK
zVp3|cyMR8ZK$Haw32tX7$69gO#SguAZ{7Ciqwqg8hvU<fke)8bKvWmHltP+T$)+;>
z5cVqpp#ea>RejI-$jIji`+KnFG5`H(QN!}HN-xnuE<kdy7_FjA`N4~$kM`RKaXk$z
z08+esk43x%lUzI(XMo9q2?<HyljL&?tecsfbsfW*<Vg*swi6)INO`~$_2?umuNH{J
zlkK<bh`%=;9%l`?l%o&83~Iwen}toA1%{+v5w7tfm}8JHUx)h?z4`o(FIw!xUPpgE
z61zakEer5+HG&1T$%yj4kAoGnuDg4*fO>K<rn+WBwgVK7XY^1jo!~&tM0;mBSy1A0
zmtb*5-_Zb(gq9cRfP|v}A2?R|8GPu-NY||M@XMQ5JoM>iAHaxOAa(IcBzIG8pxzlb
z{@QE%7?}M}M4MucYt03ao=~4CqW^r<AQHXB9H1a{qF`clED`sKiTzL=iwl_`+R_^2
z-E8~M&;&H@16WT}m!qMA?MReLio!2mys*yHMm32N(gXno{R=&81Tx%BhE6+h@HmiM
z$n_RYBAh5IJU!LHg2pftg2-e1C9h4CF=*s}yqt=c*88DZ39pbCOz30*f<FbusAj;>
z+g*APw|fo!2UYJ5XRz3FXUl%7uV>ce3G=cD_%NkKCzGb+F~5?;d^C)~;Oa0~yvQtO
zaBzzCwmk$eP=DeCW>vwHB4$2mKMp|C+5)nrg<nKhty~!g%TKbAN1a@J&0;o52J;SG
zDIY;k4!iyB+c&*4$1U+&IE$ts)dzC}tv@3xt4SEjO@N~*6y#VC9X^1b3X;!J%3IS1
zuHw;%nh&|P<l{rsgy^3$cW$0JG&YCFEwlYAp+c8pny>m-?Sa;r{D=Sb8Gp47SPL<1
z?q6LL)|cx~JYYEFDj*PY^zTd#>sQ7W{?!4YpNtFrzsvah#QyJTuoemDf&72-G};D+
Z-Tb=L#MkK`L;wcEK!4TZ6kVJB{|{cHab^Gj

literal 0
HcmV?d00001


From a204fefe16814d9ef5fcad4071daf79207d5dc36 Mon Sep 17 00:00:00 2001
From: fengjiayi <fengjiayi@baidu.com>
Date: Wed, 18 Oct 2017 14:45:32 -0700
Subject: [PATCH 19/29] Fix several bugs in compile time backward and Protobuf
 desc (#4894)

* Implement FC layer with helper

* Update LayerHelper

* Add debug string for Python ProtoBuf

and Rename `Sync` to `Flush`

* Add check of ProtoBuf initialization

* Layer wrapper for FC

* Fix unittest

* Fix CI

* Add code generator

* AttributeChecker Better error log and speicalize bool

Since lots of types can be cast to bool

* Complete mlp, fit_a_line

* Implementation of simple conv_2d layer

* Fix bugs

* Correct implement BlockDesc destructor

* Fix bugs

* Fix unit test error

* Follow comments
---
 paddle/framework/backward.cc                       | 14 ++++++--------
 paddle/framework/block_desc.cc                     | 11 ++++++++++-
 paddle/framework/block_desc.h                      | 10 +++++++---
 paddle/pybind/protobuf.cc                          |  4 ++--
 python/paddle/v2/framework/framework.py            |  5 ++++-
 python/paddle/v2/framework/tests/test_layers.py    | 13 ++++++++++++-
 .../v2/framework/tests/test_protobuf_descs.py      |  4 +++-
 7 files changed, 44 insertions(+), 17 deletions(-)

diff --git a/paddle/framework/backward.cc b/paddle/framework/backward.cc
index ac80879c54..fb552fe344 100644
--- a/paddle/framework/backward.cc
+++ b/paddle/framework/backward.cc
@@ -309,8 +309,7 @@ static void CreateGradVarInBlock(
 }
 
 std::vector<std::unique_ptr<OpDescBind>> MakeOpGrad(
-    const std::unique_ptr<OpDescBind>& op_desc,
-    std::unordered_set<std::string>* no_grad_vars,
+    const OpDescBind* op_desc, std::unordered_set<std::string>* no_grad_vars,
     std::unordered_map<std::string, std::string>* grad_to_var) {
   std::vector<std::unique_ptr<OpDescBind>> grad_op_descs;
   // All input gradients of forwarding operator do not need to calculate.
@@ -357,7 +356,7 @@ std::vector<std::unique_ptr<OpDescBind>> MakeBlockBackward(
     std::unordered_set<std::string>* no_grad_vars,
     std::unordered_map<std::string, std::string>* grad_to_var) {
   BlockDescBind* cur_block = program_desc.Block(block_idx);
-  std::deque<std::unique_ptr<OpDescBind>>& op_descs = cur_block->ops_;
+  std::vector<OpDescBind*> op_descs = cur_block->AllOps();
   std::unordered_map<std::string, std::vector<size_t>> dup_out_ops;
   size_t grad_desc_idx = 0;
   std::vector<std::unique_ptr<OpDescBind>> backward_descs;
@@ -375,7 +374,7 @@ std::vector<std::unique_ptr<OpDescBind>> MakeBlockBackward(
           program_desc, step_block_idx, no_grad_vars, grad_to_var);
       BlockDescBind* backward_block = program_desc.AppendBlock(*cur_block);
       for (auto& ptr : backward_block_op_descs) {
-        backward_block->ops_.push_back(std::move(ptr));
+        backward_block->AppendAllocatedOp(std::move(ptr));
       }
       op_grads[0]->SetBlockAttr("step_block", *backward_block);
     }
@@ -432,7 +431,6 @@ ParamGradInfoMap AppendBackward(
 
   const int root_block_idx = 0;
   auto root_block = program_desc.Block(root_block_idx);
-  auto& all_ops = root_block->ops_;
 
   // insert fill one op for target
   // TODO(qiao) add some check to the target.
@@ -447,8 +445,8 @@ ParamGradInfoMap AppendBackward(
                      {{"shape", target_shape},
                       {"value", static_cast<float>(1.0)},
                       {"data_type", framework::DataType::FP32}}));
-  all_ops.push_back(std::move(fill_one_op));
-  size_t forward_op_num = all_ops.size();
+  root_block->AppendAllocatedOp(std::move(fill_one_op));
+  size_t forward_op_num = root_block->OpSize();
   size_t forward_block_num = program_desc.Size();
 
   // Insert backward operators
@@ -457,7 +455,7 @@ ParamGradInfoMap AppendBackward(
                                              &no_grad_var_names, &grad_to_var);
 
   for (auto& ptr : backward_op_descs) {
-    all_ops.push_back(std::move(ptr));
+    root_block->AppendAllocatedOp(std::move(ptr));
   }
   // Create Variable
 
diff --git a/paddle/framework/block_desc.cc b/paddle/framework/block_desc.cc
index ba970254e5..92ac302e46 100644
--- a/paddle/framework/block_desc.cc
+++ b/paddle/framework/block_desc.cc
@@ -19,11 +19,11 @@ namespace paddle {
 namespace framework {
 
 VarDescBind *BlockDescBind::Var(const std::string &name) {
-  need_update_ = true;
   auto it = vars_.find(name);
   if (it != vars_.end()) {
     return it->second.get();
   }
+  need_update_ = true;
   auto *var = new VarDescBind(name);
   vars_[name].reset(var);
   return var;
@@ -55,6 +55,11 @@ OpDescBind *BlockDescBind::AppendOp() {
   return ops_.back().get();
 }
 
+void BlockDescBind::AppendAllocatedOp(std::unique_ptr<OpDescBind> &&op_desc) {
+  need_update_ = true;
+  ops_.emplace_back(std::move(op_desc));
+}
+
 OpDescBind *BlockDescBind::PrependOp() {
   need_update_ = true;
   ops_.emplace_front(new OpDescBind());
@@ -70,6 +75,10 @@ std::vector<OpDescBind *> BlockDescBind::AllOps() const {
 }
 
 void BlockDescBind::Flush() {
+  for (auto &op_desc : ops_) {
+    op_desc->Flush();
+  }
+
   if (need_update_) {
     auto &op_field = *this->desc_->mutable_ops();
     this->ClearPBOps();
diff --git a/paddle/framework/block_desc.h b/paddle/framework/block_desc.h
index dd7b1228be..5e1f10c1ae 100644
--- a/paddle/framework/block_desc.h
+++ b/paddle/framework/block_desc.h
@@ -57,10 +57,16 @@ class BlockDescBind {
 
   OpDescBind *AppendOp();
 
+  void AppendAllocatedOp(std::unique_ptr<OpDescBind> &&op_desc);
+
   OpDescBind *PrependOp();
 
   std::vector<OpDescBind *> AllOps() const;
 
+  size_t OpSize() const { return ops_.size(); }
+
+  OpDescBind *Op(int idx) { return ops_.at(idx).get(); }
+
   void Flush();
 
   BlockDesc *Proto();
@@ -69,9 +75,7 @@ class BlockDescBind {
   void ClearPBOps();
   void ClearPBVars();
 
-  // FIXME(yuyang18): backward will access private data of BlockDesc.
-  // Mark it public temporary. We can fix it later.
- public:
+ private:
   ProgramDescBind *prog_;  // not_own
   BlockDesc *desc_;        // not_own
   bool need_update_;
diff --git a/paddle/pybind/protobuf.cc b/paddle/pybind/protobuf.cc
index fbdd673295..d9647717d2 100644
--- a/paddle/pybind/protobuf.cc
+++ b/paddle/pybind/protobuf.cc
@@ -162,8 +162,8 @@ void BindBlockDesc(py::module &m) {
            py::return_value_policy::reference)
       .def("all_vars", &BlockDescBind::AllVars,
            py::return_value_policy::reference)
-      .def("all_ops", &BlockDescBind::AllOps,
-           py::return_value_policy::reference)
+      .def("op_size", &BlockDescBind::OpSize)
+      .def("op", &BlockDescBind::Op, py::return_value_policy::reference)
       .def("serialize_to_string", [](BlockDescBind &block_desc) -> py::bytes {
         const BlockDesc *desc = block_desc.Proto();
         PADDLE_ENFORCE(desc->IsInitialized(),
diff --git a/python/paddle/v2/framework/framework.py b/python/paddle/v2/framework/framework.py
index 93e2218eab..5a8ded46ea 100644
--- a/python/paddle/v2/framework/framework.py
+++ b/python/paddle/v2/framework/framework.py
@@ -344,7 +344,10 @@ class Block(object):
                 self.create_var(name=var.name(), desc=var, type=var.type())
 
         # sync operators from cpp
-        ops_in_cpp = self.desc.all_ops()
+        ops_in_cpp = []
+        for op_idx in range(0, self.desc.op_size()):
+            ops_in_cpp.append(self.desc.op(op_idx))
+
         first_op_in_python = self.ops[0].desc
         last_op_in_python = self.ops[len(self.ops) - 1].desc
         start_index = None
diff --git a/python/paddle/v2/framework/tests/test_layers.py b/python/paddle/v2/framework/tests/test_layers.py
index 2ffadf7371..2d8c2e5518 100644
--- a/python/paddle/v2/framework/tests/test_layers.py
+++ b/python/paddle/v2/framework/tests/test_layers.py
@@ -17,6 +17,7 @@ class TestBook(unittest.TestCase):
 
         avg_cost = mean(x=cost, program=program)
         self.assertIsNotNone(avg_cost)
+        program.append_backward(avg_cost, set())
         print str(program)
 
     def test_recognize_digits_mlp(self):
@@ -34,7 +35,17 @@ class TestBook(unittest.TestCase):
         cost = cross_entropy(input=predict, label=label, program=program)
         avg_cost = mean(x=cost, program=program)
         self.assertIsNotNone(avg_cost)
-        print str(program)
+        # print str(program)
+
+    def test_simple_conv2d(self):
+        pd = core.ProgramDesc.__create_program_desc__()
+        program = Program(desc=pd)
+        images = data_layer(
+            name='pixel', shape=[3, 48, 48], data_type='int32', program=program)
+        conv2d_layer(
+            input=images, num_filters=3, filter_size=[4, 4], program=program)
+
+        # print str(program)
 
     def test_simple_conv2d(self):
         pd = core.ProgramDesc.__create_program_desc__()
diff --git a/python/paddle/v2/framework/tests/test_protobuf_descs.py b/python/paddle/v2/framework/tests/test_protobuf_descs.py
index 6ed8edf91c..2fd3d5d165 100644
--- a/python/paddle/v2/framework/tests/test_protobuf_descs.py
+++ b/python/paddle/v2/framework/tests/test_protobuf_descs.py
@@ -133,7 +133,9 @@ class TestBlockDesc(unittest.TestCase):
         op1 = block.append_op()
         op2 = block.append_op()
         op0 = block.prepend_op()
-        all_ops = block.all_ops()
+        all_ops = []
+        for idx in xrange(0, block.op_size()):
+            all_ops.append(block.op(idx))
         self.assertEqual(all_ops, [op0, op1, op2])
 
 

From c10b8e808fc88d96ce0b4f864014bd461098de87 Mon Sep 17 00:00:00 2001
From: kavyasrinet <kavyasrinet@baidu.com>
Date: Wed, 18 Oct 2017 16:21:16 -0700
Subject: [PATCH 20/29] Adding Proximal Gradient Descent (#4848)

* Adding Proximal Gradient Descent

* Fixing review comments
---
 paddle/operators/proximal_gd_op.cc            | 93 +++++++++++++++++++
 paddle/operators/proximal_gd_op.cu            | 19 ++++
 paddle/operators/proximal_gd_op.h             | 64 +++++++++++++
 .../v2/framework/tests/test_proximal_gd_op.py | 33 +++++++
 4 files changed, 209 insertions(+)
 create mode 100644 paddle/operators/proximal_gd_op.cc
 create mode 100644 paddle/operators/proximal_gd_op.cu
 create mode 100644 paddle/operators/proximal_gd_op.h
 create mode 100644 python/paddle/v2/framework/tests/test_proximal_gd_op.py

diff --git a/paddle/operators/proximal_gd_op.cc b/paddle/operators/proximal_gd_op.cc
new file mode 100644
index 0000000000..e4b014b9f5
--- /dev/null
+++ b/paddle/operators/proximal_gd_op.cc
@@ -0,0 +1,93 @@
+/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include "paddle/operators/proximal_gd_op.h"
+
+namespace paddle {
+namespace operators {
+
+class ProximalGDOp : public framework::OperatorWithKernel {
+ public:
+  using framework::OperatorWithKernel::OperatorWithKernel;
+
+ protected:
+  void InferShape(framework::InferShapeContext *ctx) const override {
+    PADDLE_ENFORCE(ctx->HasInput("Param"),
+                   "Input(Param) of ProximalGDOp should not be null.");
+    PADDLE_ENFORCE(ctx->HasInput("Grad"),
+                   "Input(Grad) of ProximalGDOp should not be null.");
+    PADDLE_ENFORCE(ctx->HasInput("LearningRate"),
+                   "Input(LearningRate) of ProximalGDOp should not be null.");
+
+    PADDLE_ENFORCE(ctx->HasOutput("ParamOut"),
+                   "Output(ParamOut) of ProximalGDOp should not be null.");
+
+    auto param_dim = ctx->GetInputDim("Param");
+    PADDLE_ENFORCE_EQ(param_dim, ctx->GetInputDim("Grad"),
+                      "Two input of ProximalGD Op's dimension must be same.");
+
+    auto lr_dim = ctx->GetInputDim("LearningRate");
+    PADDLE_ENFORCE_EQ(framework::product(lr_dim), 1,
+                      "Learning Rate should be a scalar.");
+
+    ctx->SetOutputDim("ParamOut", param_dim);
+  }
+};
+
+class ProximalGDOpMaker : public framework::OpProtoAndCheckerMaker {
+ public:
+  ProximalGDOpMaker(framework::OpProto *proto,
+                    framework::OpAttrChecker *op_checker)
+      : OpProtoAndCheckerMaker(proto, op_checker) {
+    AddInput("Param",
+             "(Tensor, default Tensor<float>) "
+             "Input parameter value that has to be updated.");
+    AddInput("Grad",
+             "(Tensor, default Tensor<float>) "
+             "Input gradient of the parameter.");
+    AddInput("LearningRate",
+             "(Tensor, default Tensor<float>) "
+             "The learning rate should be a tensor of size 1.");
+
+    AddOutput("ParamOut", "(Tensor) Output updated parameter value.");
+
+    AddAttr<float>("l1",
+                   "(float, default 0.0) "
+                   "L1 regularization strength.")
+        .SetDefault(0.0f);
+    AddAttr<float>("l2",
+                   "(float, default 0.0)"
+                   "L2 regularization strength.")
+        .SetDefault(0.0f);
+    AddComment(R"DOC(
+
+Optimizer that implements the proximal gradient descent algorithm.
+
+prox_param = param - learning_rate * grad
+param = sign(prox_param) / (1 + learning_rate * l2) *
+        max { |prox_param| - learning_rate * l1 , 0 }
+
+The paper that proposed Proximal Gradient Descent:
+(http://papers.nips.cc/paper/3793-efficient-learning-using-forward-backward-splitting.pdf)
+)DOC");
+  }
+};
+}  // namespace operators
+}  // namespace paddle
+
+namespace ops = paddle::operators;
+REGISTER_OP_WITHOUT_GRADIENT(proximal_gd, ops::ProximalGDOp,
+                             ops::ProximalGDOpMaker);
+REGISTER_OP_CPU_KERNEL(
+    proximal_gd, ops::ProximalGDOpKernel<paddle::platform::CPUPlace, float>);
diff --git a/paddle/operators/proximal_gd_op.cu b/paddle/operators/proximal_gd_op.cu
new file mode 100644
index 0000000000..26f4ebaa0f
--- /dev/null
+++ b/paddle/operators/proximal_gd_op.cu
@@ -0,0 +1,19 @@
+/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+You may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License. */
+
+#define EIGEN_USE_GPU
+#include "paddle/operators/proximal_gd_op.h"
+
+namespace ops = paddle::operators;
+REGISTER_OP_GPU_KERNEL(
+    proximal_gd, ops::ProximalGDOpKernel<paddle::platform::GPUPlace, float>);
diff --git a/paddle/operators/proximal_gd_op.h b/paddle/operators/proximal_gd_op.h
new file mode 100644
index 0000000000..bebda02041
--- /dev/null
+++ b/paddle/operators/proximal_gd_op.h
@@ -0,0 +1,64 @@
+/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#pragma once
+#include "paddle/framework/eigen.h"
+#include "paddle/framework/op_registry.h"
+
+namespace paddle {
+namespace operators {
+
+using Tensor = framework::Tensor;
+template <typename T, int MajorType = Eigen::RowMajor,
+          typename IndexType = Eigen::DenseIndex>
+using EigenVector = framework::EigenVector<T, MajorType, IndexType>;
+
+template <typename Place, typename T>
+class ProximalGDOpKernel : public framework::OpKernel<T> {
+ public:
+  void Compute(const framework::ExecutionContext& ctx) const override {
+    auto* param_out = ctx.Output<Tensor>("ParamOut");
+
+    param_out->mutable_data<T>(ctx.GetPlace());
+
+    auto grad = ctx.Input<Tensor>("Grad");
+
+    auto l1 = static_cast<T>(ctx.Attr<float>("l1"));
+    auto l2 = static_cast<T>(ctx.Attr<float>("l2"));
+
+    auto p = EigenVector<T>::Flatten(*ctx.Input<Tensor>("Param"));
+    auto g = EigenVector<T>::Flatten(*grad);
+    auto lr = EigenVector<T>::Flatten(*ctx.Input<Tensor>("LearningRate"));
+
+    auto p_out = EigenVector<T>::Flatten(*param_out);
+    auto place = ctx.GetEigenDevice<Place>();
+
+    Eigen::DSizes<int, 1> grad_dsize(grad->numel());
+
+    auto prox_param = p - lr.broadcast(grad_dsize) * g;
+    if (l1 > 0) {
+      p_out.device(place) =
+          prox_param.sign() *
+          (((prox_param.abs() - (lr * l1).broadcast(grad_dsize))
+                .cwiseMax(T(0.0))) /
+           (1.0 + (lr * l2).broadcast(grad_dsize)));
+    } else {
+      p_out.device(place) =
+          prox_param / (1.0 + (lr * l2).broadcast(grad_dsize));
+    }
+  }
+};
+
+}  // namespace operators
+}  // namespace paddle
diff --git a/python/paddle/v2/framework/tests/test_proximal_gd_op.py b/python/paddle/v2/framework/tests/test_proximal_gd_op.py
new file mode 100644
index 0000000000..9ca79ce6b3
--- /dev/null
+++ b/python/paddle/v2/framework/tests/test_proximal_gd_op.py
@@ -0,0 +1,33 @@
+import unittest
+import numpy as np
+from op_test import OpTest
+
+
+class TestProximalGDOp(OpTest):
+    def setUp(self):
+        self.op_type = "proximal_gd"
+        w = np.random.random((102, 105)).astype("float32")
+        g = np.random.random((102, 105)).astype("float32")
+        lr = np.array([0.1]).astype("float32")
+        l1 = 0.1
+        l2 = 0.2
+
+        self.inputs = {'Param': w, 'Grad': g, 'LearningRate': lr}
+        self.attrs = {'l1': l1, 'l2': l2}
+        prox_param = w - lr * g
+        param_out = 0.0
+        if l1 > 0.0:
+            x = np.abs(prox_param) - lr * l1
+            x[x < 0] = 0
+            param_out = np.sign(prox_param) * (x / (1.0 + lr * l2))
+        else:
+            param_out = prox_param / (1.0 + lr * l2)
+
+        self.outputs = {'ParamOut': param_out}
+
+    def test_check_output(self):
+        self.check_output()
+
+
+if __name__ == "__main__":
+    unittest.main()

From c93596d35b621959d28f16ffba7689a79bd9b068 Mon Sep 17 00:00:00 2001
From: fengjiayi <fengjiayi@baidu.com>
Date: Wed, 18 Oct 2017 17:21:32 -0700
Subject: [PATCH 21/29] unify layer names (#4913)

---
 python/paddle/v2/framework/layers.py          | 50 +++++++++----------
 .../paddle/v2/framework/tests/test_layers.py  | 38 +++++++-------
 2 files changed, 45 insertions(+), 43 deletions(-)

diff --git a/python/paddle/v2/framework/layers.py b/python/paddle/v2/framework/layers.py
index 1821da197e..c7397716c4 100644
--- a/python/paddle/v2/framework/layers.py
+++ b/python/paddle/v2/framework/layers.py
@@ -3,17 +3,17 @@ import paddle.v2.framework.core as core
 from paddle.v2.framework.framework import OpProtoHolder, Variable
 import re
 
-__all__ = ['fc_layer', 'data_layer', 'cross_entropy', 'conv2d_layer']
+__all__ = ['fc', 'data', 'cross_entropy', 'conv2d']
 
 
-def fc_layer(input,
-             size,
-             param_attr=None,
-             bias_attr=True,
-             name=None,
-             act=None,
-             num_flatten_dims=1,
-             program=None):
+def fc(input,
+       size,
+       param_attr=None,
+       bias_attr=True,
+       name=None,
+       act=None,
+       num_flatten_dims=1,
+       program=None):
     # create helper
     helper = LayerHelper('fc', **locals())
 
@@ -51,11 +51,11 @@ def fc_layer(input,
     return helper.append_activation(pre_activation)
 
 
-def data_layer(name,
-               shape,
-               data_type='float32',
-               type=core.VarDesc.VarType.LOD_TENSOR,
-               program=None):
+def data(name,
+         shape,
+         data_type='float32',
+         type=core.VarDesc.VarType.LOD_TENSOR,
+         program=None):
     helper = LayerHelper('data', **locals())
     shape = [-1] + shape  # append batch size as -1
     return helper.create_global_variable(
@@ -145,17 +145,17 @@ def square_error_cost(input, label, **kwargs):
     return square_out
 
 
-def conv2d_layer(input,
-                 num_filters,
-                 name=None,
-                 filter_size=[1, 1],
-                 act=None,
-                 groups=None,
-                 stride=[1, 1],
-                 padding=None,
-                 bias_attr=None,
-                 param_attr=None,
-                 program=None):
+def conv2d(input,
+           num_filters,
+           name=None,
+           filter_size=[1, 1],
+           act=None,
+           groups=None,
+           stride=[1, 1],
+           padding=None,
+           bias_attr=None,
+           param_attr=None,
+           program=None):
     helper = LayerHelper('conv2d', **locals())
     dtype = helper.input_dtype()
 
diff --git a/python/paddle/v2/framework/tests/test_layers.py b/python/paddle/v2/framework/tests/test_layers.py
index 2d8c2e5518..dbbb653538 100644
--- a/python/paddle/v2/framework/tests/test_layers.py
+++ b/python/paddle/v2/framework/tests/test_layers.py
@@ -1,4 +1,4 @@
-from paddle.v2.framework.layers import fc_layer, data_layer, cross_entropy, mean, square_error_cost, conv2d_layer
+import paddle.v2.framework.layers as layers
 from paddle.v2.framework.framework import Program, g_program
 import paddle.v2.framework.core as core
 import unittest
@@ -7,15 +7,16 @@ import unittest
 class TestBook(unittest.TestCase):
     def test_fit_a_line(self):
         program = Program()
-        x = data_layer(
+        x = layers.data(
             name='x', shape=[13], data_type='float32', program=program)
-        y_predict = fc_layer(input=x, size=1, act=None, program=program)
+        y_predict = layers.fc(input=x, size=1, act=None, program=program)
 
-        y = data_layer(
+        y = layers.data(
             name='y', shape=[1], data_type='float32', program=program)
-        cost = square_error_cost(input=y_predict, label=y, program=program)
+        cost = layers.square_error_cost(
+            input=y_predict, label=y, program=program)
 
-        avg_cost = mean(x=cost, program=program)
+        avg_cost = layers.mean(x=cost, program=program)
         self.assertIsNotNone(avg_cost)
         program.append_backward(avg_cost, set())
         print str(program)
@@ -24,16 +25,18 @@ class TestBook(unittest.TestCase):
         program = Program()
 
         # Change g_program, so the rest layers use `g_program`
-        images = data_layer(
+        images = layers.data(
             name='pixel', shape=[784], data_type='float32', program=program)
-        label = data_layer(
+        label = layers.data(
             name='label', shape=[1], data_type='int32', program=program)
-        hidden1 = fc_layer(input=images, size=128, act='relu', program=program)
-        hidden2 = fc_layer(input=hidden1, size=64, act='relu', program=program)
-        predict = fc_layer(
-            input=hidden2, size=10, act='softmax', program=program)
-        cost = cross_entropy(input=predict, label=label, program=program)
-        avg_cost = mean(x=cost, program=program)
+        hidden1 = layers.fc(input=images, size=128, act='relu', program=program)
+        hidden2 = layers.fc(input=hidden1, size=64, act='relu', program=program)
+        predict = layers.fc(input=hidden2,
+                            size=10,
+                            act='softmax',
+                            program=program)
+        cost = layers.cross_entropy(input=predict, label=label, program=program)
+        avg_cost = layers.mean(x=cost, program=program)
         self.assertIsNotNone(avg_cost)
         # print str(program)
 
@@ -48,11 +51,10 @@ class TestBook(unittest.TestCase):
         # print str(program)
 
     def test_simple_conv2d(self):
-        pd = core.ProgramDesc.__create_program_desc__()
-        program = Program(desc=pd)
-        images = data_layer(
+        program = Program()
+        images = layers.data(
             name='pixel', shape=[3, 48, 48], data_type='int32', program=program)
-        conv2d_layer(
+        layers.conv2d(
             input=images, num_filters=3, filter_size=[4, 4], program=program)
 
         print str(program)

From c5b411c51533c93459661673e797663ed681d8de Mon Sep 17 00:00:00 2001
From: Yang Yang <yangyang62@baidu.com>
Date: Thu, 19 Oct 2017 00:46:22 +0000
Subject: [PATCH 22/29] make compatible to new programDescBind

---
 paddle/framework/prune_test.cc | 23 +++++------------------
 1 file changed, 5 insertions(+), 18 deletions(-)

diff --git a/paddle/framework/prune_test.cc b/paddle/framework/prune_test.cc
index a8faf1891e..3ab4b43d92 100644
--- a/paddle/framework/prune_test.cc
+++ b/paddle/framework/prune_test.cc
@@ -50,17 +50,8 @@ void AddOp(const std::string &type, const f::VariableNameMap &inputs,
   op->SetAttrMap(attrs);
 }
 
-f::ProgramDesc *GetNewProgramDesc() {
-  auto *program_desc = new f::ProgramDesc();
-  auto *root_block = program_desc->add_blocks();
-  root_block->set_idx(0);
-  root_block->set_parent_idx(-1);
-  return program_desc;
-}
-
 TEST(Prune, one_operator) {
-  f::ProgramDesc *program_desc = GetNewProgramDesc();
-  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::ProgramDescBind program;
   f::BlockDescBind *block = program.Block(0);
 
   AddOp("one_one", {{"input", {"a"}}}, {{"output", {"b"}}}, {}, block);
@@ -77,8 +68,7 @@ TEST(Prune, one_operator) {
 }
 
 TEST(Prune, forward) {
-  f::ProgramDesc *program_desc = GetNewProgramDesc();
-  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::ProgramDescBind program;
   f::BlockDescBind *block = program.Block(0);
 
   AddOp("one_one", {{"input", {"a"}}}, {{"output", {"b"}}}, {}, block);
@@ -97,8 +87,7 @@ TEST(Prune, forward) {
 }
 
 TEST(Prune, multi_input_op) {
-  f::ProgramDesc *program_desc = GetNewProgramDesc();
-  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::ProgramDescBind program;
   f::BlockDescBind *block = program.Block(0);
 
   AddOp("one_one", {{"input", {"a0"}}}, {{"output", {"b0"}}}, {}, block);
@@ -116,8 +105,7 @@ TEST(Prune, multi_input_op) {
 }
 
 TEST(Prune, multi_output_op) {
-  f::ProgramDesc *program_desc = GetNewProgramDesc();
-  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::ProgramDescBind program;
   f::BlockDescBind *block = program.Block(0);
 
   AddOp("one_two", {{"input", {"a"}}}, {{"output", {"b", "c"}}}, {}, block);
@@ -133,8 +121,7 @@ TEST(Prune, multi_output_op) {
 }
 
 TEST(Prune, multi_target) {
-  f::ProgramDesc *program_desc = GetNewProgramDesc();
-  f::ProgramDescBind &program = f::ProgramDescBind::Instance(program_desc);
+  f::ProgramDescBind program;
   f::BlockDescBind *block = program.Block(0);
 
   AddOp("one_two", {{"input", {"a"}}}, {{"output", {"b", "c"}}}, {}, block);

From f6e1d959d2f54a8baa183d76c8134f27c60edcba Mon Sep 17 00:00:00 2001
From: Yu Yang <yuyang18@baidu.com>
Date: Wed, 18 Oct 2017 18:22:31 -0700
Subject: [PATCH 23/29] Expose VarDesc::persistable to Python (#4911)

---
 paddle/framework/var_desc.h             |  4 ++++
 paddle/pybind/protobuf.cc               | 23 +++++++++++++----------
 python/paddle/v2/framework/framework.py | 20 +++++++++++++++++++-
 3 files changed, 36 insertions(+), 11 deletions(-)

diff --git a/paddle/framework/var_desc.h b/paddle/framework/var_desc.h
index 688a46f839..af4c26ca0a 100644
--- a/paddle/framework/var_desc.h
+++ b/paddle/framework/var_desc.h
@@ -79,6 +79,10 @@ class VarDescBind {
 
   void SetType(VarDesc::VarType type) { desc_.set_type(type); }
 
+  bool Persistable() const { return desc_.persistable(); }
+
+  void SetPersistable(bool persistable) { desc_.set_persistable(persistable); }
+
  private:
   const TensorDesc &tensor_desc() const;
   TensorDesc *mutable_tensor_desc();
diff --git a/paddle/pybind/protobuf.cc b/paddle/pybind/protobuf.cc
index d9647717d2..a4fb9b7c07 100644
--- a/paddle/pybind/protobuf.cc
+++ b/paddle/pybind/protobuf.cc
@@ -202,16 +202,19 @@ void BindVarDsec(py::module &m) {
       .def("set_lod_level", &VarDescBind::SetLoDLevel)
       .def("type", &VarDescBind::GetType)
       .def("set_type", &VarDescBind::SetType)
-      .def("serialize_to_string", [](VarDescBind &var_desc) -> py::bytes {
-        const VarDesc *desc = var_desc.Proto();
-        PADDLE_ENFORCE(desc->IsInitialized(),
-                       "VarDesc has not been initialized.");
-        std::string res;
-        PADDLE_ENFORCE(
-            desc->SerializeToString(&res),
-            "Serialize VarDesc Error. This could be a bug of Paddle.");
-        return res;
-      });
+      .def("serialize_to_string",
+           [](VarDescBind &var_desc) -> py::bytes {
+             const VarDesc *desc = var_desc.Proto();
+             PADDLE_ENFORCE(desc->IsInitialized(),
+                            "VarDesc has not been initialized.");
+             std::string res;
+             PADDLE_ENFORCE(
+                 desc->SerializeToString(&res),
+                 "Serialize VarDesc Error. This could be a bug of Paddle.");
+             return res;
+           })
+      .def("persistable", &VarDescBind::Persistable)
+      .def("set_persistable", &VarDescBind::SetPersistable);
 
   py::enum_<VarDesc::VarType>(var_desc, "VarType", "")
       .value("LOD_TENSOR", VarDesc::LOD_TENSOR)
diff --git a/python/paddle/v2/framework/framework.py b/python/paddle/v2/framework/framework.py
index 5a8ded46ea..8c63ca9644 100644
--- a/python/paddle/v2/framework/framework.py
+++ b/python/paddle/v2/framework/framework.py
@@ -15,6 +15,7 @@ class Variable(object):
                  shape=None,
                  dtype=None,
                  lod_level=None,
+                 persistable=False,
                  **kwargs):
         self.block = block
 
@@ -70,6 +71,17 @@ class Variable(object):
                                      "lod_level is {2}. They are not "
                                      "matched".format(self.name, self.lod_level,
                                                       lod_level))
+        if persistable is not None:
+            if is_new_var:
+                self.desc.set_persistable(persistable)
+            else:
+                if persistable != self.persistable:
+                    raise ValueError(
+                        "Variable {0} has been created before."
+                        "The previous persistable is {1}; the new "
+                        "persistable is {2}. They are not matched".format(
+                            self.name, self.persistable, persistable))
+
         self.block.vars[name] = self
         self.op = None
 
@@ -80,6 +92,10 @@ class Variable(object):
 
     __repr__ = __str__
 
+    @property
+    def persistable(self):
+        return self.desc.persistable()
+
     @property
     def name(self):
         return self.desc.name()
@@ -445,7 +461,9 @@ class Parameter(Variable):
             if each < 0:
                 raise ValueError("Parameter shape should not be related with "
                                  "batch-size")
-        Variable.__init__(self, block, shape=shape, dtype=dtype, **kwargs)
+
+        Variable.__init__(
+            self, block, persistable=True, shape=shape, dtype=dtype, **kwargs)
         self.trainable = kwargs.get('trainable', True)
         self.init_attr = kwargs.get('initialize_attr', {
             'type': 'uniform_random',

From e9249d16cb3078e0a1344513d752c9e314ab86f1 Mon Sep 17 00:00:00 2001
From: Yu Yang <yuyang18@baidu.com>
Date: Wed, 18 Oct 2017 18:28:50 -0700
Subject: [PATCH 24/29] Add glog as dependencies of ops (#4908)

* Add glog as dependencies of ops

* Use VLOG to logging some information is helpful when we debug Paddle

* Fix Unittests
---
 paddle/framework/CMakeLists.txt | 4 ++--
 paddle/framework/op_registry.h  | 2 ++
 paddle/framework/operator.h     | 4 +++-
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/paddle/framework/CMakeLists.txt b/paddle/framework/CMakeLists.txt
index 4bc3fdeeea..05ae2daf6a 100644
--- a/paddle/framework/CMakeLists.txt
+++ b/paddle/framework/CMakeLists.txt
@@ -23,10 +23,10 @@ cc_library(proto_desc SRCS var_desc.cc op_desc.cc block_desc.cc program_desc.cc
 cc_library(op_proto_maker SRCS op_proto_maker.cc DEPS framework_proto attribute)
 cc_test(op_proto_maker_test SRCS op_proto_maker_test.cc DEPS op_proto_maker)
 cc_library(op_info SRCS op_info.cc DEPS attribute framework_proto)
-cc_library(operator SRCS operator.cc DEPS op_info device_context tensor scope proto_desc)
+cc_library(operator SRCS operator.cc DEPS op_info device_context tensor scope proto_desc glog)
 cc_test(operator_test SRCS operator_test.cc DEPS operator op_registry)
 
-cc_library(op_registry SRCS op_registry.cc DEPS op_proto_maker op_info operator)
+cc_library(op_registry SRCS op_registry.cc DEPS op_proto_maker op_info operator glog)
 cc_test(op_registry_test SRCS op_registry_test.cc DEPS op_registry)
 
 py_proto_compile(framework_py_proto SRCS framework.proto)
diff --git a/paddle/framework/op_registry.h b/paddle/framework/op_registry.h
index d25b4abccb..ed85c386ec 100644
--- a/paddle/framework/op_registry.h
+++ b/paddle/framework/op_registry.h
@@ -20,6 +20,8 @@ limitations under the License. */
 #include <typeinfo>
 #include <unordered_map>
 #include <unordered_set>
+
+#include "glog/logging.h"  // For VLOG()
 #include "paddle/framework/attribute.h"
 #include "paddle/framework/details/op_registry.h"
 #include "paddle/framework/framework.pb.h"
diff --git a/paddle/framework/operator.h b/paddle/framework/operator.h
index cf15f9933a..12cd307297 100644
--- a/paddle/framework/operator.h
+++ b/paddle/framework/operator.h
@@ -20,12 +20,13 @@ limitations under the License. */
 #include <unordered_map>
 #include <vector>
 
-#include "op_info.h"
+#include "glog/logging.h"  // For VLOG
 #include "paddle/framework/attribute.h"
 #include "paddle/framework/block_desc.h"
 #include "paddle/framework/data_type.h"
 #include "paddle/framework/framework.pb.h"
 #include "paddle/framework/lod_tensor.h"
+#include "paddle/framework/op_info.h"
 #include "paddle/framework/scope.h"
 #include "paddle/framework/shape_inference.h"
 #include "paddle/framework/tensor.h"
@@ -573,6 +574,7 @@ class OperatorWithKernel : public OperatorBase {
 
   void Run(const Scope& scope,
            const platform::DeviceContext& dev_ctx) const final {
+    VLOG(3) << "Running operator " << this->Type();
     RuntimeInferShapeContext infer_shape_ctx(*this, scope);
     this->InferShape(&infer_shape_ctx);
 

From 3ca3a200ab14454954ba44de3deba5caea229f51 Mon Sep 17 00:00:00 2001
From: "Yang Yang(Tony)" <yangyang62@baidu.com>
Date: Wed, 18 Oct 2017 19:00:53 -0700
Subject: [PATCH 25/29] Prune Design Doc (#4732)

* Create prune.md

* modification based on comment

* remove insertion

* rename id to block_id

* Update prune.md

* formatting
---
 doc/design/prune.md | 63 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 doc/design/prune.md

diff --git a/doc/design/prune.md b/doc/design/prune.md
new file mode 100644
index 0000000000..4a5cf10c79
--- /dev/null
+++ b/doc/design/prune.md
@@ -0,0 +1,63 @@
+# Prune
+
+## Motivation
+
+We want to support running inference, training and checkpointing in one `ProgramDesc`. We implement 
+`void Prune(const ProgramDesc* input, ProgramDesc* output)` function, which takes a `ProgramDesc`
+and generate a pruned `ProgramDesc`.
+
+## Challenge
+
+Pruning need to support both variables and operators being evaluation targets. Consider the following
+different situations.
+
+```python
+# Case 1: run foward pass.
+cost_np = session.run(target=cost)
+# Case 2: run backward passing.
+opts_np, _ = session.run(target=[cost, opt])
+# Case 3: run checkpointing
+_ = session.run(target=checkpoint)
+```
+
+## Solution
+
+To support evaluation of operators, we add `is_target` field in the `OpDesc`.
+
+```c++
+message OpDesc {
+  required string type = 3;
+  repeated Var inputs = 1;
+  repeated Var outputs = 2;
+  repeated Attr attrs = 4;
+  optional bool is_target = 5 [ default = false ];
+};
+```
+
+To support evaluation of variables, we add [fetch_op](https://github.com/PaddlePaddle/Paddle/pull/4599).
+For each variable in the `target`, we insert a `fetch_op` into the `ProgramDesc` with `variable` being
+`fetch_op`'s input. Then we also set `fetch_op` is a target.
+
+### Algorithm
+
+If an operator needs to be run, it must fall into one of the following cases:
+
+1. It is the target.
+2. It is depended by some other ops, meaning its output is some other op's input.
+
+The first case can be checked by `op_desc.is_traget()` . The second case can be implement as
+
+```c++
+bool HasDependentVar(const OpDesc& op_desc, const std::set<string>& dependent_vars) {
+  for (auto& var : op_desc.outputs()) {
+    for (auto& argu : var.arguments()) {
+      if (dependent_vars.count(argu) != 0) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+```
+
+Then the whole algorithm can be implemented as the following [code](https://github.com/tonyyang-svail/Paddle/blob/prune_impl/paddle/framework/prune.cc).

From 4018754d666bc8045177e295850d941de4b264df Mon Sep 17 00:00:00 2001
From: wanghaoshuang <wanghaoshuang@baidu.com>
Date: Thu, 19 Oct 2017 10:03:47 +0800
Subject: [PATCH 26/29] fix LoDTensor::lod_element to get last element in level

---
 paddle/framework/lod_tensor.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/paddle/framework/lod_tensor.h b/paddle/framework/lod_tensor.h
index 4db36ee766..3eab91b0d1 100644
--- a/paddle/framework/lod_tensor.h
+++ b/paddle/framework/lod_tensor.h
@@ -78,7 +78,7 @@ class LoDTensor : public Tensor {
    */
   size_t lod_element(size_t level, size_t elem) const {
     PADDLE_ENFORCE_LT(level, NumLevels());
-    PADDLE_ENFORCE_LT(elem, NumElements(level));
+    PADDLE_ENFORCE_LE(elem, NumElements(level));
     return (lod_)[level][elem];
   }
 

From 47f773ddb21b01e183f258dad1b1b54137b60998 Mon Sep 17 00:00:00 2001
From: Yu Yang <yuyang18@baidu.com>
Date: Wed, 18 Oct 2017 19:28:23 -0700
Subject: [PATCH 27/29] Copy Constructor for ProgramDesc (#4895)

* Implement FC layer with helper

* Update LayerHelper

* Add debug string for Python ProtoBuf

and Rename `Sync` to `Flush`

* Add check of ProtoBuf initialization

* Layer wrapper for FC

* Fix unittest

* Fix CI

* Add code generator

* AttributeChecker Better error log and speicalize bool

Since lots of types can be cast to bool

* Complete mlp, fit_a_line

* Implementation of simple conv_2d layer

* Fix bugs

* Change ProgramDesc not a global variable

* Polish code style

* Stash

* Correct implement BlockDesc destructor

* Correct implement BlockDesc destructor

* Unify program as parameter name

* Fix bugs

* Add unittest

* Fix unit test error

* Remove unused functions

* Add clone for Python Program

* Compare OpDescBind directly
---
 paddle/framework/CMakeLists.txt               |  1 +
 paddle/framework/block_desc.cc                | 13 +++
 paddle/framework/block_desc.h                 | 13 +++
 paddle/framework/program_desc.cc              |  9 ++
 paddle/framework/program_desc.h               |  4 +-
 paddle/framework/program_desc_test.cc         | 83 +++++++++++++++++++
 paddle/pybind/protobuf.cc                     |  4 +
 python/paddle/v2/framework/framework.py       | 38 ++++++---
 .../paddle/v2/framework/tests/test_program.py | 18 ++++
 9 files changed, 168 insertions(+), 15 deletions(-)
 create mode 100644 paddle/framework/program_desc_test.cc

diff --git a/paddle/framework/CMakeLists.txt b/paddle/framework/CMakeLists.txt
index 1a6f90c1ef..6e32a1c99b 100644
--- a/paddle/framework/CMakeLists.txt
+++ b/paddle/framework/CMakeLists.txt
@@ -20,6 +20,7 @@ proto_library(framework_proto SRCS framework.proto)
 
 cc_library(attribute SRCS attribute.cc DEPS framework_proto)
 cc_library(proto_desc SRCS var_desc.cc op_desc.cc block_desc.cc program_desc.cc DEPS attribute ddim op_info)
+cc_test(program_desc_test SRCS program_desc_test.cc DEPS proto_desc)
 cc_library(op_proto_maker SRCS op_proto_maker.cc DEPS framework_proto attribute)
 cc_test(op_proto_maker_test SRCS op_proto_maker_test.cc DEPS op_proto_maker)
 cc_library(op_info SRCS op_info.cc DEPS attribute framework_proto)
diff --git a/paddle/framework/block_desc.cc b/paddle/framework/block_desc.cc
index 92ac302e46..21d4fdaf06 100644
--- a/paddle/framework/block_desc.cc
+++ b/paddle/framework/block_desc.cc
@@ -107,6 +107,19 @@ BlockDesc *BlockDescBind::Proto() {
   Flush();
   return desc_;
 }
+BlockDescBind::BlockDescBind(const BlockDescBind &other, BlockDesc *desc,
+                             ProgramDescBind *prog)
+    : prog_(prog), desc_(desc) {
+  need_update_ = true;
+  for (auto &op : other.ops_) {
+    ops_.emplace_back(new OpDescBind(*op));
+  }
+
+  for (auto &it : other.vars_) {
+    auto *var = new VarDescBind(*it.second);
+    vars_[it.first].reset(var);
+  }
+}
 
 void BlockDescBind::ClearPBOps() {
   auto ops = this->desc_->mutable_ops();
diff --git a/paddle/framework/block_desc.h b/paddle/framework/block_desc.h
index 5e1f10c1ae..7d1d33f686 100644
--- a/paddle/framework/block_desc.h
+++ b/paddle/framework/block_desc.h
@@ -16,8 +16,10 @@ limitations under the License. */
 
 #include <deque>
 #include <memory>
+#include <set>
 #include <unordered_map>
 #include <vector>
+
 #include "paddle/framework/op_desc.h"
 #include "paddle/framework/var_desc.h"
 #include "paddle/platform/macros.h"
@@ -36,6 +38,9 @@ class BlockDescBind {
   BlockDescBind(ProgramDescBind *prog, BlockDesc *desc)
       : prog_(prog), desc_(desc), need_update_(false) {}
 
+  BlockDescBind(const BlockDescBind &other, BlockDesc *desc,
+                ProgramDescBind *prog);
+
   ~BlockDescBind() {
     this->ClearPBVars();
     this->ClearPBOps();
@@ -51,6 +56,14 @@ class BlockDescBind {
 
   bool HasVar(const std::string &var_name) const;
 
+  std::set<std::string> LocalVarNames() const {
+    std::set<std::string> var_names;
+    for (auto &var : vars_) {
+      var_names.insert(var.first);
+    }
+    return var_names;
+  }
+
   std::vector<VarDescBind *> AllVars() const;
 
   BlockDescBind *ParentBlock() const;
diff --git a/paddle/framework/program_desc.cc b/paddle/framework/program_desc.cc
index df846f115a..e2349cefe0 100644
--- a/paddle/framework/program_desc.cc
+++ b/paddle/framework/program_desc.cc
@@ -39,5 +39,14 @@ ProgramDescBind::ProgramDescBind() {
   block->set_parent_idx(-1);
   blocks_.emplace_back(new BlockDescBind(this, block));
 }
+
+ProgramDescBind::ProgramDescBind(const ProgramDescBind &o) {
+  prog_ = o.prog_;
+
+  for (int i = 0; i < prog_.blocks_size(); ++i) {
+    auto *block = prog_.mutable_blocks(i);
+    blocks_.emplace_back(new BlockDescBind(*o.blocks_[i], block, this));
+  }
+}
 }  // namespace framework
 }  // namespace paddle
diff --git a/paddle/framework/program_desc.h b/paddle/framework/program_desc.h
index 514b62654d..20cc1a2325 100644
--- a/paddle/framework/program_desc.h
+++ b/paddle/framework/program_desc.h
@@ -28,6 +28,8 @@ class ProgramDescBind {
  public:
   ProgramDescBind();
 
+  ProgramDescBind(const ProgramDescBind &o);
+
   BlockDescBind *AppendBlock(const BlockDescBind &parent);
 
   BlockDescBind *Block(size_t idx) { return blocks_[idx].get(); }
@@ -40,8 +42,6 @@ class ProgramDescBind {
   ProgramDesc prog_;
 
   std::vector<std::unique_ptr<BlockDescBind>> blocks_;
-
-  DISABLE_COPY_AND_ASSIGN(ProgramDescBind);
 };
 }  // namespace framework
 }  // namespace paddle
diff --git a/paddle/framework/program_desc_test.cc b/paddle/framework/program_desc_test.cc
new file mode 100644
index 0000000000..32ee275429
--- /dev/null
+++ b/paddle/framework/program_desc_test.cc
@@ -0,0 +1,83 @@
+/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License. */
+
+#include "paddle/framework/program_desc.h"
+#include "gtest/gtest.h"
+#include "paddle/framework/block_desc.h"
+
+namespace paddle {
+namespace framework {
+TEST(ProgramDesc, copy_ctor) {
+  ProgramDescBind program;
+  auto* global_block = program.Block(0);
+  auto* x = global_block->Var("X");
+  x->SetType(VarDesc_VarType_LOD_TENSOR);
+  x->SetLoDLevel(0);
+  x->SetDataType(FP32);
+  x->SetShape({1000, 784});
+
+  auto* y = global_block->Var("Y");
+  y->SetType(VarDesc_VarType_LOD_TENSOR);
+  y->SetLoDLevel(0);
+  y->SetDataType(FP32);
+  y->SetShape({784, 100});
+
+  auto* op = global_block->AppendOp();
+  op->SetType("mul");
+  op->SetInput("X", {x->Name()});
+  op->SetInput("Y", {y->Name()});
+
+  auto* out = global_block->Var("Out");
+  out->SetType(VarDesc_VarType_LOD_TENSOR);
+  op->SetOutput("Y", {out->Name()});
+
+  ProgramDescBind program_copy(program);
+
+  auto* global_block_copy = program_copy.Block(0);
+  ASSERT_NE(global_block, global_block_copy);
+
+  auto assert_same_var = [&](const std::string& name, VarDescBind* var_before) {
+    ASSERT_TRUE(global_block_copy->HasVar(name));
+    auto* copy = global_block_copy->Var(name);
+    ASSERT_NE(copy, var_before);
+    ASSERT_EQ(copy->Name(), var_before->Name());
+    ASSERT_EQ(copy->GetType(), var_before->GetType());
+    ASSERT_EQ(copy->Shape(), var_before->Shape());
+    ASSERT_EQ(copy->Proto()->SerializeAsString(),
+              var_before->Proto()->SerializeAsString());
+  };
+
+  ASSERT_EQ(global_block->LocalVarNames(), global_block_copy->LocalVarNames());
+  ASSERT_EQ(3, global_block_copy->LocalVarNames().size());
+  assert_same_var("X", x);
+  assert_same_var("Y", y);
+  assert_same_var("Out", out);
+
+  for (size_t i = 0; i < global_block->OpSize(); ++i) {
+    auto op_origin = global_block->Op(i);
+    auto op_copy = global_block->Op(i);
+
+    ASSERT_EQ(op_origin->Type(), op_copy->Type());
+    ASSERT_EQ(op_origin->Inputs(), op_copy->Inputs());
+    ASSERT_EQ(op_origin->Outputs(), op_copy->Outputs());
+
+    ASSERT_EQ(op_copy->Proto()->SerializeAsString(),
+              op_origin->Proto()->SerializeAsString());
+  }
+
+  // Not check block's protostr are same it because the order of vars could be
+  // different and it is correct.
+}
+}  // namespace framework
+}  // namespace paddle
\ No newline at end of file
diff --git a/paddle/pybind/protobuf.cc b/paddle/pybind/protobuf.cc
index a4fb9b7c07..58739d888a 100644
--- a/paddle/pybind/protobuf.cc
+++ b/paddle/pybind/protobuf.cc
@@ -101,6 +101,10 @@ using namespace paddle::framework;  // NOLINT
 void BindProgramDesc(py::module &m) {
   py::class_<ProgramDescBind>(m, "ProgramDesc", "")
       .def(py::init<>())
+      .def("__init__",
+           [](ProgramDescBind &self, const ProgramDescBind &other) {
+             new (&self) ProgramDescBind(other);
+           })
       .def("append_block", &ProgramDescBind::AppendBlock,
            py::return_value_policy::reference)
       .def("append_backward",
diff --git a/python/paddle/v2/framework/framework.py b/python/paddle/v2/framework/framework.py
index 8c63ca9644..9c032400a1 100644
--- a/python/paddle/v2/framework/framework.py
+++ b/python/paddle/v2/framework/framework.py
@@ -364,18 +364,22 @@ class Block(object):
         for op_idx in range(0, self.desc.op_size()):
             ops_in_cpp.append(self.desc.op(op_idx))
 
-        first_op_in_python = self.ops[0].desc
-        last_op_in_python = self.ops[len(self.ops) - 1].desc
-        start_index = None
-        end_index = None
-        for index in range(len(ops_in_cpp)):
-            if first_op_in_python == ops_in_cpp[index]:
-                start_index = index
-            if last_op_in_python == ops_in_cpp[index]:
-                end_index = index
-        assert start_index is not None
-        assert end_index is not None
-        assert start_index <= end_index
+        if len(self.ops) != 0:
+            first_op_in_python = self.ops[0].desc
+            last_op_in_python = self.ops[len(self.ops) - 1].desc
+            start_index = None
+            end_index = None
+            for index in range(len(ops_in_cpp)):
+                if first_op_in_python == ops_in_cpp[index]:
+                    start_index = index
+                if last_op_in_python == ops_in_cpp[index]:
+                    end_index = index
+            assert start_index is not None
+            assert end_index is not None
+            assert start_index <= end_index
+        else:
+            start_index = 0
+            end_index = -1
 
         # sync ops append to the head of cpp_ops
         for index in range((start_index - 1 - 1), -1, -1):
@@ -413,7 +417,15 @@ class Program(object):
         proto = framework_pb2.ProgramDesc.FromString(str(protostr))
         return proto.__str__()
 
-    __repr__ = __str__
+    def clone(self):
+        p = Program()
+        p.desc = core.ProgramDesc(self.desc)
+        p.blocks = [Block(p, i) for i in xrange(self.desc.num_blocks())]
+        p.sync_with_cpp()
+        return p
+
+    def __repr__(self):
+        return str(self)
 
     def global_block(self):
         return self.blocks[0]
diff --git a/python/paddle/v2/framework/tests/test_program.py b/python/paddle/v2/framework/tests/test_program.py
index c98dc3492b..8d8dd46898 100644
--- a/python/paddle/v2/framework/tests/test_program.py
+++ b/python/paddle/v2/framework/tests/test_program.py
@@ -34,6 +34,24 @@ class TestProgram(unittest.TestCase):
         self.assertEqual(1, b.idx)
         self.assertEqual(0, b.parent_idx)
 
+    def test_program_clone(self):
+        prog = Program()
+
+        x = prog.global_block().create_var(
+            name='X', shape=[1000, 784], dtype='float32')
+
+        y = prog.global_block().create_var(
+            name='Y', shape=[784, 100], dtype='float32')
+        out = prog.global_block().create_var(name='Out', dtype='float32')
+        prog.global_block().append_op(
+            type="mul", inputs={'X': [x],
+                                'Y': [y]}, outputs={'Out': [out]})
+
+        # FIXME(yuyang18): We manual compare the output string, since the order
+        # of variable could be changed.
+        print prog
+        print prog.clone()
+
     def test_append_backward(self):
         prog = Program.instance()
         block = prog.global_block()

From edb6aba69855b64c28f123f024a0d82422becb32 Mon Sep 17 00:00:00 2001
From: wanghaoshuang <wanghaoshuang@baidu.com>
Date: Thu, 19 Oct 2017 11:07:35 +0800
Subject: [PATCH 28/29] make lod_element return std::pair

---
 paddle/framework/lod_tensor.h       | 8 ++++----
 paddle/framework/lod_tensor_test.cu | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/paddle/framework/lod_tensor.h b/paddle/framework/lod_tensor.h
index 3eab91b0d1..3d893baa35 100644
--- a/paddle/framework/lod_tensor.h
+++ b/paddle/framework/lod_tensor.h
@@ -74,12 +74,12 @@ class LoDTensor : public Tensor {
   LoD lod() const { return lod_; }
 
   /*
-   * Get a element from LoD.
+   * Get the start offset and end offset of an  element from LoD.
    */
-  size_t lod_element(size_t level, size_t elem) const {
+  std::pair<size_t, size_t> lod_element(size_t level, size_t elem) const {
     PADDLE_ENFORCE_LT(level, NumLevels());
-    PADDLE_ENFORCE_LE(elem, NumElements(level));
-    return (lod_)[level][elem];
+    PADDLE_ENFORCE_LT(elem, NumElements(level));
+    return std::make_pair((lod_)[level][elem], (lod_)[level][elem + 1]);
   }
 
   /*
diff --git a/paddle/framework/lod_tensor_test.cu b/paddle/framework/lod_tensor_test.cu
index 647d07536d..25041024cb 100644
--- a/paddle/framework/lod_tensor_test.cu
+++ b/paddle/framework/lod_tensor_test.cu
@@ -36,8 +36,8 @@ TEST(LoDTensor, LoDInGPU) {
   lod_tensor.mutable_data<float>(place);
 
   lod_tensor.set_lod(src_lod);
-  CHECK_EQ(lod_tensor.lod_element(0, 2), 4UL);
-  CHECK_EQ(lod_tensor.lod_element(0, 4), 8UL);
+  CHECK_EQ(lod_tensor.lod_element(0, 2).first, 4UL);
+  CHECK_EQ(lod_tensor.lod_element(0, 4).first, 8UL);
 
   auto lod = lod_tensor.lod();
 

From d253df742c1400ee52fc7628671357da4ef3fa40 Mon Sep 17 00:00:00 2001
From: Qiao Longfei <qiaolongfei@baidu.com>
Date: Wed, 18 Oct 2017 20:12:55 -0700
Subject: [PATCH 29/29] remove Program.instance (#4915)

* remove Program.instance

* fix test_program.py
---
 python/paddle/v2/framework/framework.py          | 10 +---------
 python/paddle/v2/framework/tests/test_program.py |  2 +-
 2 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/python/paddle/v2/framework/framework.py b/python/paddle/v2/framework/framework.py
index 9c032400a1..a24c78171e 100644
--- a/python/paddle/v2/framework/framework.py
+++ b/python/paddle/v2/framework/framework.py
@@ -399,14 +399,6 @@ class Block(object):
 
 
 class Program(object):
-    @classmethod
-    def instance(cls):
-        # From https://stackoverflow.com/questions/8212053
-        # Making Program as a Singleton class.
-        if not hasattr(cls, '_instance'):
-            cls._instance = cls()
-        return cls._instance
-
     def __init__(self):
         self.desc = core.ProgramDesc()
         self.blocks = [Block(self, 0)]
@@ -500,4 +492,4 @@ class Parameter(Variable):
 
 
 # program is a global instance.
-g_program = Program.instance()
+g_program = Program()
diff --git a/python/paddle/v2/framework/tests/test_program.py b/python/paddle/v2/framework/tests/test_program.py
index 8d8dd46898..c55dd8de72 100644
--- a/python/paddle/v2/framework/tests/test_program.py
+++ b/python/paddle/v2/framework/tests/test_program.py
@@ -53,7 +53,7 @@ class TestProgram(unittest.TestCase):
         print prog.clone()
 
     def test_append_backward(self):
-        prog = Program.instance()
+        prog = Program()
         block = prog.global_block()
 
         mul_x = block.create_var(