for {
		pos, tok, lit := s.Scan()
		switch tok {
		case token.EOF:
			return
		case token.COMMENT:
			if lit[1] == '*' {
				lit = lit[:len(lit)-2] // strip trailing */
			}
			lit = lit[2:] // strip leading // or /*
			if rx.MatchString(lit) {
				p := fset.Position(prev)
				err := comment{p.Line, p.Column, lit}
				if res == nil {
					res = make(map[int][]comment)
				}

// RUN: tf-opt %s --tf-strip-saved-module-metadata --split-input-file | FileCheck %s

// CHECK-LABEL: module
// CHECK-NOT: tf_saved_model
module attributes {tf_saved_model.semantics} {
  // CHECK: tf_saved_model.global_tensor
  // CHECK-NOT: tf_saved_model
  "tf_saved_model.global_tensor"() { is_mutable, sym_name = "v", type = tensor<?xf32>, value = dense<1.> : tensor<1xf32> } : () -> ()

// - A line break can be forced by adding a couple of empty spaces at the end of a text line.
// - All indentation is removed. The resulting output is not indented.
func LongDesc(s string) string {
	// Strip beginning and trailing space characters (including empty lines) and split the lines into a slice
	lines := strings.Split(strings.TrimSpace(s), "\n")

	output := []string{}
	paragraph := []string{}

            return toolSearchPath.locate(compilerType, SymbolExtractorOsConfig.current().getExecutableName());
        }
        if (compilerType == ToolType.STRIPPER) {
            return toolSearchPath.locate(compilerType, "strip");
        }
        throw new IllegalArgumentException();
    }

    @Override
    public <T extends CompileSpec> org.gradle.language.base.internal.compile.Compiler<T> newCompiler(Class<T> spec) {

struct StripNoinlineAttributePass
    : public impl::StripNoinlineAttributePassBase<StripNoinlineAttributePass> {
 public:
  // void runOnOperation() override;
  void runOnOperation() override {
    // Strip the "tf._noinline" attribute from top-level functions.
    for (auto func_op : getOperation().getOps<func::FuncOp>())
      func_op->removeAttr("tf._noinline");
  }
};

}  // namespace

    if not elem.text or not elem.text.strip():
      elem.text = indent_str + '  '
    if not elem.tail or not elem.tail.strip():
      elem.tail = indent_str
    for elem in elem:
      indent_xml(elem, level + 1)
    if not elem.tail or not elem.tail.strip():
      elem.tail = indent_str
  else:
    if level and (not elem.tail or not elem.tail.strip()):
      elem.tail = indent_str

// RUN: tf-opt %s -allow-unregistered-dialect --tf-strip-tf-attributes --split-input-file | FileCheck %s

// CHECK-LABEL: strips_attributes
// CHECK-NOT: tf
func.func @strips_attributes(%arg0: tensor<32x28x28x1xf32> {tf._user_specified_name = "x"},
                             %arg1: tensor<3x3x1x5xf32> {tf._user_specified_name = "w1"},
                             %arg2: tensor<5xf32> {tf._user_specified_name = "b1"},

	return
}

// Unpointer returns T given *T or an alias thereof.
// For all other types it is the identity function.
// It does not look at underlying types.
// The result may be an alias.
//
// Use this function to strip off the optional pointer on a receiver
// in a field or method selection, without losing the named type
// (which is needed to compute the method set).
//
// See also [typeparams.MustDeref], which removes one level of

	"strings"
)

func main() {
	f, err := ioutil.TempFile("", "issue22660.go")
	if err != nil {
		log.Fatal(err)
	}
	f.Close()
	defer os.Remove(f.Name())

	// path must appear in error messages even if we strip them with -trimpath
	path := filepath.Join("users", "xxx", "go")
	var src bytes.Buffer
	fmt.Fprintf(&src, "//line %s:1\n", filepath.Join(path, "foo.go"))

	if err := ioutil.WriteFile(f.Name(), src.Bytes(), 0660); err != nil {

  description_ = attr_def.description();
  full_type_ = attr_def.type();
  default_value_ = attr_def.default_value();
  if (str_util::StartsWith(full_type_, "list(")) {
    is_list_ = true;
    // strip surrounding "list(%s)"
    base_type_ = full_type_.substr(5, full_type_.length() - 6);
  } else {
    is_list_ = false;
    base_type_ = full_type_;
  }
}

}  // namespace generator