if (followingChar == '\n') {
                return true; // '\\\r\n' discarded from stream
            }
            pushBack(nextChar);
            pushBack(followingChar);
            return false;
        } else {
            pushBack(nextChar);
            return false;
        }
    }

    private int next() throws IOException {
        if (readAheadChars[0] != -1) {

	default:
		t.Skip("skipped for many architectures")

	case "arm64", "amd64": // register ABI
		fn := "(*List[go.shape.int_0]).PushBack"
		if true /* was buildcfg.Experiment.Unified */ {
			// Unified mangles differently
			fn = "(*List[go.shape.int]).PushBack"
		}
		testDebugLines(t, "-N -l", "pushback.go", fn, []int{17, 18, 19, 20, 21, 22, 24}, true)
	}
}

func TestDebugLinesConvert(t *testing.T) {
	unixOnly(t)

		// Don't make other Acquire calls block on one that's doomed to fail.
		s.mu.Unlock()
		<-done
		return ctx.Err()
	}

	ready := make(chan struct{})
	w := waiter{n: n, ready: ready}
	elem := s.waiters.PushBack(w)
	s.mu.Unlock()

	select {
	case <-done:
		s.mu.Lock()
		select {
		case <-ready:
			// Acquired the semaphore after we were canceled.
			// Pretend we didn't and put the tokens back.
			s.cur -= n

    signature->push_back(AnyQuantizedType::get(
        quant.getFlags(), quant.getStorageType(), quant.getExpressedType(),
        quant.getStorageTypeMin(), quant.getStorageTypeMax()));
  } else if (auto any = spec.dyn_cast_or_null<AnyQuantizedType>()) {
    signature->push_back(any);
  } else {  // float
    signature->push_back(AnyQuantizedType());
  }
}

  // Initialize function arguments
  all_arguments_.push_back(OpArgumentView("AbstractContext*", "ctx"));
  for (const auto& arg : op_.Inputs()) {
    all_arguments_.push_back(OpArgumentView(arg));
  }
  for (const auto& arg : op_.Outputs()) {
    all_arguments_.push_back(OpArgumentView(arg));
  }
  for (const auto& attr : op.Attributes()) {
    all_arguments_.push_back(OpArgumentView(attr));
  }

      for (const auto& item : value.list().i())
        attrs.push_back(builder->getI64IntegerAttr(item));
      for (const auto& item : value.list().s())
        attrs.push_back(builder->getStringAttr(item));
      for (const auto& item : value.list().f())
        attrs.push_back(builder->getFloatAttr(builder->getF32Type(), item));
      for (const auto& item : value.list().b())
        attrs.push_back(builder->getBoolAttr(item));

  llvm::SmallVector<mlir::Type, 4> operand_types;
  if (options.has_chain) operand_types.push_back(chain_type);
  if (parser.resolveOperands(in_chains, operand_types, loc, result.operands) ||
      parser.resolveOperands(operands, tensor_type, result.operands))
    return mlir::failure();

  if (options.has_chain) result.types.push_back(chain_type);
  result.types.append(num_results, tensor_type);

      return {};
    }
    if (tf_op_name[i] == '.') {
      compose_func_name.push_back('_');
    } else if (tf_op_name[i] >= 'A' && tf_op_name[i] <= 'Z') {
      compose_func_name.push_back('_');
      compose_func_name.push_back(tf_op_name[i] + 'a' - 'A');
    } else {
      compose_func_name.push_back(tf_op_name[i]);
    }
  }
  return compose_func_name;
}

                func.getArgAttrOfType<mlir::StringAttr>(i, "tf.device")) {
          input_devices.push_back(input_device.getValue());
        } else {
          input_devices.push_back("");
        }
      }
      if (auto* bound_input =
              mlir::tf_saved_model::LookupBoundInput(func, i, symbol_table)) {
        bound_inputs.push_back(bound_input);
      }
    }

    llvm::SmallVector<llvm::StringRef, 4> output_names;

      t.flat<float>().setZero();
      outputs->push_back(t);
    } else if (output_name == "dense/kernel") {
      Tensor t =
          Tensor(tensorflow::DT_FLOAT, tensorflow::TensorShape({100, 50}));
      t.flat<float>().setZero();
      outputs->push_back(t);
    } else if (output_name == "var1") {