code: def StackedHourglassTorch(inputs, out_channels=16, deconv="bilinear"):
      net = inputs
      with tf.name_scope("nn.Sequential"):
          with tf.name_scope("nn.Sequential"):
              net = tf.pad(
                  net, np.array([[0, 0], [3, 3], [3, 3], [0, 0]])
              )
              net = slim.conv2d(
                  net,
                  64,
                  (7, 7),
                  (2, 2),
                  activation_fn=None,
                  padding="VALID",
              )
              net = slim.batch_norm(net)
              net = slim.nn.relu(net)
              with tf.name_scope("nn.Sequential"):
                  with tf.name_scope("nn.ConcatTable"):
                      net0 = net
                      with tf.name_scope("nn.Sequential"):
                          net0 = slim.batch_norm(net0)
                          net0 = slim.nn.relu(net0)
                          net0 = tf.pad(
                              net0,
                              np.array(
                                  [[0, 0], [0, 0], [0, 0], [0, 0]]
                              ),
                          )
                          net0 = slim.conv2d(
                              net0,
                              64,
                              (1, 1),
                              (1, 1),
                              activation_fn=None,
                              padding="VALID",
                          )
                          net0 = slim.batch_norm(net0)
                          net0 = slim.nn.relu(net0)
                          net0 = tf.pad(
                              net0,
                              np.array(
                                  [[0, 0], [1, 1], [1, 1], [0, 0]]
                              ),
                          )
                          net0 = slim.conv2d(
                              net0,
                              64,
                              (3, 3),
                              (1, 1),
                              activation_fn=None,
                              padding="VALID",
                          )
                          net0 = slim.batch_norm(net0)
                          net0 = slim.nn.relu(net0)
                          net0 = tf.pad(
                              net0,
                              np.array(
                                  [[0, 0], [0, 0], [0, 0], [0, 0]]
                              ),
                          )
                          net0 = slim.conv2d(
                              net0,
                              128,
                              (1, 1),
                              (1, 1),
                              activation_fn=None,
                              padding="VALID",
                          )
                      net1 = net
                      with tf.name_scope("nn.Sequential"):
                          net1 = tf.pad(
                              net1,
                              np.array(
                                  [[0, 0], [0, 0], [0, 0], [0, 0]]
                              ),
                          )
                          net1 = slim.conv2d(
                              net1,
                              128,
                              (1, 1),
                              (1, 1),
                              activation_fn=None,
                              padding="VALID",
                          )
                  net = tf.add_n([net0, net1])
              net = tf.pad(
                  net, np.array([[0, 0], [0, 0], [0, 0], [0, 0]])
              )
              net = slim.max_pool2d(net, (2, 2), (2, 2))
              with tf.name_scope("nn.Sequential"):
                  with tf.name_scope("nn.ConcatTable"):
                      net0 = net
                      with tf.name_scope("nn.Sequential"):
                          net0 = slim.batch_norm(net0)
                          net0 = slim.nn.relu(net0)
                          net0 = tf.pad(
                              net0,
                              np.array(
                                  [[0, 0], [0, 0], [0, 0], [0, 0]]
                              ),
                          )
                          net0 = slim.conv2d(
                              net0,
                              64,
                              (1, 1),
                              (1, 1),
                              activation_fn=None,
                              padding="VALID",
                          )
                          net0 = slim.batch_norm(net0)
                          net0 = slim.nn.relu(net0)
                          net0 = tf.pad(
                              net0,
                              np.array(
                                  [[0, 0], [1, 1], [1, 1], [0, 0]]
                              ),
                          )
                          net0 = slim.conv2d(
                              net0,
                              64,
                              (3, 3),
                              (1, 1),
                              activation_fn=None,
                              padding="VALID",
                          )
                          net0 = slim.batch_norm(net0)
                          net0 = slim.nn.relu(net0)
                          net0 = tf.pad(
                              net0,
                              np.array(
                                  [[0, 0], [0, 0], [0, 0], [0, 0]]
                              ),
                          )
                          net0 = slim.conv2d(
                              net0,
                              128,
                              (1, 1),
                              (1, 1),
                              activation_fn=None,
                              padding="VALID",
                          )
                      net1 = net
                  net = tf.add_n([net0, net1])
              with tf.name_scope("nn.Sequential"):
                  with tf.name_scope("nn.ConcatTable"):
                      net0 = net
                      with tf.name_scope("nn.Sequential"):
                          net0 = slim.batch_norm(net0)
                          net0 = slim.nn.relu(net0)
                          net0 = tf.pad(
                              net0,
                              np.array(
                                  [[0, 0], [0, 0], [0, 0], [0, 0]]
                              ),
                          )
                          net0 = slim.conv2d(
                              net0,
                              64,
                              (1, 1),
                              (1, 1),
                              activation_fn=None,
                              padding="VALID",
                          )
                          net0 = slim.batch_norm(net0)
                          net0 = slim.nn.relu(net0)
                          net0 = tf.pad(
                              net0,
                              np.array(
                                  [[0, 0], [1, 1], [1, 1], [0, 0]]
                              ),
                          )
                          net0 = slim.conv2d(
                              net0,
                              64,
                              (3, 3),
                              (1, 1),
                              activation_fn=None,
                              padding="VALID",
                          )
                          net0 = slim.batch_norm(net0)
                          net0 = slim.nn.relu(net0)
                          net0 = tf.pad(
                              net0,
                              np.array(
                                  [[0, 0], [0, 0], [0, 0], [0, 0]]
                              ),
                          )
                          net0 = slim.conv2d(
                              net0,
                              128,
                              (1, 1),
                              (1, 1),
                              activation_fn=None,
                              padding="VALID",
                          )
                      net1 = net
                  net = tf.add_n([net0, net1])
              with tf.name_scope("nn.Sequential"):
                  with tf.name_scope("nn.ConcatTable"):
                      net0 = net
                      with tf.name_scope("nn.Sequential"):
                          net0 = slim.batch_norm(net0)
                          net0 = slim.nn.relu(net0)
                          net0 = tf.pad(
                              net0,
                              np.array(
                                  [[0, 0], [0, 0], [0, 0], [0, 0]]
                              ),
                          )
                          net0 = slim.conv2d(
                              net0,
                              128,
                              (1, 1),
                              (1, 1),
                              activation_fn=None,
                              padding="VALID",
                          )
                          net0 = slim.batch_norm(net0)
                          net0 = slim.nn.relu(net0)
                          net0 = tf.pad(
                              net0,
                              np.array(
                                  [[0, 0], [1, 1], [1, 1], [0, 0]]
                              ),
                          )
                          net0 = slim.conv2d(
                              net0,
                              128,
                              (3, 3),
                              (1, 1),
                              activation_fn=None,
                              padding="VALID",
                          )
                          net0 = slim.batch_norm(net0)
                          net0 = slim.nn.relu(net0)
                          net0 = tf.pad(
                              net0,
                              np.array(
                                  [[0, 0], [0, 0], [0, 0], [0, 0]]
                              ),
                          )
                          net0 = slim.conv2d(
                              net0,
                              256,
                              (1, 1),
                              (1, 1),
                              activation_fn=None,
                              padding="VALID",
                          )
                      net1 = net
                      with tf.name_scope("nn.Sequential"):
                          net1 = tf.pad(
                              net1,
                              np.array(
                                  [[0, 0], [0, 0], [0, 0], [0, 0]]
                              ),
                          )
                          net1 = slim.conv2d(
                              net1,
                              256,
                              (1, 1),
                              (1, 1),
                              activation_fn=None,
                              padding="VALID",
                          )
                  net = tf.add_n([net0, net1])
              with tf.name_scope("nn.Sequential"):
                  with tf.name_scope("nn.ConcatTable"):
                      net0 = net
                      with tf.name_scope("nn.Sequential"):
                          net0 = tf.pad(
                              net0,
                              np.array(
                                  [[0, 0], [0, 0], [0, 0], [0, 0]]
                              ),
                          )
                          net0 = slim.max_pool2d(net0, (2, 2), (2, 2))
                          with tf.name_scope("nn.Sequential"):
                              with tf.name_scope("nn.ConcatTable"):
                                  net00 = net0
                                  with tf.name_scope("nn.Sequential"):
                                      net00 = slim.batch_norm(net00)
                                      net00 = slim.nn.relu(net00)
                                      net00 = tf.pad(
                                          net00,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net00 = slim.conv2d(
                                          net00,
                                          128,
                                          (1, 1),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                      net00 = slim.batch_norm(net00)
                                      net00 = slim.nn.relu(net00)
                                      net00 = tf.pad(
                                          net00,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [1, 1],
                                                  [1, 1],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net00 = slim.conv2d(
                                          net00,
                                          128,
                                          (3, 3),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                      net00 = slim.batch_norm(net00)
                                      net00 = slim.nn.relu(net00)
                                      net00 = tf.pad(
                                          net00,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net00 = slim.conv2d(
                                          net00,
                                          256,
                                          (1, 1),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                  net01 = net0
                              net0 = tf.add_n([net00, net01])
                          with tf.name_scope("nn.Sequential"):
                              with tf.name_scope("nn.ConcatTable"):
                                  net00 = net0
                                  with tf.name_scope("nn.Sequential"):
                                      net00 = slim.batch_norm(net00)
                                      net00 = slim.nn.relu(net00)
                                      net00 = tf.pad(
                                          net00,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net00 = slim.conv2d(
                                          net00,
                                          128,
                                          (1, 1),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                      net00 = slim.batch_norm(net00)
                                      net00 = slim.nn.relu(net00)
                                      net00 = tf.pad(
                                          net00,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [1, 1],
                                                  [1, 1],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net00 = slim.conv2d(
                                          net00,
                                          128,
                                          (3, 3),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                      net00 = slim.batch_norm(net00)
                                      net00 = slim.nn.relu(net00)
                                      net00 = tf.pad(
                                          net00,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net00 = slim.conv2d(
                                          net00,
                                          256,
                                          (1, 1),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                  net01 = net0
                              net0 = tf.add_n([net00, net01])
                          with tf.name_scope("nn.Sequential"):
                              with tf.name_scope("nn.ConcatTable"):
                                  net00 = net0
                                  with tf.name_scope("nn.Sequential"):
                                      net00 = slim.batch_norm(net00)
                                      net00 = slim.nn.relu(net00)
                                      net00 = tf.pad(
                                          net00,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net00 = slim.conv2d(
                                          net00,
                                          128,
                                          (1, 1),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                      net00 = slim.batch_norm(net00)
                                      net00 = slim.nn.relu(net00)
                                      net00 = tf.pad(
                                          net00,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [1, 1],
                                                  [1, 1],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net00 = slim.conv2d(
                                          net00,
                                          128,
                                          (3, 3),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                      net00 = slim.batch_norm(net00)
                                      net00 = slim.nn.relu(net00)
                                      net00 = tf.pad(
                                          net00,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net00 = slim.conv2d(
                                          net00,
                                          256,
                                          (1, 1),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                  net01 = net0
                              net0 = tf.add_n([net00, net01])
                          with tf.name_scope("nn.Sequential"):
                              with tf.name_scope("nn.ConcatTable"):
                                  net00 = net0
                                  with tf.name_scope("nn.Sequential"):
                                      net00 = tf.pad(
                                          net00,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net00 = slim.max_pool2d(
                                          net00, (2, 2), (2, 2)
                                      )
                                      with tf.name_scope(
                                          "nn.Sequential"
                                      ):
                                          with tf.name_scope(
                                              "nn.ConcatTable"
                                          ):
                                              net000 = net00
                                              with tf.name_scope(
                                                  "nn.Sequential"
                                              ):
                                                  net000 = (
                                                      slim.batch_norm(
                                                          net000
                                                      )
                                                  )
                                                  net000 = slim.nn.relu(
                                                      net000
                                                  )
                                                  net000 = tf.pad(
                                                      net000,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net000 = slim.conv2d(
                                                      net000,
                                                      128,
                                                      (1, 1),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                                  net000 = (
                                                      slim.batch_norm(
                                                          net000
                                                      )
                                                  )
                                                  net000 = slim.nn.relu(
                                                      net000
                                                  )
                                                  net000 = tf.pad(
                                                      net000,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [1, 1],
                                                              [1, 1],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net000 = slim.conv2d(
                                                      net000,
                                                      128,
                                                      (3, 3),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                                  net000 = (
                                                      slim.batch_norm(
                                                          net000
                                                      )
                                                  )
                                                  net000 = slim.nn.relu(
                                                      net000
                                                  )
                                                  net000 = tf.pad(
                                                      net000,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net000 = slim.conv2d(
                                                      net000,
                                                      256,
                                                      (1, 1),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                              net001 = net00
                                          net00 = tf.add_n(
                                              [net000, net001]
                                          )
                                      with tf.name_scope(
                                          "nn.Sequential"
                                      ):
                                          with tf.name_scope(
                                              "nn.ConcatTable"
                                          ):
                                              net000 = net00
                                              with tf.name_scope(
                                                  "nn.Sequential"
                                              ):
                                                  net000 = (
                                                      slim.batch_norm(
                                                          net000
                                                      )
                                                  )
                                                  net000 = slim.nn.relu(
                                                      net000
                                                  )
                                                  net000 = tf.pad(
                                                      net000,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net000 = slim.conv2d(
                                                      net000,
                                                      128,
                                                      (1, 1),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                                  net000 = (
                                                      slim.batch_norm(
                                                          net000
                                                      )
                                                  )
                                                  net000 = slim.nn.relu(
                                                      net000
                                                  )
                                                  net000 = tf.pad(
                                                      net000,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [1, 1],
                                                              [1, 1],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net000 = slim.conv2d(
                                                      net000,
                                                      128,
                                                      (3, 3),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                                  net000 = (
                                                      slim.batch_norm(
                                                          net000
                                                      )
                                                  )
                                                  net000 = slim.nn.relu(
                                                      net000
                                                  )
                                                  net000 = tf.pad(
                                                      net000,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net000 = slim.conv2d(
                                                      net000,
                                                      256,
                                                      (1, 1),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                              net001 = net00
                                          net00 = tf.add_n(
                                              [net000, net001]
                                          )
                                      with tf.name_scope(
                                          "nn.Sequential"
                                      ):
                                          with tf.name_scope(
                                              "nn.ConcatTable"
                                          ):
                                              net000 = net00
                                              with tf.name_scope(
                                                  "nn.Sequential"
                                              ):
                                                  net000 = (
                                                      slim.batch_norm(
                                                          net000
                                                      )
                                                  )
                                                  net000 = slim.nn.relu(
                                                      net000
                                                  )
                                                  net000 = tf.pad(
                                                      net000,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net000 = slim.conv2d(
                                                      net000,
                                                      128,
                                                      (1, 1),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                                  net000 = (
                                                      slim.batch_norm(
                                                          net000
                                                      )
                                                  )
                                                  net000 = slim.nn.relu(
                                                      net000
                                                  )
                                                  net000 = tf.pad(
                                                      net000,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [1, 1],
                                                              [1, 1],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net000 = slim.conv2d(
                                                      net000,
                                                      128,
                                                      (3, 3),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                                  net000 = (
                                                      slim.batch_norm(
                                                          net000
                                                      )
                                                  )
                                                  net000 = slim.nn.relu(
                                                      net000
                                                  )
                                                  net000 = tf.pad(
                                                      net000,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net000 = slim.conv2d(
                                                      net000,
                                                      256,
                                                      (1, 1),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                              net001 = net00
                                          net00 = tf.add_n(
                                              [net000, net001]
                                          )
                                      with tf.name_scope(
                                          "nn.Sequential"
                                      ):
                                          with tf.name_scope(
                                              "nn.ConcatTable"
                                          ):
                                              net000 = net00
                                              with tf.name_scope(
                                                  "nn.Sequential"
                                              ):
                                                  net000 = tf.pad(
                                                      net000,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net000 = (
                                                      slim.max_pool2d(
                                                          net000,
                                                          (2, 2),
                                                          (2, 2),
                                                      )
                                                  )
                                                  with tf.name_scope(
                                                      "nn.Sequential"
                                                  ):
                                                      with tf.name_scope(
                                                          "nn.ConcatTable"
                                                      ):
                                                          net0000 = (
                                                              net000
                                                          )
                                                          with tf.name_scope(
                                                              "nn.Sequential"
                                                          ):
                                                              net0000 = slim.batch_norm(
                                                                  net0000
                                                              )
                                                              net0000 = slim.nn.relu(
                                                                  net0000
                                                              )
                                                              net0000 = tf.pad(
                                                                  net0000,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0000 = slim.conv2d(
                                                                  net0000,
                                                                  128,
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                              net0000 = slim.batch_norm(
                                                                  net0000
                                                              )
                                                              net0000 = slim.nn.relu(
                                                                  net0000
                                                              )
                                                              net0000 = tf.pad(
                                                                  net0000,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              1,
                                                                              1,
                                                                          ],
                                                                          [
                                                                              1,
                                                                              1,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0000 = slim.conv2d(
                                                                  net0000,
                                                                  128,
                                                                  (
                                                                      3,
                                                                      3,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                              net0000 = slim.batch_norm(
                                                                  net0000
                                                              )
                                                              net0000 = slim.nn.relu(
                                                                  net0000
                                                              )
                                                              net0000 = tf.pad(
                                                                  net0000,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0000 = slim.conv2d(
                                                                  net0000,
                                                                  256,
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                          net0001 = (
                                                              net000
                                                          )
                                                      net000 = tf.add_n(
                                                          [
                                                              net0000,
                                                              net0001,
                                                          ]
                                                      )
                                                  with tf.name_scope(
                                                      "nn.Sequential"
                                                  ):
                                                      with tf.name_scope(
                                                          "nn.ConcatTable"
                                                      ):
                                                          net0000 = (
                                                              net000
                                                          )
                                                          with tf.name_scope(
                                                              "nn.Sequential"
                                                          ):
                                                              net0000 = slim.batch_norm(
                                                                  net0000
                                                              )
                                                              net0000 = slim.nn.relu(
                                                                  net0000
                                                              )
                                                              net0000 = tf.pad(
                                                                  net0000,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0000 = slim.conv2d(
                                                                  net0000,
                                                                  128,
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                              net0000 = slim.batch_norm(
                                                                  net0000
                                                              )
                                                              net0000 = slim.nn.relu(
                                                                  net0000
                                                              )
                                                              net0000 = tf.pad(
                                                                  net0000,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              1,
                                                                              1,
                                                                          ],
                                                                          [
                                                                              1,
                                                                              1,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0000 = slim.conv2d(
                                                                  net0000,
                                                                  128,
                                                                  (
                                                                      3,
                                                                      3,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                              net0000 = slim.batch_norm(
                                                                  net0000
                                                              )
                                                              net0000 = slim.nn.relu(
                                                                  net0000
                                                              )
                                                              net0000 = tf.pad(
                                                                  net0000,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0000 = slim.conv2d(
                                                                  net0000,
                                                                  256,
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                          net0001 = (
                                                              net000
                                                          )
                                                      net000 = tf.add_n(
                                                          [
                                                              net0000,
                                                              net0001,
                                                          ]
                                                      )
                                                  with tf.name_scope(
                                                      "nn.Sequential"
                                                  ):
                                                      with tf.name_scope(
                                                          "nn.ConcatTable"
                                                      ):
                                                          net0000 = (
                                                              net000
                                                          )
                                                          with tf.name_scope(
                                                              "nn.Sequential"
                                                          ):
                                                              net0000 = slim.batch_norm(
                                                                  net0000
                                                              )
                                                              net0000 = slim.nn.relu(
                                                                  net0000
                                                              )
                                                              net0000 = tf.pad(
                                                                  net0000,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0000 = slim.conv2d(
                                                                  net0000,
                                                                  128,
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                              net0000 = slim.batch_norm(
                                                                  net0000
                                                              )
                                                              net0000 = slim.nn.relu(
                                                                  net0000
                                                              )
                                                              net0000 = tf.pad(
                                                                  net0000,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              1,
                                                                              1,
                                                                          ],
                                                                          [
                                                                              1,
                                                                              1,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0000 = slim.conv2d(
                                                                  net0000,
                                                                  128,
                                                                  (
                                                                      3,
                                                                      3,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                              net0000 = slim.batch_norm(
                                                                  net0000
                                                              )
                                                              net0000 = slim.nn.relu(
                                                                  net0000
                                                              )
                                                              net0000 = tf.pad(
                                                                  net0000,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0000 = slim.conv2d(
                                                                  net0000,
                                                                  256,
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                          net0001 = (
                                                              net000
                                                          )
                                                      net000 = tf.add_n(
                                                          [
                                                              net0000,
                                                              net0001,
                                                          ]
                                                      )
                                                  with tf.name_scope(
                                                      "nn.Sequential"
                                                  ):
                                                      with tf.name_scope(
                                                          "nn.ConcatTable"
                                                      ):
                                                          net0000 = (
                                                              net000
                                                          )
                                                          with tf.name_scope(
                                                              "nn.Sequential"
                                                          ):
                                                              net0000 = tf.pad(
                                                                  net0000,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0000 = slim.max_pool2d(
                                                                  net0000,
                                                                  (
                                                                      2,
                                                                      2,
                                                                  ),
                                                                  (
                                                                      2,
                                                                      2,
                                                                  ),
                                                              )
                                                              with tf.name_scope(
                                                                  "nn.Sequential"
                                                              ):
                                                                  with tf.name_scope(
                                                                      "nn.ConcatTable"
                                                                  ):
                                                                      net00000 = net0000
                                                                      with tf.name_scope(
                                                                          "nn.Sequential"
                                                                      ):
                                                                          net00000 = slim.batch_norm(
                                                                              net00000
                                                                          )
                                                                          net00000 = slim.nn.relu(
                                                                              net00000
                                                                          )
                                                                          net00000 = tf.pad(
                                                                              net00000,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00000 = slim.conv2d(
                                                                              net00000,
                                                                              128,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00000 = slim.batch_norm(
                                                                              net00000
                                                                          )
                                                                          net00000 = slim.nn.relu(
                                                                              net00000
                                                                          )
                                                                          net00000 = tf.pad(
                                                                              net00000,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00000 = slim.conv2d(
                                                                              net00000,
                                                                              128,
                                                                              (
                                                                                  3,
                                                                                  3,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00000 = slim.batch_norm(
                                                                              net00000
                                                                          )
                                                                          net00000 = slim.nn.relu(
                                                                              net00000
                                                                          )
                                                                          net00000 = tf.pad(
                                                                              net00000,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00000 = slim.conv2d(
                                                                              net00000,
                                                                              256,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                      net00001 = net0000
                                                                  net0000 = tf.add_n(
                                                                      [
                                                                          net00000,
                                                                          net00001,
                                                                      ]
                                                                  )
                                                              with tf.name_scope(
                                                                  "nn.Sequential"
                                                              ):
                                                                  with tf.name_scope(
                                                                      "nn.ConcatTable"
                                                                  ):
                                                                      net00000 = net0000
                                                                      with tf.name_scope(
                                                                          "nn.Sequential"
                                                                      ):
                                                                          net00000 = slim.batch_norm(
                                                                              net00000
                                                                          )
                                                                          net00000 = slim.nn.relu(
                                                                              net00000
                                                                          )
                                                                          net00000 = tf.pad(
                                                                              net00000,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00000 = slim.conv2d(
                                                                              net00000,
                                                                              128,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00000 = slim.batch_norm(
                                                                              net00000
                                                                          )
                                                                          net00000 = slim.nn.relu(
                                                                              net00000
                                                                          )
                                                                          net00000 = tf.pad(
                                                                              net00000,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00000 = slim.conv2d(
                                                                              net00000,
                                                                              128,
                                                                              (
                                                                                  3,
                                                                                  3,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00000 = slim.batch_norm(
                                                                              net00000
                                                                          )
                                                                          net00000 = slim.nn.relu(
                                                                              net00000
                                                                          )
                                                                          net00000 = tf.pad(
                                                                              net00000,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00000 = slim.conv2d(
                                                                              net00000,
                                                                              256,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                      net00001 = net0000
                                                                  net0000 = tf.add_n(
                                                                      [
                                                                          net00000,
                                                                          net00001,
                                                                      ]
                                                                  )
                                                              with tf.name_scope(
                                                                  "nn.Sequential"
                                                              ):
                                                                  with tf.name_scope(
                                                                      "nn.ConcatTable"
                                                                  ):
                                                                      net00000 = net0000
                                                                      with tf.name_scope(
                                                                          "nn.Sequential"
                                                                      ):
                                                                          net00000 = slim.batch_norm(
                                                                              net00000
                                                                          )
                                                                          net00000 = slim.nn.relu(
                                                                              net00000
                                                                          )
                                                                          net00000 = tf.pad(
                                                                              net00000,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00000 = slim.conv2d(
                                                                              net00000,
                                                                              128,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00000 = slim.batch_norm(
                                                                              net00000
                                                                          )
                                                                          net00000 = slim.nn.relu(
                                                                              net00000
                                                                          )
                                                                          net00000 = tf.pad(
                                                                              net00000,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00000 = slim.conv2d(
                                                                              net00000,
                                                                              128,
                                                                              (
                                                                                  3,
                                                                                  3,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00000 = slim.batch_norm(
                                                                              net00000
                                                                          )
                                                                          net00000 = slim.nn.relu(
                                                                              net00000
                                                                          )
                                                                          net00000 = tf.pad(
                                                                              net00000,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00000 = slim.conv2d(
                                                                              net00000,
                                                                              256,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                      net00001 = net0000
                                                                  net0000 = tf.add_n(
                                                                      [
                                                                          net00000,
                                                                          net00001,
                                                                      ]
                                                                  )
                                                              with tf.name_scope(
                                                                  "nn.Sequential"
                                                              ):
                                                                  with tf.name_scope(
                                                                      "nn.ConcatTable"
                                                                  ):
                                                                      net00000 = net0000
                                                                      with tf.name_scope(
                                                                          "nn.Sequential"
                                                                      ):
                                                                          net00000 = slim.batch_norm(
                                                                              net00000
                                                                          )
                                                                          net00000 = slim.nn.relu(
                                                                              net00000
                                                                          )
                                                                          net00000 = tf.pad(
                                                                              net00000,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00000 = slim.conv2d(
                                                                              net00000,
                                                                              256,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00000 = slim.batch_norm(
                                                                              net00000
                                                                          )
                                                                          net00000 = slim.nn.relu(
                                                                              net00000
                                                                          )
                                                                          net00000 = tf.pad(
                                                                              net00000,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00000 = slim.conv2d(
                                                                              net00000,
                                                                              256,
                                                                              (
                                                                                  3,
                                                                                  3,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00000 = slim.batch_norm(
                                                                              net00000
                                                                          )
                                                                          net00000 = slim.nn.relu(
                                                                              net00000
                                                                          )
                                                                          net00000 = tf.pad(
                                                                              net00000,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00000 = slim.conv2d(
                                                                              net00000,
                                                                              512,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                      net00001 = net0000
                                                                      with tf.name_scope(
                                                                          "nn.Sequential"
                                                                      ):
                                                                          net00001 = tf.pad(
                                                                              net00001,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00001 = slim.conv2d(
                                                                              net00001,
                                                                              512,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                  net0000 = tf.add_n(
                                                                      [
                                                                          net00000,
                                                                          net00001,
                                                                      ]
                                                                  )
                                                              with tf.name_scope(
                                                                  "nn.Sequential"
                                                              ):
                                                                  with tf.name_scope(
                                                                      "nn.ConcatTable"
                                                                  ):
                                                                      net00000 = net0000
                                                                      with tf.name_scope(
                                                                          "nn.Sequential"
                                                                      ):
                                                                          net00000 = slim.batch_norm(
                                                                              net00000
                                                                          )
                                                                          net00000 = slim.nn.relu(
                                                                              net00000
                                                                          )
                                                                          net00000 = tf.pad(
                                                                              net00000,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00000 = slim.conv2d(
                                                                              net00000,
                                                                              256,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00000 = slim.batch_norm(
                                                                              net00000
                                                                          )
                                                                          net00000 = slim.nn.relu(
                                                                              net00000
                                                                          )
                                                                          net00000 = tf.pad(
                                                                              net00000,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00000 = slim.conv2d(
                                                                              net00000,
                                                                              256,
                                                                              (
                                                                                  3,
                                                                                  3,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00000 = slim.batch_norm(
                                                                              net00000
                                                                          )
                                                                          net00000 = slim.nn.relu(
                                                                              net00000
                                                                          )
                                                                          net00000 = tf.pad(
                                                                              net00000,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00000 = slim.conv2d(
                                                                              net00000,
                                                                              512,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                      net00001 = net0000
                                                                  net0000 = tf.add_n(
                                                                      [
                                                                          net00000,
                                                                          net00001,
                                                                      ]
                                                                  )
                                                              net0000 = tf.pad(
                                                                  net0000,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0000 = deconv_layer(
                                                                  net0000,
                                                                  2,
                                                                  512,
                                                                  method=deconv,
                                                              )
                                                          net0001 = (
                                                              net000
                                                          )
                                                          with tf.name_scope(
                                                              "nn.Sequential"
                                                          ):
                                                              with tf.name_scope(
                                                                  "nn.Sequential"
                                                              ):
                                                                  with tf.name_scope(
                                                                      "nn.ConcatTable"
                                                                  ):
                                                                      net00010 = net0001
                                                                      with tf.name_scope(
                                                                          "nn.Sequential"
                                                                      ):
                                                                          net00010 = slim.batch_norm(
                                                                              net00010
                                                                          )
                                                                          net00010 = slim.nn.relu(
                                                                              net00010
                                                                          )
                                                                          net00010 = tf.pad(
                                                                              net00010,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00010 = slim.conv2d(
                                                                              net00010,
                                                                              128,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00010 = slim.batch_norm(
                                                                              net00010
                                                                          )
                                                                          net00010 = slim.nn.relu(
                                                                              net00010
                                                                          )
                                                                          net00010 = tf.pad(
                                                                              net00010,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00010 = slim.conv2d(
                                                                              net00010,
                                                                              128,
                                                                              (
                                                                                  3,
                                                                                  3,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00010 = slim.batch_norm(
                                                                              net00010
                                                                          )
                                                                          net00010 = slim.nn.relu(
                                                                              net00010
                                                                          )
                                                                          net00010 = tf.pad(
                                                                              net00010,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00010 = slim.conv2d(
                                                                              net00010,
                                                                              256,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                      net00011 = net0001
                                                                  net0001 = tf.add_n(
                                                                      [
                                                                          net00010,
                                                                          net00011,
                                                                      ]
                                                                  )
                                                              with tf.name_scope(
                                                                  "nn.Sequential"
                                                              ):
                                                                  with tf.name_scope(
                                                                      "nn.ConcatTable"
                                                                  ):
                                                                      net00010 = net0001
                                                                      with tf.name_scope(
                                                                          "nn.Sequential"
                                                                      ):
                                                                          net00010 = slim.batch_norm(
                                                                              net00010
                                                                          )
                                                                          net00010 = slim.nn.relu(
                                                                              net00010
                                                                          )
                                                                          net00010 = tf.pad(
                                                                              net00010,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00010 = slim.conv2d(
                                                                              net00010,
                                                                              128,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00010 = slim.batch_norm(
                                                                              net00010
                                                                          )
                                                                          net00010 = slim.nn.relu(
                                                                              net00010
                                                                          )
                                                                          net00010 = tf.pad(
                                                                              net00010,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00010 = slim.conv2d(
                                                                              net00010,
                                                                              128,
                                                                              (
                                                                                  3,
                                                                                  3,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00010 = slim.batch_norm(
                                                                              net00010
                                                                          )
                                                                          net00010 = slim.nn.relu(
                                                                              net00010
                                                                          )
                                                                          net00010 = tf.pad(
                                                                              net00010,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00010 = slim.conv2d(
                                                                              net00010,
                                                                              256,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                      net00011 = net0001
                                                                  net0001 = tf.add_n(
                                                                      [
                                                                          net00010,
                                                                          net00011,
                                                                      ]
                                                                  )
                                                              with tf.name_scope(
                                                                  "nn.Sequential"
                                                              ):
                                                                  with tf.name_scope(
                                                                      "nn.ConcatTable"
                                                                  ):
                                                                      net00010 = net0001
                                                                      with tf.name_scope(
                                                                          "nn.Sequential"
                                                                      ):
                                                                          net00010 = slim.batch_norm(
                                                                              net00010
                                                                          )
                                                                          net00010 = slim.nn.relu(
                                                                              net00010
                                                                          )
                                                                          net00010 = tf.pad(
                                                                              net00010,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00010 = slim.conv2d(
                                                                              net00010,
                                                                              256,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00010 = slim.batch_norm(
                                                                              net00010
                                                                          )
                                                                          net00010 = slim.nn.relu(
                                                                              net00010
                                                                          )
                                                                          net00010 = tf.pad(
                                                                              net00010,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          1,
                                                                                          1,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00010 = slim.conv2d(
                                                                              net00010,
                                                                              256,
                                                                              (
                                                                                  3,
                                                                                  3,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                          net00010 = slim.batch_norm(
                                                                              net00010
                                                                          )
                                                                          net00010 = slim.nn.relu(
                                                                              net00010
                                                                          )
                                                                          net00010 = tf.pad(
                                                                              net00010,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00010 = slim.conv2d(
                                                                              net00010,
                                                                              512,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                      net00011 = net0001
                                                                      with tf.name_scope(
                                                                          "nn.Sequential"
                                                                      ):
                                                                          net00011 = tf.pad(
                                                                              net00011,
                                                                              np.array(
                                                                                  [
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                      [
                                                                                          0,
                                                                                          0,
                                                                                      ],
                                                                                  ]
                                                                              ),
                                                                          )
                                                                          net00011 = slim.conv2d(
                                                                              net00011,
                                                                              512,
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              (
                                                                                  1,
                                                                                  1,
                                                                              ),
                                                                              activation_fn=None,
                                                                              padding="VALID",
                                                                          )
                                                                  net0001 = tf.add_n(
                                                                      [
                                                                          net00010,
                                                                          net00011,
                                                                      ]
                                                                  )
                                                      net000 = tf.add_n(
                                                          [
                                                              net0000,
                                                              net0001,
                                                          ]
                                                      )
                                                      with tf.name_scope(
                                                          "nn.Sequential"
                                                      ):
                                                          with tf.name_scope(
                                                              "nn.ConcatTable"
                                                          ):
                                                              net0000 = (
                                                                  net000
                                                              )
                                                              with tf.name_scope(
                                                                  "nn.Sequential"
                                                              ):
                                                                  net0000 = slim.batch_norm(
                                                                      net0000
                                                                  )
                                                                  net0000 = slim.nn.relu(
                                                                      net0000
                                                                  )
                                                                  net0000 = tf.pad(
                                                                      net0000,
                                                                      np.array(
                                                                          [
                                                                              [
                                                                                  0,
                                                                                  0,
                                                                              ],
                                                                              [
                                                                                  0,
                                                                                  0,
                                                                              ],
                                                                              [
                                                                                  0,
                                                                                  0,
                                                                              ],
                                                                              [
                                                                                  0,
                                                                                  0,
                                                                              ],
                                                                          ]
                                                                      ),
                                                                  )
                                                                  net0000 = slim.conv2d(
                                                                      net0000,
                                                                      256,
                                                                      (
                                                                          1,
                                                                          1,
                                                                      ),
                                                                      (
                                                                          1,
                                                                          1,
                                                                      ),
                                                                      activation_fn=None,
                                                                      padding="VALID",
                                                                  )
                                                                  net0000 = slim.batch_norm(
                                                                      net0000
                                                                  )
                                                                  net0000 = slim.nn.relu(
                                                                      net0000
                                                                  )
                                                                  net0000 = tf.pad(
                                                                      net0000,
                                                                      np.array(
                                                                          [
                                                                              [
                                                                                  0,
                                                                                  0,
                                                                              ],
                                                                              [
                                                                                  1,
                                                                                  1,
                                                                              ],
                                                                              [
                                                                                  1,
                                                                                  1,
                                                                              ],
                                                                              [
                                                                                  0,
                                                                                  0,
                                                                              ],
                                                                          ]
                                                                      ),
                                                                  )
                                                                  net0000 = slim.conv2d(
                                                                      net0000,
                                                                      256,
                                                                      (
                                                                          3,
                                                                          3,
                                                                      ),
                                                                      (
                                                                          1,
                                                                          1,
                                                                      ),
                                                                      activation_fn=None,
                                                                      padding="VALID",
                                                                  )
                                                                  net0000 = slim.batch_norm(
                                                                      net0000
                                                                  )
                                                                  net0000 = slim.nn.relu(
                                                                      net0000
                                                                  )
                                                                  net0000 = tf.pad(
                                                                      net0000,
                                                                      np.array(
                                                                          [
                                                                              [
                                                                                  0,
                                                                                  0,
                                                                              ],
                                                                              [
                                                                                  0,
                                                                                  0,
                                                                              ],
                                                                              [
                                                                                  0,
                                                                                  0,
                                                                              ],
                                                                              [
                                                                                  0,
                                                                                  0,
                                                                              ],
                                                                          ]
                                                                      ),
                                                                  )
                                                                  net0000 = slim.conv2d(
                                                                      net0000,
                                                                      512,
                                                                      (
                                                                          1,
                                                                          1,
                                                                      ),
                                                                      (
                                                                          1,
                                                                          1,
                                                                      ),
                                                                      activation_fn=None,
                                                                      padding="VALID",
                                                                  )
                                                              net0001 = (
                                                                  net000
                                                              )
                                                          net000 = tf.add_n(
                                                              [
                                                                  net0000,
                                                                  net0001,
                                                              ]
                                                          )
                                                  net000 = tf.pad(
                                                      net000,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net000 = deconv_layer(
                                                      net000,
                                                      2,
                                                      512,
                                                      method=deconv,
                                                  )
                                              net001 = net00
                                              with tf.name_scope(
                                                  "nn.Sequential"
                                              ):
                                                  with tf.name_scope(
                                                      "nn.Sequential"
                                                  ):
                                                      with tf.name_scope(
                                                          "nn.ConcatTable"
                                                      ):
                                                          net0010 = (
                                                              net001
                                                          )
                                                          with tf.name_scope(
                                                              "nn.Sequential"
                                                          ):
                                                              net0010 = slim.batch_norm(
                                                                  net0010
                                                              )
                                                              net0010 = slim.nn.relu(
                                                                  net0010
                                                              )
                                                              net0010 = tf.pad(
                                                                  net0010,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0010 = slim.conv2d(
                                                                  net0010,
                                                                  128,
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                              net0010 = slim.batch_norm(
                                                                  net0010
                                                              )
                                                              net0010 = slim.nn.relu(
                                                                  net0010
                                                              )
                                                              net0010 = tf.pad(
                                                                  net0010,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              1,
                                                                              1,
                                                                          ],
                                                                          [
                                                                              1,
                                                                              1,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0010 = slim.conv2d(
                                                                  net0010,
                                                                  128,
                                                                  (
                                                                      3,
                                                                      3,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                              net0010 = slim.batch_norm(
                                                                  net0010
                                                              )
                                                              net0010 = slim.nn.relu(
                                                                  net0010
                                                              )
                                                              net0010 = tf.pad(
                                                                  net0010,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0010 = slim.conv2d(
                                                                  net0010,
                                                                  256,
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                          net0011 = (
                                                              net001
                                                          )
                                                      net001 = tf.add_n(
                                                          [
                                                              net0010,
                                                              net0011,
                                                          ]
                                                      )
                                                  with tf.name_scope(
                                                      "nn.Sequential"
                                                  ):
                                                      with tf.name_scope(
                                                          "nn.ConcatTable"
                                                      ):
                                                          net0010 = (
                                                              net001
                                                          )
                                                          with tf.name_scope(
                                                              "nn.Sequential"
                                                          ):
                                                              net0010 = slim.batch_norm(
                                                                  net0010
                                                              )
                                                              net0010 = slim.nn.relu(
                                                                  net0010
                                                              )
                                                              net0010 = tf.pad(
                                                                  net0010,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0010 = slim.conv2d(
                                                                  net0010,
                                                                  128,
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                              net0010 = slim.batch_norm(
                                                                  net0010
                                                              )
                                                              net0010 = slim.nn.relu(
                                                                  net0010
                                                              )
                                                              net0010 = tf.pad(
                                                                  net0010,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              1,
                                                                              1,
                                                                          ],
                                                                          [
                                                                              1,
                                                                              1,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0010 = slim.conv2d(
                                                                  net0010,
                                                                  128,
                                                                  (
                                                                      3,
                                                                      3,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                              net0010 = slim.batch_norm(
                                                                  net0010
                                                              )
                                                              net0010 = slim.nn.relu(
                                                                  net0010
                                                              )
                                                              net0010 = tf.pad(
                                                                  net0010,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0010 = slim.conv2d(
                                                                  net0010,
                                                                  256,
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                          net0011 = (
                                                              net001
                                                          )
                                                      net001 = tf.add_n(
                                                          [
                                                              net0010,
                                                              net0011,
                                                          ]
                                                      )
                                                  with tf.name_scope(
                                                      "nn.Sequential"
                                                  ):
                                                      with tf.name_scope(
                                                          "nn.ConcatTable"
                                                      ):
                                                          net0010 = (
                                                              net001
                                                          )
                                                          with tf.name_scope(
                                                              "nn.Sequential"
                                                          ):
                                                              net0010 = slim.batch_norm(
                                                                  net0010
                                                              )
                                                              net0010 = slim.nn.relu(
                                                                  net0010
                                                              )
                                                              net0010 = tf.pad(
                                                                  net0010,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0010 = slim.conv2d(
                                                                  net0010,
                                                                  256,
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                              net0010 = slim.batch_norm(
                                                                  net0010
                                                              )
                                                              net0010 = slim.nn.relu(
                                                                  net0010
                                                              )
                                                              net0010 = tf.pad(
                                                                  net0010,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              1,
                                                                              1,
                                                                          ],
                                                                          [
                                                                              1,
                                                                              1,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0010 = slim.conv2d(
                                                                  net0010,
                                                                  256,
                                                                  (
                                                                      3,
                                                                      3,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                              net0010 = slim.batch_norm(
                                                                  net0010
                                                              )
                                                              net0010 = slim.nn.relu(
                                                                  net0010
                                                              )
                                                              net0010 = tf.pad(
                                                                  net0010,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0010 = slim.conv2d(
                                                                  net0010,
                                                                  512,
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                          net0011 = (
                                                              net001
                                                          )
                                                          with tf.name_scope(
                                                              "nn.Sequential"
                                                          ):
                                                              net0011 = tf.pad(
                                                                  net0011,
                                                                  np.array(
                                                                      [
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                          [
                                                                              0,
                                                                              0,
                                                                          ],
                                                                      ]
                                                                  ),
                                                              )
                                                              net0011 = slim.conv2d(
                                                                  net0011,
                                                                  512,
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  (
                                                                      1,
                                                                      1,
                                                                  ),
                                                                  activation_fn=None,
                                                                  padding="VALID",
                                                              )
                                                      net001 = tf.add_n(
                                                          [
                                                              net0010,
                                                              net0011,
                                                          ]
                                                      )
                                          net00 = tf.add_n(
                                              [net000, net001]
                                          )
                                          with tf.name_scope(
                                              "nn.Sequential"
                                          ):
                                              with tf.name_scope(
                                                  "nn.ConcatTable"
                                              ):
                                                  net000 = net00
                                                  with tf.name_scope(
                                                      "nn.Sequential"
                                                  ):
                                                      net000 = slim.batch_norm(
                                                          net000
                                                      )
                                                      net000 = (
                                                          slim.nn.relu(
                                                              net000
                                                          )
                                                      )
                                                      net000 = tf.pad(
                                                          net000,
                                                          np.array(
                                                              [
                                                                  [
                                                                      0,
                                                                      0,
                                                                  ],
                                                                  [
                                                                      0,
                                                                      0,
                                                                  ],
                                                                  [
                                                                      0,
                                                                      0,
                                                                  ],
                                                                  [
                                                                      0,
                                                                      0,
                                                                  ],
                                                              ]
                                                          ),
                                                      )
                                                      net000 = slim.conv2d(
                                                          net000,
                                                          256,
                                                          (1, 1),
                                                          (1, 1),
                                                          activation_fn=None,
                                                          padding="VALID",
                                                      )
                                                      net000 = slim.batch_norm(
                                                          net000
                                                      )
                                                      net000 = (
                                                          slim.nn.relu(
                                                              net000
                                                          )
                                                      )
                                                      net000 = tf.pad(
                                                          net000,
                                                          np.array(
                                                              [
                                                                  [
                                                                      0,
                                                                      0,
                                                                  ],
                                                                  [
                                                                      1,
                                                                      1,
                                                                  ],
                                                                  [
                                                                      1,
                                                                      1,
                                                                  ],
                                                                  [
                                                                      0,
                                                                      0,
                                                                  ],
                                                              ]
                                                          ),
                                                      )
                                                      net000 = slim.conv2d(
                                                          net000,
                                                          256,
                                                          (3, 3),
                                                          (1, 1),
                                                          activation_fn=None,
                                                          padding="VALID",
                                                      )
                                                      net000 = slim.batch_norm(
                                                          net000
                                                      )
                                                      net000 = (
                                                          slim.nn.relu(
                                                              net000
                                                          )
                                                      )
                                                      net000 = tf.pad(
                                                          net000,
                                                          np.array(
                                                              [
                                                                  [
                                                                      0,
                                                                      0,
                                                                  ],
                                                                  [
                                                                      0,
                                                                      0,
                                                                  ],
                                                                  [
                                                                      0,
                                                                      0,
                                                                  ],
                                                                  [
                                                                      0,
                                                                      0,
                                                                  ],
                                                              ]
                                                          ),
                                                      )
                                                      net000 = slim.conv2d(
                                                          net000,
                                                          512,
                                                          (1, 1),
                                                          (1, 1),
                                                          activation_fn=None,
                                                          padding="VALID",
                                                      )
                                                  net001 = net00
                                              net00 = tf.add_n(
                                                  [net000, net001]
                                              )
                                      net00 = tf.pad(
                                          net00,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net00 = deconv_layer(
                                          net00, 2, 512, method=deconv
                                      )
                                  net01 = net0
                                  with tf.name_scope("nn.Sequential"):
                                      with tf.name_scope(
                                          "nn.Sequential"
                                      ):
                                          with tf.name_scope(
                                              "nn.ConcatTable"
                                          ):
                                              net010 = net01
                                              with tf.name_scope(
                                                  "nn.Sequential"
                                              ):
                                                  net010 = (
                                                      slim.batch_norm(
                                                          net010
                                                      )
                                                  )
                                                  net010 = slim.nn.relu(
                                                      net010
                                                  )
                                                  net010 = tf.pad(
                                                      net010,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net010 = slim.conv2d(
                                                      net010,
                                                      128,
                                                      (1, 1),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                                  net010 = (
                                                      slim.batch_norm(
                                                          net010
                                                      )
                                                  )
                                                  net010 = slim.nn.relu(
                                                      net010
                                                  )
                                                  net010 = tf.pad(
                                                      net010,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [1, 1],
                                                              [1, 1],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net010 = slim.conv2d(
                                                      net010,
                                                      128,
                                                      (3, 3),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                                  net010 = (
                                                      slim.batch_norm(
                                                          net010
                                                      )
                                                  )
                                                  net010 = slim.nn.relu(
                                                      net010
                                                  )
                                                  net010 = tf.pad(
                                                      net010,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net010 = slim.conv2d(
                                                      net010,
                                                      256,
                                                      (1, 1),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                              net011 = net01
                                          net01 = tf.add_n(
                                              [net010, net011]
                                          )
                                      with tf.name_scope(
                                          "nn.Sequential"
                                      ):
                                          with tf.name_scope(
                                              "nn.ConcatTable"
                                          ):
                                              net010 = net01
                                              with tf.name_scope(
                                                  "nn.Sequential"
                                              ):
                                                  net010 = (
                                                      slim.batch_norm(
                                                          net010
                                                      )
                                                  )
                                                  net010 = slim.nn.relu(
                                                      net010
                                                  )
                                                  net010 = tf.pad(
                                                      net010,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net010 = slim.conv2d(
                                                      net010,
                                                      128,
                                                      (1, 1),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                                  net010 = (
                                                      slim.batch_norm(
                                                          net010
                                                      )
                                                  )
                                                  net010 = slim.nn.relu(
                                                      net010
                                                  )
                                                  net010 = tf.pad(
                                                      net010,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [1, 1],
                                                              [1, 1],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net010 = slim.conv2d(
                                                      net010,
                                                      128,
                                                      (3, 3),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                                  net010 = (
                                                      slim.batch_norm(
                                                          net010
                                                      )
                                                  )
                                                  net010 = slim.nn.relu(
                                                      net010
                                                  )
                                                  net010 = tf.pad(
                                                      net010,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net010 = slim.conv2d(
                                                      net010,
                                                      256,
                                                      (1, 1),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                              net011 = net01
                                          net01 = tf.add_n(
                                              [net010, net011]
                                          )
                                      with tf.name_scope(
                                          "nn.Sequential"
                                      ):
                                          with tf.name_scope(
                                              "nn.ConcatTable"
                                          ):
                                              net010 = net01
                                              with tf.name_scope(
                                                  "nn.Sequential"
                                              ):
                                                  net010 = (
                                                      slim.batch_norm(
                                                          net010
                                                      )
                                                  )
                                                  net010 = slim.nn.relu(
                                                      net010
                                                  )
                                                  net010 = tf.pad(
                                                      net010,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net010 = slim.conv2d(
                                                      net010,
                                                      256,
                                                      (1, 1),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                                  net010 = (
                                                      slim.batch_norm(
                                                          net010
                                                      )
                                                  )
                                                  net010 = slim.nn.relu(
                                                      net010
                                                  )
                                                  net010 = tf.pad(
                                                      net010,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [1, 1],
                                                              [1, 1],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net010 = slim.conv2d(
                                                      net010,
                                                      256,
                                                      (3, 3),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                                  net010 = (
                                                      slim.batch_norm(
                                                          net010
                                                      )
                                                  )
                                                  net010 = slim.nn.relu(
                                                      net010
                                                  )
                                                  net010 = tf.pad(
                                                      net010,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net010 = slim.conv2d(
                                                      net010,
                                                      512,
                                                      (1, 1),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                              net011 = net01
                                              with tf.name_scope(
                                                  "nn.Sequential"
                                              ):
                                                  net011 = tf.pad(
                                                      net011,
                                                      np.array(
                                                          [
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                              [0, 0],
                                                          ]
                                                      ),
                                                  )
                                                  net011 = slim.conv2d(
                                                      net011,
                                                      512,
                                                      (1, 1),
                                                      (1, 1),
                                                      activation_fn=None,
                                                      padding="VALID",
                                                  )
                                          net01 = tf.add_n(
                                              [net010, net011]
                                          )
                              net0 = tf.add_n([net00, net01])
                              with tf.name_scope("nn.Sequential"):
                                  with tf.name_scope("nn.ConcatTable"):
                                      net00 = net0
                                      with tf.name_scope(
                                          "nn.Sequential"
                                      ):
                                          net00 = slim.batch_norm(net00)
                                          net00 = slim.nn.relu(net00)
                                          net00 = tf.pad(
                                              net00,
                                              np.array(
                                                  [
                                                      [0, 0],
                                                      [0, 0],
                                                      [0, 0],
                                                      [0, 0],
                                                  ]
                                              ),
                                          )
                                          net00 = slim.conv2d(
                                              net00,
                                              256,
                                              (1, 1),
                                              (1, 1),
                                              activation_fn=None,
                                              padding="VALID",
                                          )
                                          net00 = slim.batch_norm(net00)
                                          net00 = slim.nn.relu(net00)
                                          net00 = tf.pad(
                                              net00,
                                              np.array(
                                                  [
                                                      [0, 0],
                                                      [1, 1],
                                                      [1, 1],
                                                      [0, 0],
                                                  ]
                                              ),
                                          )
                                          net00 = slim.conv2d(
                                              net00,
                                              256,
                                              (3, 3),
                                              (1, 1),
                                              activation_fn=None,
                                              padding="VALID",
                                          )
                                          net00 = slim.batch_norm(net00)
                                          net00 = slim.nn.relu(net00)
                                          net00 = tf.pad(
                                              net00,
                                              np.array(
                                                  [
                                                      [0, 0],
                                                      [0, 0],
                                                      [0, 0],
                                                      [0, 0],
                                                  ]
                                              ),
                                          )
                                          net00 = slim.conv2d(
                                              net00,
                                              512,
                                              (1, 1),
                                              (1, 1),
                                              activation_fn=None,
                                              padding="VALID",
                                          )
                                      net01 = net0
                                  net0 = tf.add_n([net00, net01])
                          net0 = tf.pad(
                              net0,
                              np.array(
                                  [[0, 0], [0, 0], [0, 0], [0, 0]]
                              ),
                          )
                          net0 = deconv_layer(
                              net0, 2, 512, method=deconv
                          )
  
                      net1 = net
                      with tf.name_scope("nn.Sequential"):
                          with tf.name_scope("nn.Sequential"):
                              with tf.name_scope("nn.ConcatTable"):
                                  net10 = net1
                                  with tf.name_scope("nn.Sequential"):
                                      net10 = slim.batch_norm(net10)
                                      net10 = slim.nn.relu(net10)
                                      net10 = tf.pad(
                                          net10,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net10 = slim.conv2d(
                                          net10,
                                          128,
                                          (1, 1),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                      net10 = slim.batch_norm(net10)
                                      net10 = slim.nn.relu(net10)
                                      net10 = tf.pad(
                                          net10,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [1, 1],
                                                  [1, 1],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net10 = slim.conv2d(
                                          net10,
                                          128,
                                          (3, 3),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                      net10 = slim.batch_norm(net10)
                                      net10 = slim.nn.relu(net10)
                                      net10 = tf.pad(
                                          net10,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net10 = slim.conv2d(
                                          net10,
                                          256,
                                          (1, 1),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                  net11 = net1
                              net1 = tf.add_n([net10, net11])
                          with tf.name_scope("nn.Sequential"):
                              with tf.name_scope("nn.ConcatTable"):
                                  net10 = net1
                                  with tf.name_scope("nn.Sequential"):
                                      net10 = slim.batch_norm(net10)
                                      net10 = slim.nn.relu(net10)
                                      net10 = tf.pad(
                                          net10,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net10 = slim.conv2d(
                                          net10,
                                          128,
                                          (1, 1),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                      net10 = slim.batch_norm(net10)
                                      net10 = slim.nn.relu(net10)
                                      net10 = tf.pad(
                                          net10,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [1, 1],
                                                  [1, 1],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net10 = slim.conv2d(
                                          net10,
                                          128,
                                          (3, 3),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                      net10 = slim.batch_norm(net10)
                                      net10 = slim.nn.relu(net10)
                                      net10 = tf.pad(
                                          net10,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net10 = slim.conv2d(
                                          net10,
                                          256,
                                          (1, 1),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                  net11 = net1
                              net1 = tf.add_n([net10, net11])
                          with tf.name_scope("nn.Sequential"):
                              with tf.name_scope("nn.ConcatTable"):
                                  net10 = net1
                                  with tf.name_scope("nn.Sequential"):
                                      net10 = slim.batch_norm(net10)
                                      net10 = slim.nn.relu(net10)
                                      net10 = tf.pad(
                                          net10,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net10 = slim.conv2d(
                                          net10,
                                          256,
                                          (1, 1),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                      net10 = slim.batch_norm(net10)
                                      net10 = slim.nn.relu(net10)
                                      net10 = tf.pad(
                                          net10,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [1, 1],
                                                  [1, 1],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net10 = slim.conv2d(
                                          net10,
                                          256,
                                          (3, 3),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                      net10 = slim.batch_norm(net10)
                                      net10 = slim.nn.relu(net10)
                                      net10 = tf.pad(
                                          net10,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net10 = slim.conv2d(
                                          net10,
                                          512,
                                          (1, 1),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                                  net11 = net1
                                  with tf.name_scope("nn.Sequential"):
                                      net11 = tf.pad(
                                          net11,
                                          np.array(
                                              [
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                                  [0, 0],
                                              ]
                                          ),
                                      )
                                      net11 = slim.conv2d(
                                          net11,
                                          512,
                                          (1, 1),
                                          (1, 1),
                                          activation_fn=None,
                                          padding="VALID",
                                      )
                              net1 = tf.add_n([net10, net11])
                  net = tf.add_n([net0, net1])
              net = tf.pad(
                  net, np.array([[0, 0], [0, 0], [0, 0], [0, 0]])
              )
              net = slim.conv2d(
                  net,
                  512,
                  (1, 1),
                  (1, 1),
                  activation_fn=None,
                  padding="VALID",
              )
              net = slim.batch_norm(net)
              net = slim.nn.relu(net)
              net = tf.pad(
                  net, np.array([[0, 0], [0, 0], [0, 0], [0, 0]])
              )
              net = slim.conv2d(
                  net,
                  256,
                  (1, 1),
                  (1, 1),
                  activation_fn=None,
                  padding="VALID",
              )
              net = slim.batch_norm(net)
              net = slim.nn.relu(net)
              net = tf.pad(
                  net, np.array([[0, 0], [0, 0], [0, 0], [0, 0]])
              )
              net = slim.conv2d(
                  net,
                  out_channels,
                  (1, 1),
                  (1, 1),
                  activation_fn=None,
                  padding="VALID",
              )
          net = tf.pad(net, np.array([[0, 0], [0, 0], [0, 0], [0, 0]]))
          net = deconv_layer(net, 4, out_channels, method=deconv)
  
      return net
  
file_path: insightface/reconstruction/ostec/external/landmark_detector/models.py
imports: import tensorflow
  import numpy
label_desc: Use image node_id 9 for calling a global function with example usage: StackedHourglassTorch(inputs, out_channels, deconv) and returns: net