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
}

    public static final Job launch(
	    CoroutineScope coroutineScope,
		CoroutineContext context, 
		CoroutineStart start, 
		Function2 function2					  // (1)タスクブロックを格納したクラス
	) {
        LazyStandaloneCoroutine coroutine;
        CoroutineContext newContext = 
		    CoroutineContextKt.newCoroutineContext(coroutineScope, context);
        if (start.isLazy()) {
            coroutine = new LazyStandaloneCoroutine(newContext, function2);
        } else {
            coroutine = new StandaloneCoroutine(newContext, true);
        }
        coroutine.start(start, coroutine, function2);	// (3)コルーチンを開始する
        return coroutine;		                // (2)コールバックを受け取るクラス
    }

        findViewById<Button>(R.id.btnStart).setOnClickListener {
            scope = SampleScope()
            scope?.launch {
                println("Start")
                Thread.sleep(2000)  // 重い処理の代わり
                println("End")
            }
        }

final class MainActivity$onCreate$1$1 
    extends SuspendLambda
	implements Function2<CoroutineScope, Continuation<? super Unit>, Object> 
{
    int label;

    public MainActivity$onCreate$1$1(
	    Continuation<? super MainActivity$onCreate$1$1> continuation
	) {
        super(2, continuation);
    }

    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
    public final Continuation<Unit> create(
	    Object obj, Continuation<?> continuation
	) {
        return new MainActivity$onCreate$1$1(continuation);
    }

    public final Object invoke(
	    CoroutineScope coroutineScope, 
		Continuation<? super Unit> continuation
	) {
        return ((MainActivity$onCreate$1$1) create(coroutineScope, continuation))
		    .invokeSuspend(Unit.INSTANCE);
    }

    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
    public final Object invokeSuspend(Object obj) {
        IntrinsicsKt.getCOROUTINE_SUSPENDED();
        switch (this.label) {
            case 0:
                ResultKt.throwOnFailure(obj);
                System.out.println((Object) "Start");
                Thread.sleep(2000);
                System.out.println((Object) "End");
                return Unit.INSTANCE;
            default:
                throw new IllegalStateException("...");
        }
		// ↑↑ タスクブロック（launchの引数に指定したラムダ式）を含む ↑↑
    }
}

public interface Function2<P1, P2, R> extends Function<R> {
    R invoke(P1 p1, P2 p2);
}

public abstract class AbstractCoroutine<in T>(
    ...
	public fun <R> start(start: CoroutineStart, receiver: R, block: suspend R.() -> T) {
        initParentJob()
        start(block, receiver, this) // CoroutineStart#invoke( )関数を実行
    }
	...
}

public enum class CoroutineStart {
    DEFAULT,
    LAZY,
    ATOMIC,
    UNDISPATCHED;

    ...
    public operator fun <R, T> invoke(
	    block: suspend R.() -> T, receiver: R, completion: Continuation<T>
	): Unit =
        when (this) {
            DEFAULT -> block.startCoroutineCancellable(receiver, completion)
            ATOMIC -> block.startCoroutine(receiver, completion)
            UNDISPATCHED -> block.startCoroutineUndispatched(receiver, completion)
            LAZY -> Unit // will start lazily
        }
    ...
}

...
internal fun <R, T> (suspend (R) -> T).startCoroutineCancellable(
    receiver: R, completion: Continuation<T>
) =
    runSafely(completion) {  // 最後の引数がラムダ式⇒( )の外へ出せる
        createCoroutineUnintercepted(receiver, completion)
		    .intercepted()
			.resumeCancellableWith(Result.success(Unit))
    }
...
private inline fun runSafely(completion: Continuation<*>, block: () -> Unit) {
    try {
        block()              // runSafelyは引数のラムダ式を実行する
    } catch (e: Throwable) {
        completion.resumeWith(Result.failure(e))
    }
}

        findViewById<Button>(R.id.btnStart).setOnClickListener {
            // launchの仕組み（入れ子）
            scope = SampleScope()
            scope?.launch(Dispatchers.Default) {            // Coroutine A
                // --- State:0 ---
                println("Start top ${getThread()}")
                val _job = launch(Dispatchers.Main) {       // Coroutine B
                    println("Start sub ${getThread()}")
                    Thread.sleep(2000)  // 重い処理の代わり
                    println("End sub")
                }
                _job.join()
                // --- State:1 ---
                println("End top")
            }
        }

internal abstract class BaseContinuationImpl(
    public val completion: Continuation<Any?>?
) : Continuation<Any?>, CoroutineStackFrame, Serializable {

    public final override fun resumeWith(result: Result<Any?>) {
        var current = this
        var param = result
        while (true) {
            probeCoroutineResumed(current)
            with(current) {
                val completion = completion!!
                val outcome: Result<Any?> =
                    try {
                        val outcome = invokeSuspend(param) // タスクブロック処理
                        if (outcome === COROUTINE_SUSPENDED) return  // 同一？
                        Result.success(outcome)
                    } catch (exception: Throwable) {
                        Result.failure(exception)
                    }
                releaseIntercepted()
                if (completion is BaseContinuationImpl) { // 上位のSuspend関数へ
                    current = completion
                    param = outcome
                } else {                                  // コールバックを発行
                    completion.resumeWith(outcome)
                    return
                }
            }
        }
    }
	
	protected abstract fun invokeSuspend(result: Result<Any?>): Any?
	// ↑↑ Coroutineクラスで実装されている ↑↑ //
    ...
}