symIdx = int(info >> 32)
				}
				p = p[8:]
				if rela != 0 {
					add = e.Uint64(p)
					p = p[8:]
				}
			} else {
				// 32-bit rel/rela
				rOff = int32(e.Uint32(p))

				p = p[4:]
				info := e.Uint32(p)
				relocType = uint64(info & 0xff)
				symIdx = int(info >> 8)
				p = p[4:]
				if rela != 0 {
					add = uint64(e.Uint32(p))
					p = p[4:]
				}
			}

<link href="${fe:url('/css/admin/bootstrap.min.css')}" rel="stylesheet" type="text/css" />
<link href="${fe:url('/css/admin/font-awesome.min.css')}" rel="stylesheet" type="text/css" />
<link href="${fe:url('/css/admin/adminlte.min.css')}" rel="stylesheet" type="text/css" />
<link href="${fe:url('/css/admin/plugins/daterangepicker/daterangepicker.css')}" rel="stylesheet" type="text/css" />

  op: "custom_embedding_matmul"
}
library {
  function {
    signature {
      name: "custom_relu"
    }
    attr {
      key: "_implements"
      value {
        func {
          name: "tensorflow.relu"
        }
      }
    }
  }
  function {
    signature {
      name: "custom_embedding_matmul"
    }
    attr {
      key: "_implements"
      value {
        func {

// CHECK-LABEL: @main

  return op_ptr->Execute(absl::MakeSpan(backprops, 1), &num_retvals);
}

// Op: Relu()
// Summary: Computes rectified linear: `max(features, 0)`.
//
// Description:
//   See: https://en.wikipedia.org/wiki/Rectifier_(neural_networks)
//   Example usage:
//   >>> tf.nn.relu([-2., 0., 3.]).numpy()
//   array([0., 0., 3.], dtype=float32)
Status Relu(AbstractContext* ctx, AbstractTensorHandle* const features,

  %0 = "tfl.add"(%arg0, %arg1) {fused_activation_function = "RELU", tac.device = "CPU"} : (tensor<10x10x10xf32>, tensor<10xf32>) -> tensor<10x10x10xf32>
  // CHECK: tac.cost = 1.000000e+03
  %1 = "tfl.mul"(%0, %arg1) {fused_activation_function = "RELU", tac.device = "CPU"} : (tensor<10x10x10xf32>, tensor<10xf32>) -> tensor<10x10x10xf32>
  func.return %1 : tensor<10x10x10xf32>
}

// -----

  %14 = "tf.AddV2"(%10, %12) : (tensor<?x256x56x56xf32>, tensor<?x256x56x56xf32>) -> tensor<?x256x56x56xf32>
  %15 = "tf.Relu"(%14) : (tensor<?x256x56x56xf32>) -> tensor<?x256x56x56xf32>

  // CHECK: %[[ADD:[0-9]*]] = "tf.AddV2"(%[[BATCH_NORM1]], %[[BATCH_NORM2]])
  // CHECK: %[[RELU:[0-9]*]] = "tf.Relu"(%[[ADD]])

  // Reduce spatial dimensions
  %16 = "tf.Mean"(%15, %1) : (tensor<?x256x56x56xf32>, tensor<2xi32>) -> tensor<?x256xf32>

  // CHECK: device = "cpu"
  %2 = "tf.Relu"(%1) {T = f32, _output_shapes = ["tfshape$dim { size: 3 } dim { size: 3 }"], device = "cpu"} : (tensor<3x3xf32>) -> tensor<3x3xf32>
  // CHECK: device = "gpu"
  %3 = "tf.Relu"(%2) {T = f32, _output_shapes = ["tfshape$dim { size: 3 } dim { size: 3 }"]} : (tensor<3x3xf32>) -> tensor<3x3xf32>
  func.return %3 : tensor<3x3xf32>

    value {
      s: "NHWC"
    }
  }
}
node {
  name: "conv_net_2d_1/Relu"
  op: "Relu"
  input: "conv_net_2d_1/conv_2d_0/BiasAdd"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
}
node {
  name: "output_0"
  op: "Identity"
  input: "conv_net_2d_1/Relu"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
}

	os.Remove(f.Name())

	// 6g/8g print the offset as dec, but 5g/9g print the offset as hex.
	patterns := []string{
		`rel 0\+\d t=R_ADDR p\.x\+8\r?\n`,       // y = &x.b
		`rel 0\+\d t=R_ADDR p\.x\+(28|1c)\r?\n`, // z = &x.d.q
		`rel 0\+\d t=R_ADDR p\.b\+5\r?\n`,       // c = &b[5]
		`rel 0\+\d t=R_ADDR p\.x\+(88|58)\r?\n`, // w = &x.f[3].r
	}
	for _, p := range patterns {
		if ok, err := regexp.Match(p, out); !ok || err != nil {