if (orig_op->Device() != kVariantDeviceNull) return absl::OkStatus();
  if (orig_op->is_function()) return absl::OkStatus();

  // TODO(fengliuai): We need a better condition to skip the rewrite. Currently,
  // The rewrite is enabled for all the tf ops and it is a no-op if the tf op
  // isn't a composite op. The following ops are explicitly skipped here because
  // their "no-op" expansion is known to cause problems in some cases.

		switch n := n.(type) {
		case *ast.ImportSpec:
			// rewrite import path "cmd/compile/internal/syntax" to "go/token"
			if n.Path.Kind != token.STRING {
				panic("invalid import path")
			}
			m.rename(&n.Path.Value)
			return false
		case *ast.SelectorExpr:
			// rewrite syntax.Pos to token.Pos
			m.renameSel(n)
		case *ast.CallExpr:
			// rewrite x.IsKnown() to x.IsValid()

}

var ssaRewriteFileSubstring = filepath.FromSlash("src/cmd/compile/internal/ssa/rewrite")

// isUnneededSSARewriteFile reports whether srcFile is a
// src/cmd/compile/internal/ssa/rewriteARCHNAME.go file for an
// architecture that isn't for the given GOARCH.
//
// When unneeded is true archCaps is the rewrite base filename without
// the "rewrite" prefix or ".go" suffix: AMD64, 386, ARM, ARM64, etc.

    }

    def "scrolling the label by zero row between redraw won't rewrite the text to ansi"() {
        given:
        label.text = "text"

        when:
        redraw()
        label.scrollBy(0)
        redraw()

        then:
        1 * ansi.a('text')
        0 * ansi._
    }

    def "newLineAdjustment between redraw won't rewrite the text to ansi"() {
        given:
        label.text = "text"

		t.Fatal(err)
	}

	defer func() { *write = false }()
	*write = true

	initParserMode()
	initRewrite()

	const maxWeight = 2 << 20
	var buf, errBuf strings.Builder
	s := newSequencer(maxWeight, &buf, &errBuf)
	s.Add(fileWeight(fn, info), func(r *reporter) error {
		return processFile(fn, info, nil, r)
	})
	if s.GetExitCode() == 0 {
		t.Fatal("rewrite of read-only file succeeded unexpectedly")
	}

def EmbeddingPipeliningPass : Pass<"tf-embedding-pipelining", "mlir::ModuleOp"> {
  let summary = "Rewrite graph for embedding pipelining";
  let constructor = "TFDevice::CreateEmbeddingPipeliningPass()";
    let description = [{
    For architectures that support accelerated embedding lookups, this pass will
    rewrite the graph to use pipelining for better device utilization.
  }];
}

    return IsTransposeOpWithPermuation(lhs.getDefiningOp(),
                                       kNhwcToNchwPermutation);
  }

  void rewrite(AddOp op, PatternRewriter& rewriter) const override {
    DeferRhsTransposeForBinaryOp(op, rewriter);
  }
};

// Rewrites the `reduce_window(transpose(%activation), %init_value)` patterns to
// `transpose(reduce_window(%activation), %init_value)`, deferring the transpose

						if err != nil {
							// Do not rewrite the URL if it isn't valid.  It is intended not
							// to error here to prevent the inability to understand the
							// content of the body to cause a fatal error.
							continue
						}
						token.Attr[i].Val = urlRewriter(url)
					}
				}
			}
			_, err = writer.Write([]byte(token.String()))
		default:
			_, err = writer.Write(tokenizer.Raw())
		}
	}

    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();
      }

      // If the op is terminator, we shouldn't rewrite.
      if (candidate_op->hasTrait<OpTrait::IsTerminator>()) {
        return failure();
      }

                                         PatternRewriter& rewriter) {
  OpBuilder::InsertionGuard insertion_guard(rewriter);

  // Create a new `CallOp` that calls `callee_func_op`.
  rewriter.setInsertionPoint(xla_call_module_op);
  auto call_op =
      rewriter.create<func::CallOp>(xla_call_module_op.getLoc(), callee_func_op,