elif self.same_scale_op == 'max_pool':
          out = nn_ops.max_pool(out, ksize=3, strides=1, padding='SAME')
        elif self.same_scale_op == 'pad':
          paddings = array_ops.ones(
              (array_ops.rank(out), 2), dtype=dtypes.int32
          )
          out = array_ops.pad(out, paddings, 'CONSTANT')
        elif self.same_scale_op == 'reshape':
          out = array_ops.reshape(out, [-1])

  // CHECK-NEXT: return [[RESULT]] : tensor<1x128x128x8xf32>
}

func.func @testDilatedConvWithFp16(%arg0 : tensor<1x20x30x40xf16>, %arg1: tensor<5x5x40x32xf16>) -> tensor<1x20x30x32xf16> {
  %block_shape = arith.constant dense<2> : tensor<2xi32>
  %paddings = arith.constant dense<4> : tensor<2x2xi32>

	r11          uint32
	r12          uint32

	spr  uint32
	lrr  uint32
	pc   uint32
	cpsr uint32

	fpscr   uint32
	padding uint32

	floatNeon [16]neon128

	bvr      [8]uint32
	bcr      [8]uint32
	wvr      [1]uint32
	wcr      [1]uint32
	padding2 [2]uint32
}

func (c *context) ip() uintptr { return uintptr(c.pc) }
func (c *context) sp() uintptr { return uintptr(c.spr) }

    input_ = tf.constant([[1, 2, 3], [4, 5, 6]], dtype=tf.float32)
    paddings = tf.constant([[
        1,
        1,
    ], [2, 2]])
    kwargs = {
        'input': input_,
        'paddings': paddings,
        'mode': mode,
    }
    kwargs_ = {
        'input_': input_,
        'paddings': paddings,
        'mode': mode,
    }
    # Make sure the composition python function is correct

    for padding `input`.

    The padded size of each dimension D of the output is:

      `paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`

    For example:

    ```
    # 't' is [[1, 1], [2, 2]]
    # 'paddings' is [[1, 1], [2, 2]]
    # rank of 't' is 2
    pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
                          [0, 0, 1, 1, 0, 0]

     channel // (space_to_depth_block_size**2)
    ])

    kernel = conv0.weights[0]
    # [7, 7, 3, 64] --> [8, 8, 3, 64]

    kernel = tf.pad(
     kernel,
     paddings=tf.constant([[1, 0], [1, 0], [0, 0], [0, 0]]),
     mode='CONSTANT',
     constant_values=0.)
    # Transform kernel follows the space-to-depth logic: https://www.tensorflow.org/api_docs/python/tf/nn/space_to_depth)

	datasel   uint32
	_st       [8]fpreg
	status    uint16
	magic     uint16
	_fxsr_env [6]uint32
	mxcsr     uint32
	reserved  uint32
	_fxsr_st  [8]fpxreg
	_xmm      [8]xmmreg
	padding1  [44]uint32
	anon0     [48]byte
}

type timespec struct {
	tv_sec  int32
	tv_nsec int32
}

//go:nosplit
func (ts *timespec) setNsec(ns int64) {
	ts.tv_sec = timediv(ns, 1e9, &ts.tv_nsec)
}

  auto paddings = Const(scope_, {{1, 1}, {2, 2}});
  TensorShape y_shape({4, 7});
  auto y = Pad(scope_, x, paddings);
  RunTest(x, x_shape, y, y_shape);
}

TEST_F(ArrayGradTest, SpaceToBatchGrad) {
  TensorShape x_shape({1, 2, 2, 1});
  auto x = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(x_shape));
  auto paddings = Const(scope_, {{1, 1}, {1, 1}});

node {
  name: "conv1_pad_1/Pad"
  op: "Pad"
  input: "transpose_1/transpose"
  input: "conv1_pad_1/Pad/paddings"
  device: "/job:localhost/replica:0/task:0/device:GPU:0"
  attr {
    key: "T"
    value {
      type: DT_HALF
    }
  }
  attr {
    key: "Tpaddings"
    value {
      type: DT_INT32
    }
  }
}
node {

<td align="left" width="10" style="padding:0;margin:0;line-height:1px;font-size:1px;"></td>
<td align="left" style="padding:0;margin:0;line-height:1px;font-size:1px;">
<table align="left" cellpadding="0" cellspacing="0" border="0" style="padding:0px; margin:0px;padding:0;margin:0;line-height:1px;font-size:1px;">
<tbody>
<tr>
<td align="left" style="padding:0;margin:0;line-height:1px;font-size:1px;">