suspend fun requestToken(): Token { ... }
suspend fun createPost(token: Token, item: Item): Post { ... }
fun processPost(post: Post) { ... }

suspend fun postItem(item: Item) {
  GlobalScope.launch {
    val token = requestToken()
    val post = createPost(token, item)
    processPost(post)
  }
}

@Nullable
public final Object requestToken(@NotNull Continuation $completion) {
  return Unit.INSTANCE;
}

/**
* Interface representing a continuation after a suspension point that returns a value of type `T`.
*/
@SinceKotlin("1.3")
public interface Continuation {
  /**
  * The context of the coroutine that corresponds to this continuation.
  */
  public val context: CoroutineContext

  /**
  * Resumes the execution of the corresponding coroutine passing a successful or failed [result] as the
  * return value of the last suspension point.
  */
  public fun resumeWith(result: Result)
}

GlobalScope.launch {
  val token = requestToken()
  val post = createPost(token)
  processPost(post)
}

Thread {

  val context = newSingleThreadContext("Test Thread")
  GlobalScope.launch (context) {
    println("Start first coroutine.")
    delay(200)
    println("Resume first coroutine after delay 200ms")
  }

  GlobalScope.launch (context){
    println("Start second coroutine.")
    delay(100)
    println("Resume second coroutine after delay 100ms")
  }

  Thread.sleep(500)
}.start()

Thread {
  GlobalScope.launch (Dispatchers.Main) {
    println("First coroutine runs in ${Thread.currentThread().name}")
    delay(100)
    println("First coroutine resumes and runs in ${Thread.currentThread().name}")
}

  GlobalScope.launch (Dispatchers.Unconfined){
    println("Second coroutine runs in ${Thread.currentThread().name}")
    delay(100)
    println("Second coroutine resumes and runs in ${Thread.currentThread().name}")
}

  Thread.sleep(500)
}.start()

public fun CoroutineScope.launch(
  context: CoroutineContext = EmptyCoroutineContext,
  start: CoroutineStart = CoroutineStart.DEFAULT,
  block: suspend CoroutineScope.() -> Unit
): Job {
  val newContext = newCoroutineContext(context)
  val coroutine = if (start.isLazy)
      LazyStandaloneCoroutine(newContext, block) 
    else
      StandaloneCoroutine(newContext, active = true)
  coroutine.start(start, coroutine, block)
  return coroutine
}

internal fun <R, T> (suspend (R) -> T).startCoroutineCancellable(
  receiver: R, 
  completion: Continuation
) = runSafely(completion) {
  createCoroutineUnintercepted(
    receiver, completion
  ).intercepted().resumeCancellable(Unit)
}

public actual fun (suspend () -> T).createCoroutineUnintercepted(
  completion: Continuation
): Continuation {
  val probeCompletion = probeCoroutineCreated(completion)
  return if (this is BaseContinuationImpl)
      create(probeCompletion)
    else
      createCoroutineFromSuspendFunction(probeCompletion) {
        (this as Function1<Continuation, Any?>).invoke(it)
      }
}

internal fun Continuation.resumeCancellable(value: T) = when (this) {
  is DispatchedContinuation -> resumeCancellable(value)
  else -> resume(value)
}

public inline fun Continuation.resume(value: T): Unit =
  resumeWith(Result.success(value))

internal abstract class BaseContinuationImpl(
  // This is `public val` so that it is private on JVM and cannot be modified by untrusted code, yet
  // it has a public getter (since even untrusted code is allowed to inspect its call stack).
  public val completion: Continuation?
) : Continuation, CoroutineStackFrame, Serializable {

// This implementation is final. This fact is used to unroll resumeWith recursion.
public final override fun resumeWith(result: Result) {
...

  try {
    val outcome = invokeSuspend(param)
    if (outcome === COROUTINE_SUSPENDED) return
    Result.success(outcome)
  } catch (exception: Throwable) {
    Result.failure(exception)
  }
...
}

protected abstract fun invokeSuspend(result: Result): Any?

...
}

resumeCancellable(value: T) -> resume(value) -> resumeWith(Result.success(value)) -> invokeSuspend(param)

internal abstract class ContinuationImpl(
  completion: Continuation<Any?>?,
  private val _context: CoroutineContext?
) : BaseContinuationImpl(completion) {
...

public fun intercepted(): Continuation<Any?> = intercepted ?: 
  (context[ContinuationInterceptor]?.interceptContinuation(this) ?: this)
  .also { intercepted = it }

...
}

public interface ContinuationInterceptor : CoroutineContext.Element {
...

public fun interceptContinuation(continuation: Continuation): Continuation
...
}

public abstract class CoroutineDispatcher :
  AbstractCoroutineContextElement(ContinuationInterceptor), 
  ContinuationInterceptor {
...
}

internal class DispatchedContinuation(
  @JvmField val dispatcher: CoroutineDispatcher,
  @JvmField val continuation: Continuation
) : DispatchedTask(MODE_ATOMIC_DEFAULT), 
    CoroutineStackFrame, 
    Continuation by continuation {

...

  override fun resumeWith(result: Result) {
    // check if need to dispatch
    if (dispatcher.isDispatchNeeded(context)) {
      ...

      // start dispatching
      dispatcher.dispatch(context, this)
    } else {
      // if not, execute the task as part of current event loop
      executeUnconfined(state, MODE_ATOMIC_DEFAULT) {
        withCoroutineContext(this.context, countOrElement) {
          continuation.resumeWith(result)
        }
      }
    }
  }

  @Suppress("NOTHING_TO_INLINE") // we need it inline to save us an entry on the stack
  inline fun resumeCancellable(value: T) {
    // check if need to dispatch
    if (dispatcher.isDispatchNeeded(context)) {
      ...

      // start dispatching
      dispatcher.dispatch(context, this)
    } else {
      // if not, execute the task as part of current event loop
      executeUnconfined(value, MODE_CANCELLABLE) {
        if (!resumeCancelled()) {
          resumeUndispatched(value)
        }
      }
    }
  }

  ...
}