Let's check the bytecode

```
[async] anf({\n  ();\n  {\n    var y: Int = 1;\n    val f: Int = y.+(2);\n    var z: Int = 0;\n    y match {\n      case 0 => {\n        va)
[async]   linearizing(())
[async]     anf(())
[async]     = List(())
[async]   = List(())
[async]   linearizing({\n  var y: Int = 1;\n  val f: Int = y.+(2);\n  var z: Int = 0;\n  y match {\n    case 0 => {\n      val x2: Int = scala.async.)
[async]     anf({\n  var y: Int = 1;\n  val f: Int = y.+(2);\n  var z: Int = 0;\n  y match {\n    case 0 => {\n      val x2: Int = scala.async.)
[async]       linearizing(var y: Int = 1)
[async]         anf(var y: Int = 1)
[async]         = List(var y: Int = 1)
[async]       = List(var y: Int = 1)
[async]       linearizing(val f: Int = y.+(2))
[async]         anf(val f: Int = y.+(2))
[async]         = List(val f: Int = y.+(2))
[async]       = List(val f: Int = y.+(2))
[async]       linearizing(var z: Int = 0)
[async]         anf(var z: Int = 0)
[async]         = List(var z: Int = 0)
[async]       = List(var z: Int = 0)
[async]       linearizing(y match {\n  case 0 => {\n    val x2: Int = scala.async.internal.AsyncId.await[Int](f);\n    z = x2.-(2)\n  }\n  case 1 => {\n )
[async]         anf(y match {\n  case 0 => {\n    val x2: Int = scala.async.internal.AsyncId.await[Int](f);\n    z = x2.-(2)\n  }\n  case 1 => {\n )
[async]           linearizing(y)
[async]             anf(y)
[async]             = List(y)
[async]           = List(y)
[async]           linearizing({\n  val x2: Int = scala.async.internal.AsyncId.await[Int](f);\n  z = x2.-(2)\n})
[async]             anf({\n  val x2: Int = scala.async.internal.AsyncId.await[Int](f);\n  z = x2.-(2)\n})
[async]               linearizing(val x2: Int = scala.async.internal.AsyncId.await[Int](f))
[async]                 anf(val x2: Int = scala.async.internal.AsyncId.await[Int](f))
[async]                   linearizing(scala.async.internal.AsyncId.await[Int](f))
[async]                     anf(scala.async.internal.AsyncId.await[Int](f))
[async]                       linearizing(scala.async.internal.AsyncId.await)
[async]                         anf(scala.async.internal.AsyncId.await)
[async]                           linearizing(scala.async.internal.AsyncId)
[async]                             anf(scala.async.internal.AsyncId)
[async]                             = List(scala.async.internal.AsyncId)
[async]                           = List(scala.async.internal.AsyncId)
[async]                         = List(scala.async.internal.AsyncId.await)
[async]                       = List(scala.async.internal.AsyncId.await)
[async]                       linearizing(f)
[async]                         anf(f)
[async]                         = List(f)
[async]                       = List(f)
[async]                     = List(<synthetic> val awaitable$macro$2: Int = f, scala.async.internal.AsyncId.await[Int](awaitable$macro$2))
[async]                   = List(<synthetic> val awaitable$macro$2: Int = f, <synthetic> val await$macro$3: Int = scala.async.internal.AsyncId.await[Int](a
[async]                 = List(<synthetic> val awaitable$macro$2: Int = f, <synthetic> val await$macro$3: Int = scala.async.internal.AsyncId.await[Int](a
[async]               = List(<synthetic> val awaitable$macro$2: Int = f, <synthetic> val await$macro$3: Int = scala.async.internal.AsyncId.await[Int](a
[async]               linearizing(z = x2.-(2))
[async]                 anf(z = x2.-(2))
[async]                 = List(z = x2.-(2))
[async]               = List(z = x2.-(2))
[async]             = List(<synthetic> val awaitable$macro$2: Int = f, <synthetic> val await$macro$3: Int = scala.async.internal.AsyncId.await[Int](a
[async]           = List(<synthetic> val awaitable$macro$2: Int = f, <synthetic> val await$macro$3: Int = scala.async.internal.AsyncId.await[Int](a
[async]           linearizing({\n  val x1: Int = scala.async.internal.AsyncId.await[Int](f);\n  z = x1.+(2)\n})
[async]             anf({\n  val x1: Int = scala.async.internal.AsyncId.await[Int](f);\n  z = x1.+(2)\n})
[async]               linearizing(val x1: Int = scala.async.internal.AsyncId.await[Int](f))
[async]                 anf(val x1: Int = scala.async.internal.AsyncId.await[Int](f))
[async]                   linearizing(scala.async.internal.AsyncId.await[Int](f))
[async]                     anf(scala.async.internal.AsyncId.await[Int](f))
[async]                       linearizing(scala.async.internal.AsyncId.await)
[async]                         anf(scala.async.internal.AsyncId.await)
[async]                           linearizing(scala.async.internal.AsyncId)
[async]                             anf(scala.async.internal.AsyncId)
[async]                             = List(scala.async.internal.AsyncId)
[async]                           = List(scala.async.internal.AsyncId)
[async]                         = List(scala.async.internal.AsyncId.await)
[async]                       = List(scala.async.internal.AsyncId.await)
[async]                       linearizing(f)
[async]                         anf(f)
[async]                         = List(f)
[async]                       = List(f)
[async]                     = List(<synthetic> val awaitable$macro$4: Int = f, scala.async.internal.AsyncId.await[Int](awaitable$macro$4))
[async]                   = List(<synthetic> val awaitable$macro$4: Int = f, <synthetic> val await$macro$5: Int = scala.async.internal.AsyncId.await[Int](a
[async]                 = List(<synthetic> val awaitable$macro$4: Int = f, <synthetic> val await$macro$5: Int = scala.async.internal.AsyncId.await[Int](a
[async]               = List(<synthetic> val awaitable$macro$4: Int = f, <synthetic> val await$macro$5: Int = scala.async.internal.AsyncId.await[Int](a
[async]               linearizing(z = x1.+(2))
[async]                 anf(z = x1.+(2))
[async]                 = List(z = x1.+(2))
[async]               = List(z = x1.+(2))
[async]             = List(<synthetic> val awaitable$macro$4: Int = f, <synthetic> val await$macro$5: Int = scala.async.internal.AsyncId.await[Int](a
[async]           = List(<synthetic> val awaitable$macro$4: Int = f, <synthetic> val await$macro$5: Int = scala.async.internal.AsyncId.await[Int](a
[async]         = List(y match {\n  case 0 => {\n    <synthetic> val awaitable$macro$2: Int = f;\n    <synthetic> val await$macro$3: Int = scala.
[async]       = List(y match {\n  case 0 => {\n    <synthetic> val awaitable$macro$2: Int = f;\n    <synthetic> val await$macro$3: Int = scala.
[async]       linearizing(z)
[async]         anf(z)
[async]         = List(z)
[async]       = List(z)
[async]       linearizing(var xxx: Int = 0)
[async]         anf(var xxx: Int = 0)
[async]         = List(var xxx: Int = 0)
[async]       = List(var xxx: Int = 0)
[async]       linearizing(while$1(){\n  if (xxx.<(3))\n    {\n      {\n        y = scala.async.internal.AsyncId.await[Int](xxx);\n        xxx = xxx.+(1)\)
[async]         anf(while$1(){\n  if (xxx.<(3))\n    {\n      {\n        y = scala.async.internal.AsyncId.await[Int](xxx);\n        xxx = xxx.+(1)\)
[async]           linearizing(if (xxx.<(3))\n  {\n    {\n      y = scala.async.internal.AsyncId.await[Int](xxx);\n      xxx = xxx.+(1)\n    };\n    while$1())
[async]             anf(if (xxx.<(3))\n  {\n    {\n      y = scala.async.internal.AsyncId.await[Int](xxx);\n      xxx = xxx.+(1)\n    };\n    while$1())
[async]               linearizing(xxx.<(3))
[async]                 anf(xxx.<(3))
[async]                 = List(xxx.<(3))
[async]               = List(xxx.<(3))
[async]               linearizing({\n  {\n    y = scala.async.internal.AsyncId.await[Int](xxx);\n    xxx = xxx.+(1)\n  };\n  while$1()\n})
[async]                 anf({\n  {\n    y = scala.async.internal.AsyncId.await[Int](xxx);\n    xxx = xxx.+(1)\n  };\n  while$1()\n})
[async]                   linearizing({\n  y = scala.async.internal.AsyncId.await[Int](xxx);\n  xxx = xxx.+(1)\n})
[async]                     anf({\n  y = scala.async.internal.AsyncId.await[Int](xxx);\n  xxx = xxx.+(1)\n})
[async]                       linearizing(y = scala.async.internal.AsyncId.await[Int](xxx))
[async]                         anf(y = scala.async.internal.AsyncId.await[Int](xxx))
[async]                           linearizing(scala.async.internal.AsyncId.await[Int](xxx))
[async]                             anf(scala.async.internal.AsyncId.await[Int](xxx))
[async]                               linearizing(scala.async.internal.AsyncId.await)
[async]                                 anf(scala.async.internal.AsyncId.await)
[async]                                   linearizing(scala.async.internal.AsyncId)
[async]                                     anf(scala.async.internal.AsyncId)
[async]                                     = List(scala.async.internal.AsyncId)
[async]                                   = List(scala.async.internal.AsyncId)
[async]                                 = List(scala.async.internal.AsyncId.await)
[async]                               = List(scala.async.internal.AsyncId.await)
[async]                               linearizing(xxx)
[async]                                 anf(xxx)
[async]                                 = List(xxx)
[async]                               = List(xxx)
[async]                             = List(<synthetic> val awaitable$macro$6: Int = xxx, scala.async.internal.AsyncId.await[Int](awaitable$macro$6))
[async]                           = List(<synthetic> val awaitable$macro$6: Int = xxx, <synthetic> val await$macro$7: Int = scala.async.internal.AsyncId.await[Int]
[async]                         = List(<synthetic> val awaitable$macro$6: Int = xxx, <synthetic> val await$macro$7: Int = scala.async.internal.AsyncId.await[Int]
[async]                       = List(<synthetic> val awaitable$macro$6: Int = xxx, <synthetic> val await$macro$7: Int = scala.async.internal.AsyncId.await[Int]
[async]                       linearizing(xxx = xxx.+(1))
[async]                         anf(xxx = xxx.+(1))
[async]                         = List(xxx = xxx.+(1))
[async]                       = List(xxx = xxx.+(1))
[async]                     = List(<synthetic> val awaitable$macro$6: Int = xxx, <synthetic> val await$macro$7: Int = scala.async.internal.AsyncId.await[Int]
[async]                   = List(<synthetic> val awaitable$macro$6: Int = xxx, <synthetic> val await$macro$7: Int = scala.async.internal.AsyncId.await[Int]
[async]                   linearizing(while$1())
[async]                     anf(while$1())
[async]                     = List(while$1())
[async]                   = List(while$1())
[async]                 = List(<synthetic> val awaitable$macro$6: Int = xxx, <synthetic> val await$macro$7: Int = scala.async.internal.AsyncId.await[Int]
[async]               = List(<synthetic> val awaitable$macro$6: Int = xxx, <synthetic> val await$macro$7: Int = scala.async.internal.AsyncId.await[Int]
[async]               linearizing(())
[async]                 anf(())
[async]                 = List(())
[async]               = List(())
[async]             = List(if (xxx.<(3))\n  {\n    <synthetic> val awaitable$macro$6: Int = xxx;\n    <synthetic> val await$macro$7: Int = scala.asyn
[async]           = List(if (xxx.<(3))\n  {\n    <synthetic> val awaitable$macro$6: Int = xxx;\n    <synthetic> val await$macro$7: Int = scala.asyn
[async]         = List(while$1(){\n  if (xxx.<(3))\n    {\n      <synthetic> val awaitable$macro$6: Int = xxx;\n      <synthetic> val await$macro
[async]       = List(while$1(){\n  if (xxx.<(3))\n    {\n      <synthetic> val awaitable$macro$6: Int = xxx;\n      <synthetic> val await$macro
[async]       linearizing(y)
[async]         anf(y)
[async]         = List(y)
[async]       = List(y)
[async]     = List(var y: Int = 1, val f: Int = y.+(2), var z: Int = 0, y match {\n  case 0 => {\n    <synthetic> val awaitable$macro$2: Int
[async]   = List(var y: Int = 1, val f: Int = y.+(2), var z: Int = 0, y match {\n  case 0 => {\n    <synthetic> val awaitable$macro$2: Int
[async] = List(var y: Int = 1, val f: Int = y.+(2), var z: Int = 0, y match {\n  case 0 => {\n    <synthetic> val awaitable$macro$2: Int
[async] In file '<console>':
[async] scala.async.internal.AsyncId.async[Int]({
  var y: Int = 1;
  val f: Int = y.+(2);
  var z: Int = 0;
  y match {
    case 0 => {
      val x2: Int = scala.async.internal.AsyncId.await[Int](f);
      z = x2.-(2)
    }
    case 1 => {
      val x1: Int = scala.async.internal.AsyncId.await[Int](f);
      z = x1.+(2)
    }
  };
  z;
  var xxx: Int = 0;
  while$1(){
    if (xxx.<(3))
      {
        {
          y = scala.async.internal.AsyncId.await[Int](xxx);
          xxx = xxx.+(1)
        };
        while$1()
      }
    else
      ()
  };
  y
})
[async] ANF transform expands to:
 {
  var y: Int = 1;
  val f: Int = y.+(2);
  var z: Int = 0;
  y match {
    case 0 => {
      <synthetic> val awaitable$macro$2: Int = f;
      <synthetic> val await$macro$3: Int = scala.async.internal.AsyncId.await[Int](awaitable$macro$2);
      val x2: Int = await$macro$3;
      z = x2.-(2)
    }
    case 1 => {
      <synthetic> val awaitable$macro$4: Int = f;
      <synthetic> val await$macro$5: Int = scala.async.internal.AsyncId.await[Int](awaitable$macro$4);
      val x1: Int = await$macro$5;
      z = x1.+(2)
    }
  };
  z;
  var xxx: Int = 0;
  while$1(){
    if (xxx.<(3))
      {
        <synthetic> val awaitable$macro$6: Int = xxx;
        <synthetic> val await$macro$7: Int = scala.async.internal.AsyncId.await[Int](awaitable$macro$6);
        y = await$macro$7;
        xxx = xxx.+(1);
        while$1()
      }
    else
      {
        ()
      };
    ()
  };
  y
}
[async] AsyncStateWithoutAwait #0, nextStates = List(1, 2)
[async] AsyncStateWithAwait #1, next = 5
[async] AsyncState #5, next = 3
[async] AsyncStateWithAwait #2, next = 7
[async] AsyncState #7, next = 3
[async] AsyncStateWithoutAwait #3, nextStates = List(-8329)
[async] AsyncStateWithoutAwait #-8329, nextStates = List(9, 10)
[async] AsyncStateWithAwait #9, next = 13
[async] AsyncState #13, next = -8329
[async] AsyncState #10, next = 11
[async] AsyncState #11, next = 8
[async] AsyncState #8, next = 2147483647
[async] fields never zero-ed out: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] fields used in state #0: used: variable y$macro$11
captured:
[async] fields used in state #1: used: variable f$macro$8
captured:
[async] fields used in state #5: used: variable await$macro$3$macro$9,variable z$macro$14
captured:
[async] fields used in state #2: used: variable f$macro$8
captured:
[async] fields used in state #7: used: variable await$macro$5$macro$13,variable z$macro$14
captured:
[async] fields used in state #3: used: variable z$macro$14
captured:
[async] fields used in state #-8329: used: variable xxx$macro$10
captured:
[async] fields used in state #9: used: variable xxx$macro$10
captured:
[async] fields used in state #13: used: variable y$macro$11,variable await$macro$7$macro$12,variable xxx$macro$10
captured:
[async] fields used in state #10: used:
captured:
[async] fields used in state #11: used:
captured:
[async] fields used in state #8: used: variable y$macro$11
captured:
[async] LVentry at state #0: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVexit  at state #0: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVentry at state #1: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVexit  at state #1: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVentry at state #5: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVexit  at state #5: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVentry at state #2: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVexit  at state #2: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVentry at state #7: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVexit  at state #7: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVentry at state #3: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVexit  at state #3: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVentry at state #-8329: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVexit  at state #-8329: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVentry at state #9: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVexit  at state #9: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVentry at state #13: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVexit  at state #13: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVentry at state #10: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVexit  at state #10: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVentry at state #11: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVexit  at state #11: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVentry at state #8: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] LVexit  at state #8: variable xxx$macro$10, variable await$macro$5$macro$13, variable await$macro$3$macro$9, variable await$macro$7$macro$12, variable f$macro$8, variable z$macro$14, variable y$macro$11
[async] field xxx$macro$10 is last used in states 8
[async] field y$macro$11 is last used in states 8
[async] field await$macro$3$macro$9 is last used in states 8
[async] field f$macro$8 is last used in states 8
[async] field await$macro$5$macro$13 is last used in states 8
[async] field await$macro$7$macro$12 is last used in states 8
[async] field z$macro$14 is last used in states 8
[async] field xxx$macro$10 should be nulled out in states
[async] field y$macro$11 should be nulled out in states
[async] field await$macro$3$macro$9 should be nulled out in states
[async] field f$macro$8 should be nulled out in states
[async] field await$macro$5$macro$13 should be nulled out in states
[async] field await$macro$7$macro$12 should be nulled out in states
[async] field z$macro$14 should be nulled out in states
[async] 2 dead states eliminated
[async] async state machine transform expands to:
 {
  class stateMachine$macro$1 extends AnyRef with scala.util.Try[Any] => Unit with () => Unit {
    <stable> private[this] var f$macro$8: Int = _;
    <synthetic> <stable> private[this] var await$macro$3$macro$9: Int = _;
    <stable> private[this] var xxx$macro$10: Int = _;
    <stable> private[this] var y$macro$11: Int = _;
    <synthetic> <stable> private[this] var await$macro$7$macro$12: Int = _;
    <synthetic> <stable> private[this] var await$macro$5$macro$13: Int = _;
    <stable> private[this] var z$macro$14: Int = _;
    def <init>(): stateMachine$macro$1 = {
      stateMachine$macro$1.super.<init>();
      ()
    };
    private[this] var state: Int = 0;
    private[this] val result: scala.async.internal.Box[Int] = new scala.async.internal.Box[Int]();
    <stable> <accessor> def result: scala.async.internal.Box[Int] = stateMachine$macro$1.this.result;
    private[this] val execContext: Unit = ();
    <stable> <accessor> def execContext: Unit = stateMachine$macro$1.this.execContext;
    def apply(tr: scala.util.Try[Any]): Unit = while$macro$15(){
      try {
        stateMachine$macro$1.this.state match {
          case 0 => {
            stateMachine$macro$1.this.y$macro$11 = 1;
            stateMachine$macro$1.this.f$macro$8 = stateMachine$macro$1.this.y$macro$11.+(2);
            stateMachine$macro$1.this.z$macro$14 = 0;
            stateMachine$macro$1.this.y$macro$11 match {
              case 0 => {
                stateMachine$macro$1.this.state = 1
              }
              case 1 => {
                stateMachine$macro$1.this.state = 3
              }
            };
            ()
          }
          case 1 => {
            <synthetic> val awaitable$macro$2: Int = stateMachine$macro$1.this.f$macro$8;
            stateMachine$macro$1.this.state = 10;
            this.apply(Success.apply[Int](awaitable$macro$2));
            return ()
          }
          case 2 => {
            stateMachine$macro$1.this.state = 5;
            val x2: Int = stateMachine$macro$1.this.await$macro$3$macro$9;
            stateMachine$macro$1.this.z$macro$14 = x2.-(2)
          }
          case 3 => {
            <synthetic> val awaitable$macro$4: Int = stateMachine$macro$1.this.f$macro$8;
            stateMachine$macro$1.this.state = 11;
            this.apply(Success.apply[Int](awaitable$macro$4));
            return ()
          }
          case 4 => {
            stateMachine$macro$1.this.state = 5;
            val x1: Int = stateMachine$macro$1.this.await$macro$5$macro$13;
            stateMachine$macro$1.this.z$macro$14 = x1.+(2)
          }
          case 5 => {
            stateMachine$macro$1.this.z$macro$14;
            stateMachine$macro$1.this.xxx$macro$10 = 0;
            stateMachine$macro$1.this.state = 6;
            ()
          }
          case 6 => {
            if (stateMachine$macro$1.this.xxx$macro$10.<(3))
              stateMachine$macro$1.this.state = 7
            else
              stateMachine$macro$1.this.state = 9;
            ()
          }
          case 7 => {
            <synthetic> val awaitable$macro$6: Int = stateMachine$macro$1.this.xxx$macro$10;
            stateMachine$macro$1.this.state = 12;
            this.apply(Success.apply[Int](awaitable$macro$6));
            return ()
          }
          case 8 => {
            stateMachine$macro$1.this.state = 6;
            stateMachine$macro$1.this.y$macro$11 = stateMachine$macro$1.this.await$macro$7$macro$12;
            stateMachine$macro$1.this.xxx$macro$10 = stateMachine$macro$1.this.xxx$macro$10.+(1)
          }
          case 9 => {
            {
              stateMachine$macro$1.this.result.a_=(Success.apply[Int](stateMachine$macro$1.this.y$macro$11).get);
              ()
            };
            return ()
          }
          case 10 => {
            if (tr.isFailure)
              {
                stateMachine$macro$1.this.result.a_=(tr.asInstanceOf[scala.util.Try[Int]].get);
                return ()
              }
            else
              {
                stateMachine$macro$1.this.await$macro$3$macro$9 = tr.get.asInstanceOf[Int];
                stateMachine$macro$1.this.state = 2
              };
            ()
          }
          case 11 => {
            if (tr.isFailure)
              {
                stateMachine$macro$1.this.result.a_=(tr.asInstanceOf[scala.util.Try[Int]].get);
                return ()
              }
            else
              {
                stateMachine$macro$1.this.await$macro$5$macro$13 = tr.get.asInstanceOf[Int];
                stateMachine$macro$1.this.state = 4
              };
            ()
          }
          case 12 => {
            if (tr.isFailure)
              {
                stateMachine$macro$1.this.result.a_=(tr.asInstanceOf[scala.util.Try[Int]].get);
                return ()
              }
            else
              {
                stateMachine$macro$1.this.await$macro$7$macro$12 = tr.get.asInstanceOf[Int];
                stateMachine$macro$1.this.state = 8
              };
            ()
          }
          case _ => throw new IllegalStateException()
        }
      } catch {
        case (throwable @ (_: Throwable)) => {
          stateMachine$macro$1.this.result.a_=(Failure.apply[Int](throwable).get);
          return ()
        }
      };
      while$macro$15()
    };
    def apply: Unit = stateMachine$macro$1.this.apply(null)
  };
  val stateMachine$macro$1 = new stateMachine$macro$1();
  stateMachine$macro$1.apply();
  stateMachine$macro$1.result.a
}
package <empty> {
  class Test extends Object {
    def test(): Int = {
      val stateMachine$macro$1: Test$stateMachine$macro$1$1 = new Test$stateMachine$macro$1$1(null);
      stateMachine$macro$1.apply$mcV$sp();
      scala.Int.unbox(stateMachine$macro$1.result().a())
    };
    def <init>(): Test = {
      Test.super.<init>();
      scala.Predef.println(scala.Int.box(Test.this.test()));
      ()
    }
  };
  class Test$stateMachine$macro$1$1 extends Object with Function1 with Function0$mcV$sp {
    <specialized> def apply$mcZ$sp(): Boolean = Test$stateMachine$macro$1$1.super.apply$mcZ$sp();
    <specialized> def apply$mcB$sp(): Byte = Test$stateMachine$macro$1$1.super.apply$mcB$sp();
    <specialized> def apply$mcC$sp(): Char = Test$stateMachine$macro$1$1.super.apply$mcC$sp();
    <specialized> def apply$mcD$sp(): Double = Test$stateMachine$macro$1$1.super.apply$mcD$sp();
    <specialized> def apply$mcF$sp(): Float = Test$stateMachine$macro$1$1.super.apply$mcF$sp();
    <specialized> def apply$mcI$sp(): Int = Test$stateMachine$macro$1$1.super.apply$mcI$sp();
    <specialized> def apply$mcJ$sp(): Long = Test$stateMachine$macro$1$1.super.apply$mcJ$sp();
    <specialized> def apply$mcS$sp(): Short = Test$stateMachine$macro$1$1.super.apply$mcS$sp();
    override def toString(): String = Test$stateMachine$macro$1$1.super.toString();
    <specialized> def apply$mcZD$sp(v1: Double): Boolean = Test$stateMachine$macro$1$1.super.apply$mcZD$sp(v1);
    <specialized> def apply$mcDD$sp(v1: Double): Double = Test$stateMachine$macro$1$1.super.apply$mcDD$sp(v1);
    <specialized> def apply$mcFD$sp(v1: Double): Float = Test$stateMachine$macro$1$1.super.apply$mcFD$sp(v1);
    <specialized> def apply$mcID$sp(v1: Double): Int = Test$stateMachine$macro$1$1.super.apply$mcID$sp(v1);
    <specialized> def apply$mcJD$sp(v1: Double): Long = Test$stateMachine$macro$1$1.super.apply$mcJD$sp(v1);
    <specialized> def apply$mcVD$sp(v1: Double): Unit = Test$stateMachine$macro$1$1.super.apply$mcVD$sp(v1);
    <specialized> def apply$mcZF$sp(v1: Float): Boolean = Test$stateMachine$macro$1$1.super.apply$mcZF$sp(v1);
    <specialized> def apply$mcDF$sp(v1: Float): Double = Test$stateMachine$macro$1$1.super.apply$mcDF$sp(v1);
    <specialized> def apply$mcFF$sp(v1: Float): Float = Test$stateMachine$macro$1$1.super.apply$mcFF$sp(v1);
    <specialized> def apply$mcIF$sp(v1: Float): Int = Test$stateMachine$macro$1$1.super.apply$mcIF$sp(v1);
    <specialized> def apply$mcJF$sp(v1: Float): Long = Test$stateMachine$macro$1$1.super.apply$mcJF$sp(v1);
    <specialized> def apply$mcVF$sp(v1: Float): Unit = Test$stateMachine$macro$1$1.super.apply$mcVF$sp(v1);
    <specialized> def apply$mcZI$sp(v1: Int): Boolean = Test$stateMachine$macro$1$1.super.apply$mcZI$sp(v1);
    <specialized> def apply$mcDI$sp(v1: Int): Double = Test$stateMachine$macro$1$1.super.apply$mcDI$sp(v1);
    <specialized> def apply$mcFI$sp(v1: Int): Float = Test$stateMachine$macro$1$1.super.apply$mcFI$sp(v1);
    <specialized> def apply$mcII$sp(v1: Int): Int = Test$stateMachine$macro$1$1.super.apply$mcII$sp(v1);
    <specialized> def apply$mcJI$sp(v1: Int): Long = Test$stateMachine$macro$1$1.super.apply$mcJI$sp(v1);
    <specialized> def apply$mcVI$sp(v1: Int): Unit = Test$stateMachine$macro$1$1.super.apply$mcVI$sp(v1);
    <specialized> def apply$mcZJ$sp(v1: Long): Boolean = Test$stateMachine$macro$1$1.super.apply$mcZJ$sp(v1);
    <specialized> def apply$mcDJ$sp(v1: Long): Double = Test$stateMachine$macro$1$1.super.apply$mcDJ$sp(v1);
    <specialized> def apply$mcFJ$sp(v1: Long): Float = Test$stateMachine$macro$1$1.super.apply$mcFJ$sp(v1);
    <specialized> def apply$mcIJ$sp(v1: Long): Int = Test$stateMachine$macro$1$1.super.apply$mcIJ$sp(v1);
    <specialized> def apply$mcJJ$sp(v1: Long): Long = Test$stateMachine$macro$1$1.super.apply$mcJJ$sp(v1);
    <specialized> def apply$mcVJ$sp(v1: Long): Unit = Test$stateMachine$macro$1$1.super.apply$mcVJ$sp(v1);
    @scala.annotation.unspecialized def compose(g: Function1): Function1 = Test$stateMachine$macro$1$1.super.compose(g);
    @scala.annotation.unspecialized def andThen(g: Function1): Function1 = Test$stateMachine$macro$1$1.super.andThen(g);
    <stable> private[this] var f$macro$8: Int = _;
    <synthetic> <stable> private[this] var await$macro$3$macro$9: Int = _;
    <stable> private[this] var xxx$macro$10: Int = _;
    <stable> private[this] var y$macro$11: Int = _;
    <synthetic> <stable> private[this] var await$macro$7$macro$12: Int = _;
    <synthetic> <stable> private[this] var await$macro$5$macro$13: Int = _;
    <stable> private[this] var z$macro$14: Int = _;
    private[this] var state: Int = _;
    private[this] val result: scala.async.internal.Box = _;
    <stable> <accessor> def result(): scala.async.internal.Box = Test$stateMachine$macro$1$1.this.result;
    private[this] val execContext: scala.runtime.BoxedUnit = _;
    <stable> <accessor> def execContext(): Unit = ();
    def apply(tr: scala.util.Try): Unit = while$macro$15(){
      try {
        case <synthetic> val x1: Int = Test$stateMachine$macro$1$1.this.state;
        (x1: Int) match {
          case 0 => {
            Test$stateMachine$macro$1$1.this.y$macro$11 = 1;
            Test$stateMachine$macro$1$1.this.f$macro$8 = Test$stateMachine$macro$1$1.this.y$macro$11.+(2);
            Test$stateMachine$macro$1$1.this.z$macro$14 = 0;
            {
              case <synthetic> val x1: Int = Test$stateMachine$macro$1$1.this.y$macro$11;
              (x1: Int) match {
                case 0 => {
                  Test$stateMachine$macro$1$1.this.state = 1
                }
                case 1 => {
                  Test$stateMachine$macro$1$1.this.state = 3
                }
                case _ => throw new MatchError(scala.Int.box(x1))
              }
            };
            ()
          }
          case 1 => {
            <synthetic> val awaitable$macro$2: Int = Test$stateMachine$macro$1$1.this.f$macro$8;
            Test$stateMachine$macro$1$1.this.state = 10;
            this.apply(new scala.util.Success(scala.Int.box(awaitable$macro$2)));
            return ()
          }
          case 2 => {
            Test$stateMachine$macro$1$1.this.state = 5;
            val x2: Int = Test$stateMachine$macro$1$1.this.await$macro$3$macro$9;
            Test$stateMachine$macro$1$1.this.z$macro$14 = x2.-(2)
          }
          case 3 => {
            <synthetic> val awaitable$macro$4: Int = Test$stateMachine$macro$1$1.this.f$macro$8;
            Test$stateMachine$macro$1$1.this.state = 11;
            this.apply(new scala.util.Success(scala.Int.box(awaitable$macro$4)));
            return ()
          }
          case 4 => {
            Test$stateMachine$macro$1$1.this.state = 5;
            val x1: Int = Test$stateMachine$macro$1$1.this.await$macro$5$macro$13;
            Test$stateMachine$macro$1$1.this.z$macro$14 = x1.+(2)
          }
          case 5 => {
            Test$stateMachine$macro$1$1.this.z$macro$14;
            Test$stateMachine$macro$1$1.this.xxx$macro$10 = 0;
            Test$stateMachine$macro$1$1.this.state = 6;
            ()
          }
          case 6 => {
            if (Test$stateMachine$macro$1$1.this.xxx$macro$10.<(3))
              Test$stateMachine$macro$1$1.this.state = 7
            else
              Test$stateMachine$macro$1$1.this.state = 9;
            ()
          }
          case 7 => {
            <synthetic> val awaitable$macro$6: Int = Test$stateMachine$macro$1$1.this.xxx$macro$10;
            Test$stateMachine$macro$1$1.this.state = 12;
            this.apply(new scala.util.Success(scala.Int.box(awaitable$macro$6)));
            return ()
          }
          case 8 => {
            Test$stateMachine$macro$1$1.this.state = 6;
            Test$stateMachine$macro$1$1.this.y$macro$11 = Test$stateMachine$macro$1$1.this.await$macro$7$macro$12;
            Test$stateMachine$macro$1$1.this.xxx$macro$10 = Test$stateMachine$macro$1$1.this.xxx$macro$10.+(1)
          }
          case 9 => {
            {
              Test$stateMachine$macro$1$1.this.result().a_=(new scala.util.Success(scala.Int.box(Test$stateMachine$macro$1$1.this.y$macro$11)).get());
              ()
            };
            return ()
          }
          case 10 => {
            if (tr.isFailure())
              {
                Test$stateMachine$macro$1$1.this.result().a_=(tr.get());
                return ()
              }
            else
              {
                Test$stateMachine$macro$1$1.this.await$macro$3$macro$9 = scala.Int.unbox(tr.get());
                Test$stateMachine$macro$1$1.this.state = 2
              };
            ()
          }
          case 11 => {
            if (tr.isFailure())
              {
                Test$stateMachine$macro$1$1.this.result().a_=(tr.get());
                return ()
              }
            else
              {
                Test$stateMachine$macro$1$1.this.await$macro$5$macro$13 = scala.Int.unbox(tr.get());
                Test$stateMachine$macro$1$1.this.state = 4
              };
            ()
          }
          case 12 => {
            if (tr.isFailure())
              {
                Test$stateMachine$macro$1$1.this.result().a_=(tr.get());
                return ()
              }
            else
              {
                Test$stateMachine$macro$1$1.this.await$macro$7$macro$12 = scala.Int.unbox(tr.get());
                Test$stateMachine$macro$1$1.this.state = 8
              };
            ()
          }
          case _ => throw new IllegalStateException()
        }
      } catch {
        case (throwable @ (_: Throwable)) => {
          Test$stateMachine$macro$1$1.this.result().a_=(new scala.util.Failure(throwable).get());
          return ()
        }
      };
      while$macro$15()
    };
    def apply(): Unit = Test$stateMachine$macro$1$1.this.apply$mcV$sp();
    <specialized> def apply$mcV$sp(): Unit = Test$stateMachine$macro$1$1.this.apply(null);
    <bridge> <artifact> def apply(): Object = {
      Test$stateMachine$macro$1$1.this.apply();
      scala.runtime.BoxedUnit.UNIT
    };
    <bridge> <artifact> def apply(v1: Object): Object = {
      Test$stateMachine$macro$1$1.this.apply(v1.$asInstanceOf[scala.util.Try]());
      scala.runtime.BoxedUnit.UNIT
    };
    def <init>($outer: Test): Test$stateMachine$macro$1$1 = {
      Test$stateMachine$macro$1$1.super.<init>();
      Test$stateMachine$macro$1$1.super./*Function1*/$init$();
      Test$stateMachine$macro$1$1.super./*Function0*/$init$();
      Test$stateMachine$macro$1$1.this.state = 0;
      Test$stateMachine$macro$1$1.this.result = new scala.async.internal.Box();
      Test$stateMachine$macro$1$1.this.execContext = scala.runtime.BoxedUnit.UNIT;
      ()
    }
  }
}
Bytecode for class Test$stateMachine$macro$1$1
// class version 52.0 (52)
// access flags 0x21
// signature Ljava/lang/Object;Lscala/Function1<Lscala/util/Try<Ljava/lang/Object;>;Lscala/runtime/BoxedUnit;>;Lscala/Function0$mcV$sp;
// declaration: Test$stateMachine$macro$1$1 implements scala.Function1<scala.util.Try<java.lang.Object>, scala.runtime.BoxedUnit>, scala.Function0$mcV$sp
public class Test$stateMachine$macro$1$1 implements scala/Function1 scala/Function0$mcV$sp  {

  // compiled from: <console>
  OUTERCLASS Test test ()I

  ATTRIBUTE Scala : unknown

  ATTRIBUTE ScalaInlineInfo : unknown
  // access flags 0x1
  public INNERCLASS Test$stateMachine$macro$1$1 null stateMachine$macro$1$1

  // access flags 0x2
  private I state

  // access flags 0x12
  // signature Lscala/async/internal/Box<Ljava/lang/Object;>;
  // declaration: scala.async.internal.Box<java.lang.Object>
  private final Lscala/async/internal/Box; result

  // access flags 0x12
  private final Lscala/runtime/BoxedUnit; execContext

  // access flags 0x2
  private I f$macro$8

  // access flags 0x2
  private I await$macro$3$macro$9

  // access flags 0x2
  private I xxx$macro$10

  // access flags 0x2
  private I y$macro$11

  // access flags 0x2
  private I await$macro$7$macro$12

  // access flags 0x2
  private I await$macro$5$macro$13

  // access flags 0x2
  private I z$macro$14

  // access flags 0x1
  public apply$mcZ$sp()Z
   L0
    LINENUMBER 5 L0
    ALOAD 0
    INVOKESTATIC scala/Function0.apply$mcZ$sp$ (Lscala/Function0;)Z
    IRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1
  public apply$mcB$sp()B
   L0
    LINENUMBER 5 L0
    ALOAD 0
    INVOKESTATIC scala/Function0.apply$mcB$sp$ (Lscala/Function0;)B
    IRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1
  public apply$mcC$sp()C
   L0
    LINENUMBER 5 L0
    ALOAD 0
    INVOKESTATIC scala/Function0.apply$mcC$sp$ (Lscala/Function0;)C
    IRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1
  public apply$mcD$sp()D
   L0
    LINENUMBER 5 L0
    ALOAD 0
    INVOKESTATIC scala/Function0.apply$mcD$sp$ (Lscala/Function0;)D
    DRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    MAXSTACK = 2
    MAXLOCALS = 1

  // access flags 0x1
  public apply$mcF$sp()F
   L0
    LINENUMBER 5 L0
    ALOAD 0
    INVOKESTATIC scala/Function0.apply$mcF$sp$ (Lscala/Function0;)F
    FRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1
  public apply$mcI$sp()I
   L0
    LINENUMBER 5 L0
    ALOAD 0
    INVOKESTATIC scala/Function0.apply$mcI$sp$ (Lscala/Function0;)I
    IRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1
  public apply$mcJ$sp()J
   L0
    LINENUMBER 5 L0
    ALOAD 0
    INVOKESTATIC scala/Function0.apply$mcJ$sp$ (Lscala/Function0;)J
    LRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    MAXSTACK = 2
    MAXLOCALS = 1

  // access flags 0x1
  public apply$mcS$sp()S
   L0
    LINENUMBER 5 L0
    ALOAD 0
    INVOKESTATIC scala/Function0.apply$mcS$sp$ (Lscala/Function0;)S
    IRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1
  public toString()Ljava/lang/String;
   L0
    LINENUMBER 5 L0
    ALOAD 0
    INVOKESTATIC scala/Function0.toString$ (Lscala/Function0;)Ljava/lang/String;
    ARETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1
  public apply$mcZD$sp(D)Z
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    DLOAD 1
    INVOKESTATIC scala/Function1.apply$mcZD$sp$ (Lscala/Function1;D)Z
    IRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 D L0 L1 1
    MAXSTACK = 3
    MAXLOCALS = 3

  // access flags 0x1
  public apply$mcDD$sp(D)D
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    DLOAD 1
    INVOKESTATIC scala/Function1.apply$mcDD$sp$ (Lscala/Function1;D)D
    DRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 D L0 L1 1
    MAXSTACK = 3
    MAXLOCALS = 3

  // access flags 0x1
  public apply$mcFD$sp(D)F
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    DLOAD 1
    INVOKESTATIC scala/Function1.apply$mcFD$sp$ (Lscala/Function1;D)F
    FRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 D L0 L1 1
    MAXSTACK = 3
    MAXLOCALS = 3

  // access flags 0x1
  public apply$mcID$sp(D)I
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    DLOAD 1
    INVOKESTATIC scala/Function1.apply$mcID$sp$ (Lscala/Function1;D)I
    IRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 D L0 L1 1
    MAXSTACK = 3
    MAXLOCALS = 3

  // access flags 0x1
  public apply$mcJD$sp(D)J
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    DLOAD 1
    INVOKESTATIC scala/Function1.apply$mcJD$sp$ (Lscala/Function1;D)J
    LRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 D L0 L1 1
    MAXSTACK = 3
    MAXLOCALS = 3

  // access flags 0x1
  public apply$mcVD$sp(D)V
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    DLOAD 1
    INVOKESTATIC scala/Function1.apply$mcVD$sp$ (Lscala/Function1;D)V
    RETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 D L0 L1 1
    MAXSTACK = 3
    MAXLOCALS = 3

  // access flags 0x1
  public apply$mcZF$sp(F)Z
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    FLOAD 1
    INVOKESTATIC scala/Function1.apply$mcZF$sp$ (Lscala/Function1;F)Z
    IRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 F L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  public apply$mcDF$sp(F)D
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    FLOAD 1
    INVOKESTATIC scala/Function1.apply$mcDF$sp$ (Lscala/Function1;F)D
    DRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 F L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  public apply$mcFF$sp(F)F
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    FLOAD 1
    INVOKESTATIC scala/Function1.apply$mcFF$sp$ (Lscala/Function1;F)F
    FRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 F L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  public apply$mcIF$sp(F)I
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    FLOAD 1
    INVOKESTATIC scala/Function1.apply$mcIF$sp$ (Lscala/Function1;F)I
    IRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 F L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  public apply$mcJF$sp(F)J
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    FLOAD 1
    INVOKESTATIC scala/Function1.apply$mcJF$sp$ (Lscala/Function1;F)J
    LRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 F L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  public apply$mcVF$sp(F)V
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    FLOAD 1
    INVOKESTATIC scala/Function1.apply$mcVF$sp$ (Lscala/Function1;F)V
    RETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 F L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  public apply$mcZI$sp(I)Z
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    ILOAD 1
    INVOKESTATIC scala/Function1.apply$mcZI$sp$ (Lscala/Function1;I)Z
    IRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 I L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  public apply$mcDI$sp(I)D
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    ILOAD 1
    INVOKESTATIC scala/Function1.apply$mcDI$sp$ (Lscala/Function1;I)D
    DRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 I L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  public apply$mcFI$sp(I)F
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    ILOAD 1
    INVOKESTATIC scala/Function1.apply$mcFI$sp$ (Lscala/Function1;I)F
    FRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 I L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  public apply$mcII$sp(I)I
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    ILOAD 1
    INVOKESTATIC scala/Function1.apply$mcII$sp$ (Lscala/Function1;I)I
    IRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 I L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  public apply$mcJI$sp(I)J
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    ILOAD 1
    INVOKESTATIC scala/Function1.apply$mcJI$sp$ (Lscala/Function1;I)J
    LRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 I L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  public apply$mcVI$sp(I)V
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    ILOAD 1
    INVOKESTATIC scala/Function1.apply$mcVI$sp$ (Lscala/Function1;I)V
    RETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 I L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  public apply$mcZJ$sp(J)Z
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    LLOAD 1
    INVOKESTATIC scala/Function1.apply$mcZJ$sp$ (Lscala/Function1;J)Z
    IRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 J L0 L1 1
    MAXSTACK = 3
    MAXLOCALS = 3

  // access flags 0x1
  public apply$mcDJ$sp(J)D
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    LLOAD 1
    INVOKESTATIC scala/Function1.apply$mcDJ$sp$ (Lscala/Function1;J)D
    DRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 J L0 L1 1
    MAXSTACK = 3
    MAXLOCALS = 3

  // access flags 0x1
  public apply$mcFJ$sp(J)F
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    LLOAD 1
    INVOKESTATIC scala/Function1.apply$mcFJ$sp$ (Lscala/Function1;J)F
    FRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 J L0 L1 1
    MAXSTACK = 3
    MAXLOCALS = 3

  // access flags 0x1
  public apply$mcIJ$sp(J)I
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    LLOAD 1
    INVOKESTATIC scala/Function1.apply$mcIJ$sp$ (Lscala/Function1;J)I
    IRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 J L0 L1 1
    MAXSTACK = 3
    MAXLOCALS = 3

  // access flags 0x1
  public apply$mcJJ$sp(J)J
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    LLOAD 1
    INVOKESTATIC scala/Function1.apply$mcJJ$sp$ (Lscala/Function1;J)J
    LRETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 J L0 L1 1
    MAXSTACK = 3
    MAXLOCALS = 3

  // access flags 0x1
  public apply$mcVJ$sp(J)V
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    LLOAD 1
    INVOKESTATIC scala/Function1.apply$mcVJ$sp$ (Lscala/Function1;J)V
    RETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 J L0 L1 1
    MAXSTACK = 3
    MAXLOCALS = 3

  // access flags 0x1
  // signature <A:Ljava/lang/Object;>(Lscala/Function1<TA;Lscala/util/Try<Ljava/lang/Object;>;>;)Lscala/Function1<TA;Lscala/runtime/BoxedUnit;>;
  // declaration: scala.Function1<A, scala.runtime.BoxedUnit> compose<A>(scala.Function1<A, scala.util.Try<java.lang.Object>>)
  public compose(Lscala/Function1;)Lscala/Function1;
    // parameter final  g
   L0
    LINENUMBER 5 L0
    ALOAD 0
    ALOAD 1
    INVOKESTATIC scala/Function1.compose$ (Lscala/Function1;Lscala/Function1;)Lscala/Function1;
    ARETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE g Lscala/Function1; L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  // signature <A:Ljava/lang/Object;>(Lscala/Function1<Lscala/runtime/BoxedUnit;TA;>;)Lscala/Function1<Lscala/util/Try<Ljava/lang/Object;>;TA;>;
  // declaration: scala.Function1<scala.util.Try<java.lang.Object>, A> andThen<A>(scala.Function1<scala.runtime.BoxedUnit, A>)
  public andThen(Lscala/Function1;)Lscala/Function1;
    // parameter final  g
   L0
    LINENUMBER 5 L0
    ALOAD 0
    ALOAD 1
    INVOKESTATIC scala/Function1.andThen$ (Lscala/Function1;Lscala/Function1;)Lscala/Function1;
    ARETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE g Lscala/Function1; L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  // signature ()Lscala/async/internal/Box<Ljava/lang/Object;>;
  // declaration: scala.async.internal.Box<java.lang.Object> result()
  public result()Lscala/async/internal/Box;
   L0
    LINENUMBER 5 L0
    ALOAD 0
    GETFIELD Test$stateMachine$macro$1$1.result : Lscala/async/internal/Box;
    ARETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1
  public execContext()V
   L0
    LINENUMBER 5 L0
    RETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    MAXSTACK = 0
    MAXLOCALS = 1

  // access flags 0x1
  // signature (Lscala/util/Try<Ljava/lang/Object;>;)V
  // declaration: void apply(scala.util.Try<java.lang.Object>)
  public apply(Lscala/util/Try;)V
    // parameter final  tr
    TRYCATCHBLOCK L0 L1 L2 java/lang/Throwable
   L0
    LINENUMBER 5 L0
   FRAME SAME
    ALOAD 0
    GETFIELD Test$stateMachine$macro$1$1.state : I
    ISTORE 2
    ILOAD 2
    TABLESWITCH
      0: L3
      1: L4
      2: L5
      3: L6
      4: L7
      5: L8
      6: L9
      7: L10
      8: L11
      9: L12
      10: L13
      11: L14
      12: L15
      default: L16
   L3
    LINENUMBER 6 L3
   FRAME APPEND [I]
    ALOAD 0
    ICONST_1
    PUTFIELD Test$stateMachine$macro$1$1.y$macro$11 : I
   L17
    LINENUMBER 7 L17
    ALOAD 0
    ALOAD 0
    GETFIELD Test$stateMachine$macro$1$1.y$macro$11 : I
    ICONST_2
    IADD
    PUTFIELD Test$stateMachine$macro$1$1.f$macro$8 : I
   L18
    LINENUMBER 8 L18
    ALOAD 0
    ICONST_0
    PUTFIELD Test$stateMachine$macro$1$1.z$macro$14 : I
   L19
    LINENUMBER 9 L19
    ALOAD 0
    GETFIELD Test$stateMachine$macro$1$1.y$macro$11 : I
    ISTORE 3
    ILOAD 3
    TABLESWITCH
      0: L20
      1: L21
      default: L22
   L20
    LINENUMBER 5 L20
   FRAME APPEND [I]
    ALOAD 0
    ICONST_1
    PUTFIELD Test$stateMachine$macro$1$1.state : I
    GOTO L23
   L21
   FRAME SAME
    ALOAD 0
    ICONST_3
    PUTFIELD Test$stateMachine$macro$1$1.state : I
    GOTO L23
   L22
    LINENUMBER 9 L22
   FRAME SAME
    NEW scala/MatchError
    DUP
    ILOAD 3
    INVOKESTATIC scala/runtime/BoxesRunTime.boxToInteger (I)Ljava/lang/Integer;
    INVOKESPECIAL scala/MatchError.<init> (Ljava/lang/Object;)V
    ATHROW
   L23
    LINENUMBER 5 L23
   FRAME SAME
    GOTO L1
   L4
    LINENUMBER 11 L4
   FRAME CHOP 1
    ALOAD 0
    GETFIELD Test$stateMachine$macro$1$1.f$macro$8 : I
    ISTORE 4
   L24
    LINENUMBER 5 L24
    ALOAD 0
    BIPUSH 10
    PUTFIELD Test$stateMachine$macro$1$1.state : I
    ALOAD 0
    NEW scala/util/Success
    DUP
   L25
    LINENUMBER 11 L25
    ILOAD 4
    INVOKESTATIC scala/runtime/BoxesRunTime.boxToInteger (I)Ljava/lang/Integer;
    INVOKESPECIAL scala/util/Success.<init> (Ljava/lang/Object;)V
    INVOKEVIRTUAL Test$stateMachine$macro$1$1.apply (Lscala/util/Try;)V
   L26
    LINENUMBER 5 L26
    RETURN
   L5
   FRAME SAME
    ALOAD 0
    ICONST_5
    PUTFIELD Test$stateMachine$macro$1$1.state : I
   L27
    LINENUMBER 11 L27
    ALOAD 0
    GETFIELD Test$stateMachine$macro$1$1.await$macro$3$macro$9 : I
   L28
    ISTORE 5
   L29
    LINENUMBER 12 L29
    ALOAD 0
    ILOAD 5
    ICONST_2
    ISUB
    PUTFIELD Test$stateMachine$macro$1$1.z$macro$14 : I
   L30
    GOTO L1
   L6
    LINENUMBER 14 L6
   FRAME SAME
    ALOAD 0
    GETFIELD Test$stateMachine$macro$1$1.f$macro$8 : I
    ISTORE 6
   L31
    LINENUMBER 5 L31
    ALOAD 0
    BIPUSH 11
    PUTFIELD Test$stateMachine$macro$1$1.state : I
    ALOAD 0
    NEW scala/util/Success
    DUP
   L32
    LINENUMBER 14 L32
    ILOAD 6
    INVOKESTATIC scala/runtime/BoxesRunTime.boxToInteger (I)Ljava/lang/Integer;
    INVOKESPECIAL scala/util/Success.<init> (Ljava/lang/Object;)V
    INVOKEVIRTUAL Test$stateMachine$macro$1$1.apply (Lscala/util/Try;)V
   L33
    LINENUMBER 5 L33
    RETURN
   L7
   FRAME SAME
    ALOAD 0
    ICONST_5
    PUTFIELD Test$stateMachine$macro$1$1.state : I
   L34
    LINENUMBER 14 L34
    ALOAD 0
    GETFIELD Test$stateMachine$macro$1$1.await$macro$5$macro$13 : I
   L35
    ISTORE 7
   L36
    LINENUMBER 15 L36
    ALOAD 0
    ILOAD 7
    ICONST_2
    IADD
    PUTFIELD Test$stateMachine$macro$1$1.z$macro$14 : I
   L37
    GOTO L1
   L8
    LINENUMBER 17 L8
   FRAME SAME
    ALOAD 0
    GETFIELD Test$stateMachine$macro$1$1.z$macro$14 : I
    POP
   L38
    LINENUMBER 18 L38
    ALOAD 0
    ICONST_0
    PUTFIELD Test$stateMachine$macro$1$1.xxx$macro$10 : I
   L39
    LINENUMBER 5 L39
    ALOAD 0
    BIPUSH 6
    PUTFIELD Test$stateMachine$macro$1$1.state : I
    GOTO L1
   L9
    LINENUMBER 19 L9
   FRAME SAME
    ALOAD 0
    GETFIELD Test$stateMachine$macro$1$1.xxx$macro$10 : I
    ICONST_3
    IF_ICMPGE L40
   L41
    LINENUMBER 5 L41
    ALOAD 0
    BIPUSH 7
    PUTFIELD Test$stateMachine$macro$1$1.state : I
    GOTO L42
   L40
   FRAME SAME
    ALOAD 0
    BIPUSH 9
    PUTFIELD Test$stateMachine$macro$1$1.state : I
   L42
   FRAME SAME
    GOTO L1
   L10
    LINENUMBER 20 L10
   FRAME SAME
    ALOAD 0
    GETFIELD Test$stateMachine$macro$1$1.xxx$macro$10 : I
    ISTORE 8
   L43
    LINENUMBER 5 L43
    ALOAD 0
    BIPUSH 12
    PUTFIELD Test$stateMachine$macro$1$1.state : I
    ALOAD 0
    NEW scala/util/Success
    DUP
   L44
    LINENUMBER 20 L44
    ILOAD 8
    INVOKESTATIC scala/runtime/BoxesRunTime.boxToInteger (I)Ljava/lang/Integer;
    INVOKESPECIAL scala/util/Success.<init> (Ljava/lang/Object;)V
    INVOKEVIRTUAL Test$stateMachine$macro$1$1.apply (Lscala/util/Try;)V
   L45
    LINENUMBER 5 L45
    RETURN
   L11
   FRAME SAME
    ALOAD 0
    BIPUSH 6
    PUTFIELD Test$stateMachine$macro$1$1.state : I
   L46
    LINENUMBER 20 L46
    ALOAD 0
    ALOAD 0
    GETFIELD Test$stateMachine$macro$1$1.await$macro$7$macro$12 : I
    PUTFIELD Test$stateMachine$macro$1$1.y$macro$11 : I
   L47
    LINENUMBER 21 L47
    ALOAD 0
    ALOAD 0
    GETFIELD Test$stateMachine$macro$1$1.xxx$macro$10 : I
    ICONST_1
    IADD
    PUTFIELD Test$stateMachine$macro$1$1.xxx$macro$10 : I
    GOTO L1
   L12
    LINENUMBER 5 L12
   FRAME SAME
    ALOAD 0
    INVOKEVIRTUAL Test$stateMachine$macro$1$1.result ()Lscala/async/internal/Box;
    NEW scala/util/Success
    DUP
   L48
    LINENUMBER 23 L48
    ALOAD 0
    GETFIELD Test$stateMachine$macro$1$1.y$macro$11 : I
    INVOKESTATIC scala/runtime/BoxesRunTime.boxToInteger (I)Ljava/lang/Integer;
    INVOKESPECIAL scala/util/Success.<init> (Ljava/lang/Object;)V
    INVOKEVIRTUAL scala/util/Success.get ()Ljava/lang/Object;
    INVOKEVIRTUAL scala/async/internal/Box.a_$eq (Ljava/lang/Object;)V
   L49
    LINENUMBER 5 L49
    RETURN
   L13
   FRAME SAME
    ALOAD 1
    INVOKEVIRTUAL scala/util/Try.isFailure ()Z
    IFEQ L50
    ALOAD 0
    INVOKEVIRTUAL Test$stateMachine$macro$1$1.result ()Lscala/async/internal/Box;
    ALOAD 1
    INVOKEVIRTUAL scala/util/Try.get ()Ljava/lang/Object;
    INVOKEVIRTUAL scala/async/internal/Box.a_$eq (Ljava/lang/Object;)V
    RETURN
   L50
   FRAME SAME
    ALOAD 0
    ALOAD 1
    INVOKEVIRTUAL scala/util/Try.get ()Ljava/lang/Object;
    INVOKESTATIC scala/runtime/BoxesRunTime.unboxToInt (Ljava/lang/Object;)I
    PUTFIELD Test$stateMachine$macro$1$1.await$macro$3$macro$9 : I
    ALOAD 0
    ICONST_2
    PUTFIELD Test$stateMachine$macro$1$1.state : I
    GOTO L1
   L14
   FRAME SAME
    ALOAD 1
    INVOKEVIRTUAL scala/util/Try.isFailure ()Z
    IFEQ L51
    ALOAD 0
    INVOKEVIRTUAL Test$stateMachine$macro$1$1.result ()Lscala/async/internal/Box;
    ALOAD 1
    INVOKEVIRTUAL scala/util/Try.get ()Ljava/lang/Object;
    INVOKEVIRTUAL scala/async/internal/Box.a_$eq (Ljava/lang/Object;)V
    RETURN
   L51
   FRAME SAME
    ALOAD 0
    ALOAD 1
    INVOKEVIRTUAL scala/util/Try.get ()Ljava/lang/Object;
    INVOKESTATIC scala/runtime/BoxesRunTime.unboxToInt (Ljava/lang/Object;)I
    PUTFIELD Test$stateMachine$macro$1$1.await$macro$5$macro$13 : I
    ALOAD 0
    ICONST_4
    PUTFIELD Test$stateMachine$macro$1$1.state : I
    GOTO L1
   L15
   FRAME SAME
    ALOAD 1
    INVOKEVIRTUAL scala/util/Try.isFailure ()Z
    IFEQ L52
    ALOAD 0
    INVOKEVIRTUAL Test$stateMachine$macro$1$1.result ()Lscala/async/internal/Box;
    ALOAD 1
    INVOKEVIRTUAL scala/util/Try.get ()Ljava/lang/Object;
    INVOKEVIRTUAL scala/async/internal/Box.a_$eq (Ljava/lang/Object;)V
    RETURN
   L52
   FRAME SAME
    ALOAD 0
    ALOAD 1
    INVOKEVIRTUAL scala/util/Try.get ()Ljava/lang/Object;
    INVOKESTATIC scala/runtime/BoxesRunTime.unboxToInt (Ljava/lang/Object;)I
    PUTFIELD Test$stateMachine$macro$1$1.await$macro$7$macro$12 : I
    ALOAD 0
    BIPUSH 8
    PUTFIELD Test$stateMachine$macro$1$1.state : I
    GOTO L1
   L16
   FRAME SAME
    NEW java/lang/IllegalStateException
    DUP
    INVOKESPECIAL java/lang/IllegalStateException.<init> ()V
    ATHROW
   L1
   FRAME SAME
    GOTO L53
   L2
   FRAME FULL [Test$stateMachine$macro$1$1 scala/util/Try] [java/lang/Throwable]
    ASTORE 9
    ALOAD 0
    INVOKEVIRTUAL Test$stateMachine$macro$1$1.result ()Lscala/async/internal/Box;
    NEW scala/util/Failure
    DUP
    ALOAD 9
    INVOKESPECIAL scala/util/Failure.<init> (Ljava/lang/Throwable;)V
    INVOKEVIRTUAL scala/util/Failure.get ()Ljava/lang/Object;
    INVOKEVIRTUAL scala/async/internal/Box.a_$eq (Ljava/lang/Object;)V
    RETURN
   L53
   FRAME APPEND [I]
    GOTO L0
   L54
    LOCALVARIABLE x2 I L28 L30 5
    LOCALVARIABLE x1 I L35 L37 7
    LOCALVARIABLE throwable Ljava/lang/Throwable; L2 L53 9
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L54 0
    LOCALVARIABLE tr Lscala/util/Try; L0 L54 1
    MAXSTACK = 4
    MAXLOCALS = 10

  // access flags 0x1
  public apply()V
   L0
    LINENUMBER 5 L0
    ALOAD 0
    INVOKEVIRTUAL Test$stateMachine$macro$1$1.apply$mcV$sp ()V
    RETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1
  public apply$mcV$sp()V
   L0
    LINENUMBER 5 L0
    ALOAD 0
    ACONST_NULL
    INVOKEVIRTUAL Test$stateMachine$macro$1$1.apply (Lscala/util/Try;)V
    RETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    MAXSTACK = 2
    MAXLOCALS = 1

  // access flags 0x1041
  public synthetic bridge apply()Ljava/lang/Object;
   L0
    LINENUMBER 5 L0
    ALOAD 0
    INVOKEVIRTUAL Test$stateMachine$macro$1$1.apply ()V
    GETSTATIC scala/runtime/BoxedUnit.UNIT : Lscala/runtime/BoxedUnit;
    ARETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1041
  public synthetic bridge apply(Ljava/lang/Object;)Ljava/lang/Object;
    // parameter final  v1
   L0
    LINENUMBER 5 L0
    ALOAD 0
    ALOAD 1
    CHECKCAST scala/util/Try
    INVOKEVIRTUAL Test$stateMachine$macro$1$1.apply (Lscala/util/Try;)V
    GETSTATIC scala/runtime/BoxedUnit.UNIT : Lscala/runtime/BoxedUnit;
    ARETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE v1 Ljava/lang/Object; L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  public <init>(LTest;)V
    // parameter final  $outer
   L0
    LINENUMBER 5 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    ALOAD 0
    INVOKESTATIC scala/Function1.$init$ (Lscala/Function1;)V
    ALOAD 0
    INVOKESTATIC scala/Function0.$init$ (Lscala/Function0;)V
    ALOAD 0
    ICONST_0
    PUTFIELD Test$stateMachine$macro$1$1.state : I
    ALOAD 0
    NEW scala/async/internal/Box
    DUP
    INVOKESPECIAL scala/async/internal/Box.<init> ()V
    PUTFIELD Test$stateMachine$macro$1$1.result : Lscala/async/internal/Box;
    ALOAD 0
    GETSTATIC scala/runtime/BoxedUnit.UNIT : Lscala/runtime/BoxedUnit;
    PUTFIELD Test$stateMachine$macro$1$1.execContext : Lscala/runtime/BoxedUnit;
    RETURN
   L1
    LOCALVARIABLE this LTest$stateMachine$macro$1$1; L0 L1 0
    LOCALVARIABLE $outer LTest; L0 L1 1
    MAXSTACK = 3
    MAXLOCALS = 2
}

2

Process finished with exit code 0

```

