suspend fun putTextWithDelay(view: TextView, text: String) { // suspend付き
    delay(1000)					  // Suspend関数（non-blocking動作を含む）
	view.text = text
}

suspend fun exeCountDown(view: TextView?) {                  // suspend付き
    view?.text = "3"
	putTextWithDelay(view, "2")	  // Suspend関数（non-blocking動作を含む）
	putTextWithDelay(view, "1")	  // Suspend関数（non-blocking動作を含む）
	putTextWithDelay(view, "0")	  // Suspend関数（non-blocking動作を含む）
}

public suspend fun delay(timeMillis: Long) {
    if (timeMillis <= 0) return // don`t delay
    return suspendCancellableCoroutine sc@ { cont: CancellableContinuation<Unit> ->
        cont.context.delay.scheduleResumeAfterDelay(timeMillis, cont)
    }
}

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
}

    suspend fun exeCountDown(view: TextView?) {
        view?.text = "3"
        delay(1000)		// suspend関数 ← 非同期処理、non-blocking動作
        view?.text = "2"
        delay(1000)		// suspend関数 ← 非同期処理、non-blocking動作
        view?.text = "1"
        delay(1000)		// suspend関数 ← 非同期処理、non-blocking動作
        view?.text = "0"
    }

    suspend fun task(): String {
        //  State:0
        println("TaskAの前処理")
        val _resultA = taskA()   // Suspend関数
        //  State:1
        println("TaskBの前処理")
        val _resultB = taskB()   // Suspend関数
        //  State:2
        println("TaskCの前処理")
        val _resultC = taskC()   // Suspend関数
        //  State:3
        println("結果の集計")
        val _result = _resultA + _resultB + _resultC
        //
        return "重い処理の結果　${_result}"
    }

public final Object task(Continuation<? super String> var1) {
   MainActivity$task$1 mainActivity$task$1;
   label37: {
      if (var1 instanceof MainActivity$task$1) {
         mainActivity$task$1 = (MainActivity$task$1)var1;
         if ((mainActivity$task$1.label & Integer.MIN_VALUE) != 0) {
            mainActivity$task$1.label -= Integer.MIN_VALUE;
            break label37;
         }
      }
      mainActivity$task$1 = new ContinuationImpl(var1);
   }
 
   Object var10000;
   String _resultA;
   String _resultB;
   String _resultC;
   label31: {
      Object var8;
      label30: {
         Object $result = mainActivity$task$1.result;
         var8 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
         switch(mainActivity$task$1.label) {
         case 0:
            ResultKt.throwOnFailure($result);
            _resultA = "TaskAの前処理";
            System.out.println(_resultA);
            mainActivity$task$1.L$0 = this;
            mainActivity$task$1.label = 1;
            var10000 = this.taskA((Continuation)mainActivity$task$1);
            if (var10000 == var8) {
               return var8;
            }
            break;
         case 1:
            this = (MainActivity)mainActivity$task$1.L$0;
            ResultKt.throwOnFailure($result);
            var10000 = $result;
            break;
         case 2:
            _resultA = (String)mainActivity$task$1.L$1;
            this = (MainActivity)mainActivity$task$1.L$0;
            ResultKt.throwOnFailure($result);
            var10000 = $result;
            break label30;
         case 3:
            _resultB = (String)mainActivity$task$1.L$1;
            _resultA = (String)mainActivity$task$1.L$0;
            ResultKt.throwOnFailure($result);
            var10000 = $result;
            break label31;
         default:
            throw new IllegalStateException(
                "call to 'resume' before 'invoke' with coroutine");
         }
 
         _resultA = (String)var10000;
         _resultB = "TaskBの前処理";
         System.out.println(_resultB);
         mainActivity$task$1.L$0 = this;
         mainActivity$task$1.L$1 = _resultA;
         mainActivity$task$1.label = 2;
         var10000 = this.taskB((Continuation)mainActivity$task$1);
         if (var10000 == var8) {
            return var8;
         }
      }
 
      _resultB = (String)var10000;
      _resultC = "TaskCの前処理";
      System.out.println(_resultC);
      mainActivity$task$1.L$0 = _resultA;
      mainActivity$task$1.L$1 = _resultB;
      mainActivity$task$1.label = 3;
      var10000 = this.taskC((Continuation)mainActivity$task$1);
      if (var10000 == var8) {
         return var8;
      }
   }
 
   _resultC = (String)var10000;
   String _result = "結果の集計";
   System.out.println(_result);
   _result = _resultA + _resultB + _resultC;
   return "重い処理の結果　" + _result;
}

public final class MainActivity$task$1 extends ContinuationImpl {
    Object L$0;    // _resultAを格納
    Object L$1;    // _resultBを格納
    int label;
    final /* synthetic */ MainActivity this$0;

    MainActivity$task$1(
	    MainActivity mainActivity, 
		Continuation<? super MainActivity$task$1> continuation
    ) {
        super(continuation);
        this.this$0 = mainActivity;
    }

    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
    public final Object invokeSuspend(Object obj) {
        this.result = obj;
        this.label |= Integer.MIN_VALUE; // このinvokeSuspendから呼ばれたことを示すフラグ
        return this.this$0.task(this);
    }
}

internal abstract class BaseContinuationImpl(
    public val completion: Continuation<Any?>? // 上位Suspend関数のステートを管理するクラス
) : Continuation<Any?>, CoroutineStackFrame, Serializable {

    public final override fun resumeWith(result: Result<Any?>) {
        var current = this           // 現Suspend関数のスレートを管理するクラス
        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) {
                    current = completion // 上位Suspend関数へ切り替え
                    param = outcome
                } else {
                    completion.resumeWith(outcome)
                    return
                }
            }
        }
    }

    protected abstract fun invokeSuspend(result: Result<Any?>): Any?
	...
}