start, _, err := madmClnt.Heal(context.Background(), "healing-rewrite-bucket", "", opts, "", false, false)
	if err != nil {
		log.Fatalln(err)
	}
	fmt.Println("Healstart sequence ===")
	enc := json.NewEncoder(os.Stdout)
	if err = enc.Encode(&start); err != nil {
		log.Fatalln(err)
	}

	fmt.Println()
	for {
		_, status, err := madmClnt.Heal(context.Background(), "healing-rewrite-bucket", "", opts, start.ClientToken, false, false)

type traceArg uint64

// traceEventWriter is the high-level API for writing trace events.
//
// See the comment on traceWriter about style for more details as to why
// this type and its methods are structured the way they are.
type traceEventWriter struct {
	w traceWriter
}

// eventWriter creates a new traceEventWriter. It is the main entrypoint for writing trace events.
//

apiVersion: release-notes/v2
kind: feature
area: traffic-management
releaseNotes:
  - |

std::unique_ptr<OperationPass<ModuleOp>> CreateCompositeLoweringPass();

// Adds the HLO to TF rewrite patterns to the specified pattern list.
void PopulateLegalizeHloToTfPatterns(RewritePatternSet* patterns,
                                     MLIRContext* context);

// Adds the HLO to TFLite rewrite patterns to the specified pattern list.
void PopulateLegalizeHloToTFLitePatterns(RewritePatternSet* patterns,

		archive.Files[gomodIdx].Data = newGomodData
		rewrite = true
	}

	newGosumData, err := os.ReadFile(s.Path("go.sum"))
	if err != nil && !os.IsNotExist(err) {
		t.Fatalf("reading go.sum after -testsum: %v", err)
	}
	switch {
	case os.IsNotExist(err) && gosumIdx >= 0:
		// go.sum was deleted.
		rewrite = true
		archive.Files = append(archive.Files[:gosumIdx], archive.Files[gosumIdx+1:]...)

    if (failed(candidate_ops) || candidate_ops->empty()) return failure();

    // Rewrite the floating-point ops to the quantized version, by fusing
    // preceding dequantize ops and succeding quantize ops.
    for (Operation* candidate_op : *candidate_ops) {
      // If it is requantize op, we shouldn't rewrite this op.
      if (isa<QuantizeOpT, DequantizeOpT>(candidate_op)) {
        return failure();
      }

 * `withXml { link:{javadocPath}/org/gradle/api/XmlProvider.html[XmlProvider] arg \-> ... }`


[[sec:partial-rewrite]]
==== Partial rewrite of existing content

		lower = (*context).copy
	} else if !o.ignoreFinalSigma {
		lower = finalSigma(lower)
	}
	return &titleCaser{
		title:     x.title,
		lower:     lower,
		titleSpan: x.titleSpan,
		rewrite:   x.rewrite,
	}
}

func noSpan(c *context) bool {
	c.err = transform.ErrEndOfSpan
	return false
}

// TODO: consider a similar special case for the fast majority lower case. This

  auto dedup_op = builder.create<XlaRecvTPUEmbeddingDeduplicationDataOp>(
      loc, output_ty, config);

  // Rewrite RecvTPUEmbeddingActivations op to the corresponding internal op.
  if (recv_op)
    AddOperandAndRewriteAs<XlaRecvTPUEmbeddingActivationsOp>(
        recv_op, dedup_op, recv_op->getAttrs(), &builder);

  // Rewrite SendTPUEmbeddingGradients op to the corresponding internal op and
  // then update the OperandSegmentSize attribute.

def IsNhwcLayoutOp: Constraint<Neg<IsNchwLayoutOp.predicate>>;

// TODO(b/343278954): Move the creation of transposes to a separate prepare pass
// to avoid creating multiple pattern-rewrite rules for the same composite op.
def LegalizeTorchUpsampleBlinear2dComposite: Pat<
    (MHLO_CompositeOp:$old_val
    (variadic $input),
    ConstantStrAttr<StrAttr, "odml.upsample_bilinear2d">, $attrs, $_, $_),