return false;
  }

  // Prevent "missing hashCode" warning by explicitly forcing subclasses implement it
  @Override
  public abstract int hashCode();

  /*
   * The implementation neither produces nor consumes any non-null instance of type C, so
   * casting the type parameter is safe.
   */
  @SuppressWarnings("unchecked")
  static <C extends Comparable> Cut<C> belowAll() {
    return (Cut<C>) BelowAll.INSTANCE;
  }

        reader.readNextLine(result)
        result.toString() == "line 2"

        !reader.readNextLine(result)

        where:
        eol << ['\n', '\r', '\r\n']
    }

    def "consumes quoted strings"() {
        when:
        input = '''
"abc\\""
"\\""
'''

        then:
        output == '\n"abc\\""\n"\\""'
    }

    def "removes line continuation characters"() {

    return false;
  }

  // Prevent "missing hashCode" warning by explicitly forcing subclasses implement it
  @Override
  public abstract int hashCode();

  /*
   * The implementation neither produces nor consumes any non-null instance of type C, so
   * casting the type parameter is safe.
   */
  @SuppressWarnings("unchecked")
  static <C extends Comparable> Cut<C> belowAll() {
    return (Cut<C>) BelowAll.INSTANCE;
  }

	ws.Path(APIGroupPrefix)
	ws.Doc("get available API versions")
	ws.Route(ws.GET("/").To(s.restfulHandle).
		Doc("get available API versions").
		Operation("getAPIVersions").
		Produces(mediaTypes...).
		Consumes(mediaTypes...).
		Writes(metav1.APIGroupList{}))
	return ws

   * {@code A -> B}.
   *
   * @since 9.0 (in 1.0 as {@code com.google.common.base.Service.State})
   */
  enum State {
    /** A service in this state is inactive. It does minimal work and consumes minimal resources. */
    NEW,

    /** A service in this state is transitioning to {@link #RUNNING}. */
    STARTING,

    /** A service in this state is operational. */
    RUNNING,

		}
	}
}

// EnableFullDuplex indicates that the request handler will interleave reads from [Request.Body]
// with writes to the [ResponseWriter].
//
// For HTTP/1 requests, the Go HTTP server by default consumes any unread portion of
// the request body before beginning to write the response, preventing handlers from
// concurrently reading from the request and writing the response.

      result.write(this, i)
      // Consume '"'.
      readByte()
      return result.readUtf8()
    }

    if (size == i + 1L) return null // Dangling escape.
    result.write(this, i)
    // Consume '\'.
    readByte()
    result.write(this, 1L) // The escaped character.
  }
}

/**
 * Consumes and returns a non-empty token, terminating at special characters in

 */
@HasInternalProtocol
public interface TaskInputs {
    /**
     * Returns true if this task has declared the inputs that it consumes.
     *
     * @return true if this task has declared any inputs.
     */
    boolean getHasInputs();

    /**
     * Returns the input files of this task.
     *

	case "watch":
		// WATCH supports `SendInitialEvents` option, which effectively means
		// that is starts with sending of the contents of a corresponding LIST call.
		// From that perspective, given that the watch only consumes APF seats
		// during its initialization (sending init events), its cost should then
		// be computed the same way as for a regular list.
		if utilfeature.DefaultFeatureGate.Enabled(features.WatchList) {

// Returns true if it is possible (but not guaranteed) that `n` calls a
// function.
bool MayCallFunction(const Node& n, const FunctionLibraryDefinition* flib_def);

// Returns true if `node` an operator that consumes only the shape of its input,
// not the data itself.
bool IsShapeConsumerOp(const Node& node);

// Computes a clustering summary for `graph`.  See documentation on
// `XlaAutoClusteringSummary` for details.