grad, axis=reduction_axes, keepdims=True)
  bias_grad = tf.reshape(updates_grad_reshaped, input_value_shape)

  dilations = [1, op.get_attr('dilation_w'), op.get_attr('dilation_h'), 1]
  strides = [1, op.get_attr('stride_w'), op.get_attr('stride_h'), 1]
  padding = op.get_attr('padding')
  shape_0, shape_1 = tf.shape_n([op.inputs[0], op.inputs[1]])
  return [
      tf.compat.v1.nn.conv2d_backprop_input(
          shape_0,

func Getxattr(file string, attr string, dest []byte) (sz int, err error) {
	d := initxattrdest(dest, 0)
	destsize := len(dest)

	nsid, a, err := xattrnamespace(attr)
	if err != nil {
		return -1, err
	}

	return ExtattrGetFile(file, nsid, a, uintptr(d), destsize)
}

func Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) {

	MOVD R8, ret+0(FP)
	RET

TEXT ·get_GetxattrAddr(SB), NOSPLIT|NOFRAME, $0-8
	MOVD $·Getxattr(SB), R8
	MOVD R8, ret+0(FP)
	RET

TEXT ·get_NanosleepAddr(SB), NOSPLIT|NOFRAME, $0-8
	MOVD $·Nanosleep(SB), R8
	MOVD R8, ret+0(FP)
	RET

TEXT ·get_SetxattrAddr(SB), NOSPLIT|NOFRAME, $0-8
	MOVD $·Setxattr(SB), R8
	MOVD R8, ret+0(FP)
	RET

TEXT ·get_Wait4Addr(SB), NOSPLIT|NOFRAME, $0-8
	MOVD $·Wait4(SB), R8

    flexbuffers::Builder* builder) {
  auto int_attr = mlir::dyn_cast_or_null<IntegerAttr>(attrs.get(attribute));
  if (!int_attr) {
    return func.emitError()
           << attribute.c_str() << " attribute is not set or not an integer";
  }
  builder->Int(attribute.c_str(), int_attr.getInt());
  return success();
}

LogicalResult ConvertSSDPostProcessFunc::AddFloatAttr(

    float max_percentile;
    OP_REQUIRES_OK(context, context->GetAttr("calibration_method",
                                             &calibration_method_value));
    OP_REQUIRES_OK(context, context->GetAttr("num_bins", &num_bins));
    OP_REQUIRES_OK(context,
                   context->GetAttr("min_percentile", &min_percentile));
    OP_REQUIRES_OK(context,
                   context->GetAttr("max_percentile", &max_percentile));

    .SetIsStateful()
    .SetShapeFn([](shape_inference::InferenceContext* c) {
      c->set_output(0, c->Scalar());
      DataType t;
      TF_RETURN_IF_ERROR(c->GetAttr("dtype", &t));
      PartialTensorShape p;
      TF_RETURN_IF_ERROR(c->GetAttr("shape", &p));
      shape_inference::ShapeHandle s;
      TF_RETURN_IF_ERROR(c->MakeShapeFromPartialTensorShape(p, &s));
      c->set_output_handle_shapes_and_types(

def test_route_classes():
    routes = {}
    for r in app.router.routes:
        assert isinstance(r, Route)
        routes[r.path] = r
    assert getattr(routes["/a/"], "x_type") == "A"  # noqa: B009
    assert getattr(routes["/a/b/"], "x_type") == "B"  # noqa: B009
    assert getattr(routes["/a/b/c/"], "x_type") == "C"  # noqa: B009


def test_openapi_schema():
    response = client.get("/openapi.json")

    string file_name;
    string func_name;
    string node_name;
    OP_REQUIRES_OK(ctx, ctx->GetAttr("log_dir_path", &log_dir_path));
    OP_REQUIRES_OK(ctx, ctx->GetAttr("enabled", &enabled_));
    OP_REQUIRES_OK(ctx, ctx->GetAttr("file_name", &file_name));
    OP_REQUIRES_OK(ctx, ctx->GetAttr("func_name", &func_name));
    OP_REQUIRES_OK(ctx, ctx->GetAttr("node_name", &node_name));
    OP_REQUIRES_OK(ctx, ctx->env()->RecursivelyCreateDir(log_dir_path));

  // will be preserved since it has uses.
  %2 = "tf.MyCustomOp"(%1, %0) {fused_activation_function = "RELU", int_attr = 2 : i32}  : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32>
  // will be preserved since it has side-effect.
  "tf.MyCustomOp"(%1, %0) {fused_activation_function = "RELU", int_attr = 2 : i32}  : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32>
  func.return %2 : tensor<4xf32>

                                          dq.getArg());
      dq.getResult().replaceAllUsesWith(dcast);
      if (auto extra_attr = op->getAttr(mlir::quant::kVolatileOpAttrName)) {
        dcast->setAttr(mlir::quant::kVolatileOpAttrName, extra_attr);
      }
      dq.erase();
    } else if (auto q = llvm::dyn_cast<quantfork::QuantizeCastOp>(op)) {
      auto out_type = q.getResult().getType();