return &Paragraph{
		pos,
		p.newText(pos, s),
	}
}

func newPara(p *parseState, s line) (line, bool) {
	// Process paragraph continuation text or start new paragraph.
	b := p.para()
	indented := p.lineDepth == len(p.stack)-2 // fully indented, not playing "pargraph continuation text" games
	text := s.trimSpaceString()

	if b != nil && b.table != nil {
		if indented && text != "" && text != "|" {
			// Continue table.

 */
package org.gradle.language.nativeplatform.internal.incremental.sourceparser;

import java.io.IOException;
import java.io.Reader;

/**
 * Replaces c-style comments with a single space, and removes line-continuation characters.
 * This code is largely adopted from org.apache.tools.ant.filters.StripJavaComments.
 */
public class PreprocessingReader {
    private final Reader reader;
    /**

import org.hamcrest.MatcherAssert.assertThat

import org.junit.Test

import java.io.File

import java.util.concurrent.ArrayBlockingQueue
import java.util.concurrent.TimeUnit

import kotlin.coroutines.Continuation


class KotlinBuildScriptModelRepositoryTest {

    @Test
    fun `cancels older requests before returning response to most recent request`() = runBlockingWithTimeout {

        // given:

// The encoding is:
// - unsigned integers are serialized 7 bits at a time, starting with the
//   least significant bits
// - the most significant bit (msb) in each output byte indicates if there
//   is a continuation byte (msb = 1)
// - signed integers are mapped to unsigned integers using "zig-zag"
//   encoding: Positive values x are written as 2*x + 0, negative values

 * <p>
 * Implementations must be multiple use and threadsafe.
 */
public interface DaemonCommandAction {

    /**
     * Executes this action.
     * <p>
     * The execution object is a kind of continuation and also carries the “result” of the action.
     * For example, if an exception arises as part of actioning the command, the exception should be

        }

        return upperBounds.firstOrNull() ?: builtIns.nullableAnyType
    }

    override fun continuationTypeConstructor(): TypeConstructorMarker {
        val continuationFqName = StandardClassIds.Continuation.asSingleFqName()
        val foundClasses = resolveSession.getTopLevelClassifierDescriptors(continuationFqName, NoLookupLocation.FROM_IDE)
        return foundClasses.firstOrNull()?.typeConstructor

import org.gradle.launcher.daemon.context.DaemonContext;
import org.gradle.launcher.daemon.protocol.Command;

import java.util.LinkedList;
import java.util.List;

/**
 * A continuation style object used to model the execution of a command.
 * <p>
 * Facilitates processing “chains”, making it easier to break up processing logic into discrete {@link org.gradle.launcher.daemon.server.api.DaemonCommandAction actions}.

// a server.
//
// [Pipeline], to manage pipelined requests and responses
// in a client.
//
// [Reader], to read numeric response code lines,
// key: value headers, lines wrapped with leading spaces
// on continuation lines, and whole text blocks ending
// with a dot on a line by itself.
//
// [Writer], to write dot-encoded text blocks.
//
// [Conn], a convenient packaging of [Reader], [Writer], and [Pipeline] for use

    assertThat(frameLog(true, 3, 10000, TYPE_HEADERS, 0x4))
      .isEqualTo("<< 0x00000003 10000 HEADERS       END_HEADERS")
    assertThat(frameLog(true, 3, 10000, TYPE_CONTINUATION, 0x4))
      .isEqualTo("<< 0x00000003 10000 CONTINUATION  END_HEADERS")
    assertThat(frameLog(true, 4, 10000, TYPE_PUSH_PROMISE, 0x4))
      .isEqualTo("<< 0x00000004 10000 PUSH_PROMISE  END_PUSH_PROMISE")
  }

  @Test
  fun flagOverlapOn0x20() {

		{
			name: "nonempty string",
			obj:  "hello world",
		},
		{
			name: "empty string",
			obj:  "",
		},
		{
			name: "string containing invalid UTF-8 sequence",
			obj:  "\x80", // first byte is a continuation byte
		},
		{
			name: "true",
			obj:  true,
		},
		{
			name: "false",
			obj:  false,
		},
		{
			name: "int64",
			obj:  int64(5),
		},
		{
			name: "int64 max",