Author: retronym

src/test/scala/scala/async/TreeInterrogation.scala

@@ -12,6 +12,7 @@ import org.junit.Test
 import scala.async.internal.AsyncId
 import AsyncId._
 import scala.reflect.internal.util.ScalaClassLoader
+import scala.reflect.io.Streamable
 import scala.tools.ant.sabbus.Settings
 import scala.tools.nsc
 import scala.tools.nsc.Global
@@ -87,7 +88,7 @@ object TreeInterrogation extends App {
           def test = {
             import scala.async.internal.AsyncId._
             async {
-              val y = 1
+              var y = 1
               val f = y + 2
               var z = 0
               y match {
@@ -99,6 +100,12 @@ object TreeInterrogation extends App {
                   z = x1 + 2
               }
               z
+              var xxx: Int = 0
+              while (xxx < 3) {
+                y = await(xxx)
+                xxx = xxx + 1
+              }
+              y
             }
           }
           println(test)
@@ -110,6 +117,8 @@ object TreeInterrogation extends App {
     println(tree)
     val loader = new ScalaClassLoader.URLClassLoader(Seq(new File(settings.outdir.value).toURI.toURL), g.getClass.getClassLoader)
     val cls = loader.loadClass("Test")
+    val clsBytes = Streamable.bytes(loader.getResourceAsStream("Test$stateMachine$macro$1$1.class"))
+    scala.tools.nsc.backend.jvm.AsmUtils.traceClass(clsBytes)
     cls.getMethod("test").invoke(cls.newInstance())
   }