/*device_ordinal=*/rewriter.getI64IntegerAttr(0),
          rewriter.getStringAttr("TPU"));
    }

    constexpr int64_t kDefaultCostEstimate = 1000000;
    rewriter.replaceOpWithNewOp<TF::XlaHostComputeOp>(
        op, op.getResultTypes(), op.getInputs(),
        /*ancestors=*/rewriter.getArrayAttr({}),
        rewriter.getArrayAttr(shape_attrs),
        /*shape_inference_graph=*/

        // The op is disabled by default. Otherwise, values will be saved
        // during calibration.
        rewriter.getNamedAttr("enabled", rewriter.getBoolAttr(enabled)),
        rewriter.getNamedAttr("func_name", rewriter.getStringAttr(func_name)),
        rewriter.getNamedAttr("node_name", rewriter.getStringAttr(node_name)),
    };
    return dump_attributes;
  }

  StringAttr DuplicateFunction(Operation *op,

    };

    auto dequant_values =
        mlir::cast<DenseIntOrFPElementsAttr>(input_values)
            .mapValues(FloatType::getF32(rewriter.getContext()),
                       llvm::function_ref<DequantizeFuncType>(dequantize_func));
    rewriter.replaceOpWithNewOp<TFL::ConstOp>(dequant_op, dequant_op.getType(),
                                              dequant_values);

    return success();
  }
};

};  // namespace

LogicalResult Tf2XlaRewriter::RewriteOp(Operation* op,
                                        PatternRewriter& rewriter,
                                        const std::string& device_type) {
  Tf2XlaRewriter tf2xla_rewriter(op, rewriter, device_type);
  return tf2xla_rewriter.LegalizeOp();
}

Tf2XlaRewriter::Tf2XlaRewriter(Operation* op, PatternRewriter& rewriter,

DATA runtime·tls_g+0(SB)/8, $16
GLOBL runtime·tls_g+0(SB), NOPTR, $8
#endif
#ifdef GOOS_windows
GLOBL runtime·tls_g+0(SB), NOPTR, $8
#endif

// The compiler and assembler's -spectre=ret mode rewrites
// all indirect CALL AX / JMP AX instructions to be
// CALL retpolineAX / JMP retpolineAX.
// See https://support.google.com/faqs/answer/7625886.
#define RETPOLINE(reg) \

        RankedTensorType::get({cur_rank}, rewriter.getIntegerType(64));
    auto new_shape_const_attr =
        DenseElementsAttr::get(shape_spec_type, new_shape.getShape());
    rewriter.setInsertionPointAfter(weight_op);
    auto new_shape_const = rewriter.create<arith::ConstantOp>(
        weight_op->getLoc(), shape_spec_type, new_shape_const_attr);
    auto reshape_op = rewriter.create<TF::ReshapeOp>(

      PatternRewriter& rewriter) const;

 public:
  LogicalResult matchAndRewrite(Conv2dOpTy op,
                                PatternRewriter& rewriter) const override;
};

template <typename Conv2dOpTy>
LogicalResult ConvertTFDilatedConvOp<Conv2dOpTy>::matchAndRewrite(
    Conv2dOpTy op, PatternRewriter& rewriter) const {
  if (!op.getResult().hasOneUse()) {

// a Value can be rewritten which make it impossible to correctly rewrite sibling Value users. To workaround this
// case, candidates for CC opcodes are converted in two steps:
//   1. Convert all (x (Op ...) ...) into (x (Select0 (OpCC ...) ...). See convertPPC64OpToOpCC for more
//      detail on how and why this is done there.
//   2. Rewrite (CMPconst [0] (Select0 (OpCC ...))) into (Select1 (OpCC...))

        loc, GetI64ElementsAttr(new_broadcast_shape, &rewriter));

    auto new_broadcast_to_op = rewriter.create<TFL::BroadcastToOp>(
        loc, RankedTensorType::get(new_broadcast_shape, rewriter.getF32Type()),
        new_inner_reshape_op.getOutput(), new_broadcast_shape_value);

    // Create a new broadcast_op to replace the old broadcast_op.
    rewriter.replaceOp(tfl_broadcast_to_op, new_broadcast_to_op.getResult());

	}

	return
}

// validateAuthorityRewrite ensures we only attempt rewrite authority in a single place.
func validateAuthorityRewrite(rewrite *networking.HTTPRewrite, headers *networking.Headers) error {
	current := rewrite.GetAuthority()
	for k, v := range headers.GetRequest().GetSet() {
		if !isAuthorityHeader(k) {
			continue
		}
		if current != "" {