// Simple common case: line is short enough to fit in a
			// single reader's buffer.
			if !isPrefix && len(wholeLine) == 0 {
				wholeLine = line
				break
			}

			wholeLine = append(wholeLine, line...)

			// Check if we read the whole line (or enough columns)
			// already.
			if !isPrefix || bytes.Count(wholeLine, []byte{':'}) >= readCols {
				break
			}
		}

			// Does the line end in CRLF instead of just LF?
			hasLF := bytes.HasSuffix(r.line, lf)
			hasCR := bytes.HasSuffix(r.line, crlf)
			wholeLine := r.line
			r.line = bytes.TrimRightFunc(wholeLine, isQPDiscardWhitespace)
			if bytes.HasSuffix(r.line, softSuffix) {
				rightStripped := wholeLine[len(r.line):]
				r.line = r.line[:len(r.line)-1]
				if !bytes.HasPrefix(rightStripped, lf) && !bytes.HasPrefix(rightStripped, crlf) &&

        stage1 = CachedScript.CompilationStage(Settings, ScriptPlugin, "stage1", Descriptions.script, file),
        stage2 = CachedScript.CompilationStage(Settings, ScriptPlugin, "stage2", Descriptions.script, file, hasBuildscriptBlock && hasBody)
    )


fun cachedBuildFile(file: File, hasBody: Boolean = false) =
    CachedScript.WholeFile(
        stage1 = CachedScript.CompilationStage(Project, TopLevel, "stage1", Descriptions.buildFile, file),

    }


private
data class MultiProjectCachedScripts(
    val settingsFile: CachedScript.WholeFile,
    val rootBuildFile: CachedScript.WholeFile,
    val leftBuildFile: CachedScript.WholeFile,
    val rightBuildFile: CachedScript.WholeFile

        cachedScripts.forEach { assertClassLoads(it, 0) }

    private
    fun assertClassLoads(cachedScript: CachedScript, count: Int) =
        when (cachedScript) {
            is CachedScript.WholeFile -> cachedScript.stages.forEach { assertClassLoads(it, count) }
            is CachedScript.CompilationStage -> assertClassLoads(cachedScript, count)
        }

    private

internal
interface KotlinDslCacheFixture {
    fun misses(vararg cachedScripts: CachedScript)
    fun hits(vararg cachedScripts: CachedScript)
}


sealed class CachedScript {

    class WholeFile(
        val stage1: CompilationStage,
        val stage2: CompilationStage
    ) : CachedScript() {

        val stages = listOf(stage1, stage2)
    }

    class CompilationStage(

def test():

  vocabulary_file = write_vocabulary_file(['cat', 'is', 'on', 'the', 'mat'])
  table_initializer = tf.lookup.TextFileInitializer(
      vocabulary_file, tf.string, tf.lookup.TextFileIndex.WHOLE_LINE, tf.int64,
      tf.lookup.TextFileIndex.LINE_NUMBER)
  # Incur another bound_input on the asset, but with a different sym_name, i.e.,
  # __tf_saved_model_asset1_tokens.txt vs. __tf_saved_model_asset0_tokens.txt.

    self.table = lookup_ops.StaticHashTable(
        lookup_ops.TextFileInitializer(self.asset, dtypes.string,
                                       lookup_ops.TextFileIndex.WHOLE_LINE,
                                       dtypes.int64,
                                       lookup_ops.TextFileIndex.LINE_NUMBER),
        -1)

  @def_function.function(

    // Now, this pattern matching only supports the following case, which is
    // commonly used among inference use cases:
    //
    // tf.lookup.TextFileInitializer(
    //   "test.txt", tf.string, tf.lookup.TextFileIndex.WHOLE_LINE,
    //   tf.int64, tf.lookup.TextFileIndex.LINE_NUMBER, delimiter=" ")
    //
    // In the above case, the delimiter will be not used since the key is just a
    // whole line and value is a line number.

    # "range" -> 1
    # "quantization" -> 2
    # default -> -1
    init = lookup_ops.TextFileInitializer(
        filename=asset_file,
        key_dtype=dtypes.string,
        key_index=lookup_ops.TextFileIndex.WHOLE_LINE,
        value_dtype=dtypes.int64,
        value_index=lookup_ops.TextFileIndex.LINE_NUMBER,
    )
    table = lookup_ops.StaticHashTable(init, default_value=-1)