simple

[
	undefined,
	,
	undefined,
	
]

  var expecting = [undefined, undefined];
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

simpleish

[
	undefined,
	,
	undefined,
	
]

  // the space after yield was causing a problem at some point ;)
  var expecting = [undefined, undefined];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

single step, returns 1

[
	undefined,
	,
	1
]

  var expecting = [undefined, 1];
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

yield arg

[
	1,
	2
]

  var expecting = [1,2];
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) {
      return (_γ_ielded=true, _γ_nextId = 1,  1)
}
    return 2;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
_γ_ieldValue_1;
    }
    return 2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

yield return

[
	undefined,
	,
	1
]

  var send = [,1];
  var expecting = [undefined, 1];
  function g(){
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

 x = _γ_ieldValue_1;
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

yield return yield

[
	undefined,
	,
	1
]

  var send = [,1];
  var expecting = [undefined, 1];
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

return _γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

yield complex expression

[
	13,
	1
]

  var send = [,1];
  var expecting = [13,1];
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1,  10+3)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

return _γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

condition, passing

[
	1,
	2
]

  var expecting = [1, 2];
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) {
      return (_γ_ielded=true, _γ_nextId = 1,  1)
}
    return 2;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
_γ_ieldValue_1;
    }
    return 2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

condition, failing

[
	2
]

  var expecting = [2];
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (false) {
      return (_γ_ielded=true, _γ_nextId = 1,  1)
}
    return 2;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
_γ_ieldValue_1;
    }
    return 2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

yield as condition, passing

[
	undefined,
	,
	1
]

  var send = [,true];
  var expecting = [undefined,1];
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 2;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

if (_γ_ieldValue_1) {
      return 1;
    }
    return 2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

yield as condition, failing

[
	undefined,
	,
	2
]

  var send = [,false];
  var expecting = [undefined,2];
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 2;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

if (_γ_ieldValue_1) {
      return 1;
    }
    return 2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

yield with argument as condition

[
	1,
	3
]

  var send = [,false];
  var expecting = [1,3];
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1,  1)
return 3;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

if (_γ_ieldValue_1) {
      return 2;
    }
    return 3;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

generator args

[
	undefined,
	,
	1
]

  var args = [1];
  var expecting = [undefined,1];
  function g(x){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double loop, inner yield

[
	"abc",
	"abcdc",
	"abcdcdebef"
]

  expecting = ['abc', 'abcdc', 'abcdcdebef'];

  var x = 3;
  var y = 3;
  var s = '';
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    s += 'a';
    while (--x > 0) {
      s += 'b';
      while (--y > 0) {
        s += 'c';
        return (_γ_ielded=true, _γ_nextId = 1,  s)
s += 'd';
      }
      s += 'e';
    }
    return s + 'f';
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_35 = true, _γ_broke_35 = false;_γ_whileOnce_35; _γ_whileOnce_35 = false)
{
for (var _γ_whileOnce_47 = true, _γ_broke_47 = false;_γ_whileOnce_47; _γ_whileOnce_47 = false)
{
_γ_ieldValue_1;
        s += 'd';
      }
      if (!_γ_broke_47) { while (--y > 0) {
        s += 'c';
        return (_γ_ielded=true, _γ_nextId = 1,  s)
s += 'd';
      }
      }s += 'e';
    }
    if (!_γ_broke_35) { while (--x > 0) {
      s += 'b';
      while (--y > 0) {
        s += 'c';
        return (_γ_ielded=true, _γ_nextId = 1,  s)
s += 'd';
      }
      s += 'e';
    }
    }return s + 'f';
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double loop, inner yield, inner loop resets

[
	"abc",
	"abcdc",
	"abcdcdebc",
	"abcdcdebcdc",
	"abcdcdebcdcdef"
]

  expecting = ['abc', 'abcdc', 'abcdcdebc', 'abcdcdebcdc', 'abcdcdebcdcdef'];

  var x = 0;
  var y = 0;
  var s = '';
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    s += 'a';
    while (++x < 3) {
      y = 0;
      s += 'b';
      while (++y < 3) {
        s += 'c';
        return (_γ_ielded=true, _γ_nextId = 1,  s)
s += 'd';
      }
      s += 'e';
    }
    return s + 'f';
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_39 = true, _γ_broke_39 = false;_γ_whileOnce_39; _γ_whileOnce_39 = false)
{
for (var _γ_whileOnce_55 = true, _γ_broke_55 = false;_γ_whileOnce_55; _γ_whileOnce_55 = false)
{
_γ_ieldValue_1;
        s += 'd';
      }
      if (!_γ_broke_55) { while (++y < 3) {
        s += 'c';
        return (_γ_ielded=true, _γ_nextId = 1,  s)
s += 'd';
      }
      }s += 'e';
    }
    if (!_γ_broke_39) { while (++x < 3) {
      y = 0;
      s += 'b';
      while (++y < 3) {
        s += 'c';
        return (_γ_ielded=true, _γ_nextId = 1,  s)
s += 'd';
      }
      s += 'e';
    }
    }return s + 'f';
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double loop, outer yield

[
	"ab",
	"abcddeb",
	"abcddebcef"
]

  expecting = ['ab', 'abcddeb', 'abcddebcef'];

  var x = 3;
  var y = 3;
  var s = '';
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    s += 'a';
    while (--x > 0) {
      s += 'b';
      return (_γ_ielded=true, _γ_nextId = 1,  s)
s += 'c';
      while (--y > 0) {
        s += 'd';
      }
      s += 'e';
    }
    return s + 'f';
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_35 = true, _γ_broke_35 = false;_γ_whileOnce_35; _γ_whileOnce_35 = false)
{
_γ_ieldValue_1;
      s += 'c';
      while (--y > 0) {
        s += 'd';
      }
      s += 'e';
    }
    if (!_γ_broke_35) { while (--x > 0) {
      s += 'b';
      return (_γ_ielded=true, _γ_nextId = 1,  s)
s += 'c';
      while (--y > 0) {
        s += 'd';
      }
      s += 'e';
    }
    }return s + 'f';
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

generator context

[
	1,
	3
]

  var context = {a:1, b:2};
  var send = [,2];
  var expecting = [1, 3];
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1,  this.a)
return this.a + this.b;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

this.b = _γ_ieldValue_1;
    return this.a + this.b;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}
  // g.next(2); == 1
  // g.next(); == 3

simple while loop

[
	0,
	1,
	2
]

  var expecting = [0, 1, 2];

  var x = 0;
  var y = 0;
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    while (++x < 3) {
      return (_γ_ielded=true, _γ_nextId = 1,  y++)
}
    return y;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_27 = true, _γ_broke_27 = false;_γ_whileOnce_27; _γ_whileOnce_27 = false)
{
_γ_ieldValue_1;
    }
    if (!_γ_broke_27) { while (++x < 3) {
      return (_γ_ielded=true, _γ_nextId = 1,  y++)
}
    }return y;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

simple for loop no-var

[
	0,
	1,
	2,
	3
]

  var expecting = [0, 1, 2, 3];

  var x = 0;
  var y = 0;
  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    {x=0;while ( x<3) {
      return (_γ_ielded=true, _γ_nextId = 1,  y++)
++x;}}
    return y;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_34 = true, _γ_broke_34 = false;_γ_whileOnce_34; _γ_whileOnce_34 = false)
{
_γ_ieldValue_1;
     ++x;}if (!_γ_broke_34) { while ( x<3) {
      return (_γ_ielded=true, _γ_nextId = 1,  y++)
++x;}}}
    return y;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

simple for loop var

[
	0,
	1,
	2,
	3
]

  var expecting = [0, 1, 2, 3];

  var y = 0;
  function g(){
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    { x=0;while ( x<3) {
      return (_γ_ielded=true, _γ_nextId = 1,  y++)
++x;}}
    return y;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_30 = true, _γ_broke_30 = false;_γ_whileOnce_30; _γ_whileOnce_30 = false)
{
_γ_ieldValue_1;
     ++x;}if (!_γ_broke_30) { while ( x<3) {
      return (_γ_ielded=true, _γ_nextId = 1,  y++)
++x;}}}
    return y;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

for-in, outside yield before

[
	undefined,
	,
	" "
]

  var expecting = [undefined, ' '];

  function g() {
var s, o, key, _γ_key, _γ_keys_39, _γ_expro_39;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
 s = ' a b 15 ';
     o = {a:true,b:true,15:true};
      key ;
 _γ_key, _γ_keys_39 = [], _γ_expro_39 = ( o);
for (_γ_key in _γ_expro_39) _γ_keys_39.push(_γ_key);
while (_γ_keys_39.length)
if (_γ_keys_39[0] in _γ_expro_39 && !void( key  = _γ_keys_39.shift()))
  {
       s = s.replace(' '+key+' ', ' ');
    }
    return s;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
     s = ' a b 15 ';
     o = {a:true,b:true,15:true};
      key ;
 _γ_key, _γ_keys_39 = [], _γ_expro_39 = ( o);
for (_γ_key in _γ_expro_39) _γ_keys_39.push(_γ_key);
while (_γ_keys_39.length)
if (_γ_keys_39[0] in _γ_expro_39 && !void( key  = _γ_keys_39.shift()))
  {
       s = s.replace(' '+key+' ', ' ');
    }
    return s;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

for-in, outside yield after

[
	undefined,
	,
	" "
]

  var expecting = [undefined, ' '];

  function g() {
var s, o, key, _γ_key, _γ_keys_37, _γ_expro_37;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     s = ' a b 15 ';
     o = {a:true,b:true,15:true};
      key ;
 _γ_key, _γ_keys_37 = [], _γ_expro_37 = ( o);
for (_γ_key in _γ_expro_37) _γ_keys_37.push(_γ_key);
while (_γ_keys_37.length)
if (_γ_keys_37[0] in _γ_expro_37 && !void( key  = _γ_keys_37.shift()))
  {
       s = s.replace(' '+key+' ', ' ');
    }
    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return s;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
    return s;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

simple for-in loop no-var

[
	"a",
	"b",
	3
]

  var expecting = ['a', 'b', 3];

  var o = {a:1, b:2};
  var y = 0;
  function g(){
var key, _γ_key, _γ_keys_38, _γ_expro_38;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     key;
    key ;
 _γ_key, _γ_keys_38 = [], _γ_expro_38 = ( o);
for (_γ_key in _γ_expro_38) _γ_keys_38.push(_γ_key);
while (_γ_keys_38.length)
if (_γ_keys_38[0] in _γ_expro_38 && !void(key  = _γ_keys_38.shift()))
  {
      return (_γ_ielded=true, _γ_nextId = 1,  key)
y += o[key];
    }
    return y;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_67 = true, _γ_broke_67 = false;_γ_whileOnce_67; _γ_whileOnce_67 = false)
if (true)
{
_γ_ieldValue_1;
      y += o[key];
    }
    if (!_γ_broke_67) { while (_γ_keys_38.length)
if (_γ_keys_38[0] in _γ_expro_38 && !void(key  = _γ_keys_38.shift()))
  {
      return (_γ_ielded=true, _γ_nextId = 1,  key)
y += o[key];
    }
    }return y;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

simple for-in loop var

[
	"a",
	"b",
	3
]

  var expecting = ['a', 'b', 3];

  var o = {a:1, b:2};
  var y = 0;
  function g(){
var key, _γ_key, _γ_keys_35, _γ_expro_35;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

      key ;
 _γ_key, _γ_keys_35 = [], _γ_expro_35 = ( o);
for (_γ_key in _γ_expro_35) _γ_keys_35.push(_γ_key);
while (_γ_keys_35.length)
if (_γ_keys_35[0] in _γ_expro_35 && !void( key  = _γ_keys_35.shift()))
  {
      return (_γ_ielded=true, _γ_nextId = 1,  key)
y += o[key];
    }
    return y;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_65 = true, _γ_broke_65 = false;_γ_whileOnce_65; _γ_whileOnce_65 = false)
if (true)
{
_γ_ieldValue_1;
      y += o[key];
    }
    if (!_γ_broke_65) { while (_γ_keys_35.length)
if (_γ_keys_35[0] in _γ_expro_35 && !void( key  = _γ_keys_35.shift()))
  {
      return (_γ_ielded=true, _γ_nextId = 1,  key)
y += o[key];
    }
    }return y;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

for-in yield rhs

[
	undefined,
	,
	3
]

  var o = {1:1, 2:2};
  var send = [,o];
  var expecting = [undefined, 3];

  var y = 0;
  function g(){
var key, key, _γ_key, _γ_keys_44, _γ_expro_44;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     key;
      key ;
return (_γ_ielded=true, _γ_nextId = 1, undefined)
for (_γ_key in _γ_expro_44) _γ_keys_44.push(_γ_key);
while (_γ_keys_44.length)
if (_γ_keys_44[0] in _γ_expro_44 && !void( key  = _γ_keys_44.shift()))
  {
      y += parseInt(key, 10);
    }
    return y;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

 _γ_key, _γ_keys_44 = [], _γ_expro_44 = ( _γ_ieldValue_1);
for (_γ_key in _γ_expro_44) _γ_keys_44.push(_γ_key);
while (_γ_keys_44.length)
if (_γ_keys_44[0] in _γ_expro_44 && !void( key  = _γ_keys_44.shift()))
  {
      y += parseInt(key, 10);
    }
    return y;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

for-in yield rhs with arg

[
	15,
	3
]

  var o = {1:1, 2:2};
  var send = [,o];
  var expecting = [15, 3];

  var y = 0;
  function g(){
var key, key, _γ_key, _γ_keys_44, _γ_expro_44;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     key;
      key ;
return (_γ_ielded=true, _γ_nextId = 1,  15)
for (_γ_key in _γ_expro_44) _γ_keys_44.push(_γ_key);
while (_γ_keys_44.length)
if (_γ_keys_44[0] in _γ_expro_44 && !void( key  = _γ_keys_44.shift()))
  {
      y += parseInt(key, 10);
    }
    return y;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

 _γ_key, _γ_keys_44 = [], _γ_expro_44 = ( _γ_ieldValue_1);
for (_γ_key in _γ_expro_44) _γ_keys_44.push(_γ_key);
while (_γ_keys_44.length)
if (_γ_keys_44[0] in _γ_expro_44 && !void( key  = _γ_keys_44.shift()))
  {
      y += parseInt(key, 10);
    }
    return y;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

if no-block

[
	2,
	3
]

  var send = [,3];
  var expecting = [2, 3];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) return (_γ_ielded=true, _γ_nextId = 1,  2)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
return _γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

if block

[
	2,
	3
]

  var send = [,3];
  var expecting = [2, 3];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) {
      return (_γ_ielded=true, _γ_nextId = 1,  2)
}
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
return _γ_ieldValue_1;
    }
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

if-else no-block

[
	2,
	3
]

  var send = [,3];
  var expecting = [2, 3];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) return (_γ_ielded=true, _γ_nextId = 1,  2)
else return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
return _γ_ieldValue_1;
    else return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

if block

[
	2,
	3
]

  var send = [,3];
  var expecting = [2, 3];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) {
      return (_γ_ielded=true, _γ_nextId = 1,  2)
} else {
      return 5;
    }
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
return _γ_ieldValue_1;
    } else {
      return 5;
    }
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

else no-block

[
	2,
	[object Object]
]

  var obj = {};
  var send = [,obj];
  var expecting = [2, obj];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (false) {
      return 1;
    } else return (_γ_ielded=true, _γ_nextId = 1,  2)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
return _γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

else block

[
	2,
	[object Object]
]

  var obj = {};
  var send = [,obj];
  var expecting = [2, obj];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (false) {
      return 1;
    } else {
      return (_γ_ielded=true, _γ_nextId = 1,  2)
}
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
return _γ_ieldValue_1;
    }
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

if-then-elseif block

[
	2,
	3
]

  var send = [,3];
  var expecting = [2, 3];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) {
      return (_γ_ielded=true, _γ_nextId = 1,  2)
} else if (false) {
      return 3;
    }
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
return _γ_ieldValue_1;
    } else if (false) {
      return 3;
    }
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

if-then-elseif no-block

[
	2,
	3
]

  var send = [,3];
  var expecting = [2, 3];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) return (_γ_ielded=true, _γ_nextId = 1,  2)
else if (false) return 3;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
return _γ_ieldValue_1;
    else if (false) return 3;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double if yield

[
	1,
	2,
	3
]

  var expecting = [1, 2, 3];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) return (_γ_ielded=true, _γ_nextId = 1,  1)
if (true) return (_γ_ielded=true, _γ_nextId = 2,  2)
return 3;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
_γ_ieldValue_1;
    if (true) return (_γ_ielded=true, _γ_nextId = 2,  2)
return 3;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
_γ_ieldValue_2;
    return 3;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double nested if yield

[
	1,
	2,
	3
]

  var expecting = [1, 2, 3];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) {
      return (_γ_ielded=true, _γ_nextId = 1,  1)
if (true) return (_γ_ielded=true, _γ_nextId = 2,  2)
}
    return 3;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
_γ_ieldValue_1;
      if (true) return (_γ_ielded=true, _γ_nextId = 2,  2)
}
    return 3;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
if (true)
_γ_ieldValue_2;
    }
    return 3;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

if-else double yield

[
	2,
	4
]

  var send = [,3];
  var expecting = [2, 4];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) {
      return (_γ_ielded=true, _γ_nextId = 1,  2)
} else {
      return (_γ_ielded=true, _γ_nextId = 2,  3)
}
    return 4;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
_γ_ieldValue_1;
    } else {
      return (_γ_ielded=true, _γ_nextId = 2,  3)
}
    return 4;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
_γ_ieldValue_2;
    }
    return 4;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

if-then-elseif block double yield

[
	2,
	4
]

  var send = [,3];
  var expecting = [2, 4];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) {
      return (_γ_ielded=true, _γ_nextId = 1,  2)
} else if (false) {
      return (_γ_ielded=true, _γ_nextId = 2,  3)
}
    return 4;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
_γ_ieldValue_1;
    } else if (false) {
      return (_γ_ielded=true, _γ_nextId = 2,  3)
}
    return 4;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
if (true)
{
_γ_ieldValue_2;
    }
    return 4;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

if return yield

[
	undefined,
	,
	2
]

  var send = [,2];
  var expecting = [undefined, 2];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
return _γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

else return yield

[
	undefined,
	,
	2
]

  var send = [,2];
  var expecting = [undefined, 2];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (false) return 5;
    else return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
return _γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

ifelse double return yield

[
	undefined,
	,
	2
]

  var send = [,2];
  var expecting = [undefined, 2];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (false) return (_γ_ielded=true, _γ_nextId = 1, undefined)
else return (_γ_ielded=true, _γ_nextId = 2, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
return _γ_ieldValue_1;
    else return (_γ_ielded=true, _γ_nextId = 2, undefined)

    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
return _γ_ieldValue_2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

if-then-elseif return double yield

[
	2,
	3
]

  var send = [,3];
  var expecting = [2, 3];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) {
      return (_γ_ielded=true, _γ_nextId = 1,  2)
} else if (false) {
      return (_γ_ielded=true, _γ_nextId = 2,  3)
}
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
return _γ_ieldValue_1;
    } else if (false) {
      return (_γ_ielded=true, _γ_nextId = 2,  3)
}
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
if (true)
{
return _γ_ieldValue_2;
    }
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

if-then-elseif no-block return double yield

[
	2,
	3
]

  var send = [,3];
  var expecting = [2, 3];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) return (_γ_ielded=true, _γ_nextId = 1,  2)
else if (false) return (_γ_ielded=true, _γ_nextId = 2,  3)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
return _γ_ieldValue_1;
    else if (false) return (_γ_ielded=true, _γ_nextId = 2,  3)

    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
if (true)
return _γ_ieldValue_2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

if-then-elseif-else block return double yield

[
	2,
	3
]

  var send = [,3];
  var expecting = [2, 3];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) {
      return (_γ_ielded=true, _γ_nextId = 1,  2)
} else if (false) {
      return (_γ_ielded=true, _γ_nextId = 2,  3)
} else {
      return 5;
    }
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
return _γ_ieldValue_1;
    } else if (false) {
      return (_γ_ielded=true, _γ_nextId = 2,  3)
} else {
      return 5;
    }
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
if (true)
{
return _γ_ieldValue_2;
    } else {
      return 5;
    }
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

if-then-elseif-else no-block return double yield

[
	2,
	3
]

  var send = [,3];
  var expecting = [2, 3];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) return (_γ_ielded=true, _γ_nextId = 1,  2)
else if (false) return (_γ_ielded=true, _γ_nextId = 2,  3)
else return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
return _γ_ieldValue_1;
    else if (false) return (_γ_ielded=true, _γ_nextId = 2,  3)
else return 5;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
if (true)
return _γ_ieldValue_2;
    else return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

elseif yield return double yield

[
	2,
	true
]

  var send = [,true];
  var expecting = [2, true];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) return (_γ_ielded=true, _γ_nextId = 1,  2)
else return (_γ_ielded=true, _γ_nextId = 2, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
return _γ_ieldValue_1;
    else return (_γ_ielded=true, _γ_nextId = 2, undefined)

    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
if (_γ_ieldValue_2) return 3;
    else return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

elseif yield true return double yield

[
	undefined,
	,
	3
]

  var send = [,true];
  var expecting = [undefined, 3];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (false) return (_γ_ielded=true, _γ_nextId = 1,  2)
else return (_γ_ielded=true, _γ_nextId = 2, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
return _γ_ieldValue_1;
    else return (_γ_ielded=true, _γ_nextId = 2, undefined)

    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
if (_γ_ieldValue_2) return 3;
    else return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

elseif yield false return double yield

[
	undefined,
	,
	5
]

  var send = [,false];
  var expecting = [undefined, 5];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (false) return (_γ_ielded=true, _γ_nextId = 1,  2)
else return (_γ_ielded=true, _γ_nextId = 2, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
return _γ_ieldValue_1;
    else return (_γ_ielded=true, _γ_nextId = 2, undefined)

    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
if (_γ_ieldValue_2) return 3;
    else return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nasty double if else, 1

[
	undefined,
	,
	1
]

  var expecting = [undefined, 1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
if (true)
      if (true) return 1;
      else return 2;
    else return 3;
    return 4;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
    if (true)
      if (true) return 1;
      else return 2;
    else return 3;
    return 4;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nasty double if else, 2

[
	undefined,
	,
	4
]

  var expecting = [undefined, 4];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true)
      if (true) return (_γ_ielded=true, _γ_nextId = 1, undefined)
else return 2;
    else return 3;
    return 4;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
if (true)
_γ_ieldValue_1;
      else return 2;
    else return 3;
    return 4;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nasty double if else, 3

[
	undefined,
	,
	4
]

  var expecting = [undefined, 4];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true)
      if (false) return 1;
      else return (_γ_ielded=true, _γ_nextId = 1, undefined)
else return 3;
    return 4;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
if (true)
_γ_ieldValue_1;
    else return 3;
    return 4;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nasty double if else, 4

[
	undefined,
	,
	4
]

  var expecting = [undefined, 4];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (false)
      if (false) return 1;
      else return 2;
    else return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 4;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
_γ_ieldValue_1;
    return 4;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

loop break before

[
	5
]

  var expecting = [5];

  function g(){
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    while (++x < 3) {
      break;
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_18 = true, _γ_broke_18 = false;_γ_whileOnce_18; _γ_whileOnce_18 = false)
{
_γ_ieldValue_1;
    }
    if (!_γ_broke_18) { while (++x < 3) {
      break;
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

loop break after

[
	2,
	5
]

  var expecting = [2, 5];

  function g(){
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 3;
    while (--x > 0) {
      return (_γ_ielded=true, _γ_nextId = 1,  x)
break;
    }
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_20 = true, _γ_broke_20 = false;_γ_whileOnce_20; _γ_whileOnce_20 = false)
{
_γ_ieldValue_1;
      {_γ_broke_20 = true;
break;
};
    }
    if (!_γ_broke_20) { while (--x > 0) {
      return (_γ_ielded=true, _γ_nextId = 1,  x)
break;
    }
    }return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

loop continue before

[
	5
]

  var expecting = [5];

  function g(){
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    while (++x < 3) {
      continue;
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_18 = true, _γ_broke_18 = false;_γ_whileOnce_18; _γ_whileOnce_18 = false)
{
_γ_ieldValue_1;
    }
    if (!_γ_broke_18) { while (++x < 3) {
      continue;
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

loop continue after

[
	undefined,
	,
	undefined,
	,
	5
]

  var expecting = [undefined, undefined, 5];

  function g(){
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    while (++x < 3) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
continue;
    }
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_22 = true, _γ_broke_22 = false;_γ_whileOnce_22; _γ_whileOnce_22 = false)
{
_γ_ieldValue_1;
      break;;
    }
    if (!_γ_broke_22) { while (++x < 3) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
continue;
    }
    }return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double loop continue 1

[
	5
]

  var expecting = [5];

  function g(){
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 3;
    while (--x > 0) {
      continue;
       y = 3;
      while (--y > 0) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_18 = true, _γ_broke_18 = false;_γ_whileOnce_18; _γ_whileOnce_18 = false)
{
for (var _γ_whileOnce_33 = true, _γ_broke_33 = false;_γ_whileOnce_33; _γ_whileOnce_33 = false)
{
_γ_ieldValue_1;
      }
    if (!_γ_broke_33) { while (--y > 0) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }}
    if (!_γ_broke_18) { while (--x > 0) {
      continue;
       y = 3;
      while (--y > 0) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }
    }return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double loop continue 2

[
	5
]

  var expecting = [5];

  function g(){
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    while (++x < 3) {
       y = 0;
      while (++y < 3) {
        continue;
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_18 = true, _γ_broke_18 = false;_γ_whileOnce_18; _γ_whileOnce_18 = false)
{
for (var _γ_whileOnce_31 = true, _γ_broke_31 = false;_γ_whileOnce_31; _γ_whileOnce_31 = false)
{
_γ_ieldValue_1;
      }
    if (!_γ_broke_31) { while (++y < 3) {
        continue;
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }}
    if (!_γ_broke_18) { while (++x < 3) {
       y = 0;
      while (++y < 3) {
        continue;
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }
    }return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double loop continue 3

[
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	5
]

  var expecting = [undefined, undefined, undefined, undefined, 5];

  function g(){
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    while (++x < 3) {
       y = 0;
      while (++y < 3) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
continue;
      }
    }
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_26 = true, _γ_broke_26 = false;_γ_whileOnce_26; _γ_whileOnce_26 = false)
{
for (var _γ_whileOnce_39 = true, _γ_broke_39 = false;_γ_whileOnce_39; _γ_whileOnce_39 = false)
{
_γ_ieldValue_1;
        break;;
      }
    if (!_γ_broke_39) { while (++y < 3) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
continue;
      }
    }}
    if (!_γ_broke_26) { while (++x < 3) {
       y = 0;
      while (++y < 3) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
continue;
      }
    }
    }return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double loop continue 4

[
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	5
]

  var expecting = [undefined, undefined, undefined, undefined, 5];

  function g(){
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    while (++x < 3) {
       y = 0;
      while (++y < 3) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
      continue;
    }
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_26 = true, _γ_broke_26 = false;_γ_whileOnce_26; _γ_whileOnce_26 = false)
{
for (var _γ_whileOnce_39 = true, _γ_broke_39 = false;_γ_whileOnce_39; _γ_whileOnce_39 = false)
{
_γ_ieldValue_1;
      }
      if (!_γ_broke_39) { while (++y < 3) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
      }break;;
    }
    if (!_γ_broke_26) { while (++x < 3) {
       y = 0;
      while (++y < 3) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
      continue;
    }
    }return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double loop break 1

[
	5
]

  var expecting = [5];

  function g(){
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    while (++x < 3) {
      break;
       y = 0;
      while (++y < 3) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_18 = true, _γ_broke_18 = false;_γ_whileOnce_18; _γ_whileOnce_18 = false)
{
for (var _γ_whileOnce_33 = true, _γ_broke_33 = false;_γ_whileOnce_33; _γ_whileOnce_33 = false)
{
_γ_ieldValue_1;
      }
    if (!_γ_broke_33) { while (++y < 3) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }}
    if (!_γ_broke_18) { while (++x < 3) {
      break;
       y = 0;
      while (++y < 3) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }
    }return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double loop break 2

[
	5
]

  var expecting = [5];

  function g(){
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    while (++x < 3) {
       y = 0;
      while (++y < 3) {
        break;
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_18 = true, _γ_broke_18 = false;_γ_whileOnce_18; _γ_whileOnce_18 = false)
{
for (var _γ_whileOnce_31 = true, _γ_broke_31 = false;_γ_whileOnce_31; _γ_whileOnce_31 = false)
{
_γ_ieldValue_1;
      }
    if (!_γ_broke_31) { while (++y < 3) {
        break;
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }}
    if (!_γ_broke_18) { while (++x < 3) {
       y = 0;
      while (++y < 3) {
        break;
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }
    }return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double loop break 3

[
	undefined,
	,
	undefined,
	,
	5
]

  var expecting = [undefined, undefined, 5];

  function g(){
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 3;
    while (--x > 0) {
       y = 3;
      while (--y > 0) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
break;
      }
    }
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_22 = true, _γ_broke_22 = false;_γ_whileOnce_22; _γ_whileOnce_22 = false)
{
for (var _γ_whileOnce_35 = true, _γ_broke_35 = false;_γ_whileOnce_35; _γ_whileOnce_35 = false)
{
_γ_ieldValue_1;
        {_γ_broke_35 = true;
break;
};
      }
    if (!_γ_broke_35) { while (--y > 0) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
break;
      }
    }}
    if (!_γ_broke_22) { while (--x > 0) {
       y = 3;
      while (--y > 0) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
break;
      }
    }
    }return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double loop break 4

[
	undefined,
	,
	undefined,
	,
	5
]

  var expecting = [undefined, undefined, 5];

  function g(){
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 3;
    while (--x > 0) {
       y = 3;
      while (--y > 0) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
      break;
    }
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_22 = true, _γ_broke_22 = false;_γ_whileOnce_22; _γ_whileOnce_22 = false)
{
for (var _γ_whileOnce_35 = true, _γ_broke_35 = false;_γ_whileOnce_35; _γ_whileOnce_35 = false)
{
_γ_ieldValue_1;
      }
      if (!_γ_broke_35) { while (--y > 0) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
      }{_γ_broke_22 = true;
break;
};
    }
    if (!_γ_broke_22) { while (--x > 0) {
       y = 3;
      while (--y > 0) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
      break;
    }
    }return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double yield

[
	undefined,
	,
	undefined,
	,
	undefined,
	
]

  var expecting = [undefined, undefined, undefined];
  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
    return (_γ_ielded=true, _γ_nextId = 2, undefined)

    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested yield <Test disabled>

[
	<Test disabled>
]

chaining yield <Test disabled>

[
	<Test disabled>
]

double yielded sub expression <Test disabled>

[
	<Test disabled>
]

double yield block nested

[
	undefined,
	,
	undefined,
	,
	undefined,
	
]

  var expecting = [undefined, undefined, undefined];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
if (true) {
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
}
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
    if (true) {
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
}
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
_γ_ieldValue_2;
    }
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double yield inner block nested

[
	undefined,
	,
	undefined,
	,
	undefined,
	
]

  var expecting = [undefined, undefined, undefined];

  function g(){
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
if (true) {
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
}
    }
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
_γ_ieldValue_1;
      if (true) {
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
}
    }
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
if (true)
{
_γ_ieldValue_2;
      }
    }
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double yield, nested yield statement with yield

[
	undefined,
	,
	undefined,
	,
	20
]

  var send = [,true]
  var expecting = [undefined, undefined, 20];

  function g(){
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 10;
    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2, undefined)
return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

if (_γ_ieldValue_1) {
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
x = 20;
    }
    return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
_γ_ieldValue_2;
      x = 20;
    }
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested for-in, check key pairs, 1

[
	undefined,
	,
	undefined,
	,
	undefined,
	,
	" "
]

  // while exact order can not be anticipated, all keys should be visited
  // this test checks whether all (unique) key pairs are indeed removed
  // from a string that contains them all.

  var expecting = [undefined, undefined, undefined, ' '];

  function g() {
var s, o1, o2, key1, _γ_key, _γ_keys_58, _γ_expro_58, key2, _γ_key, _γ_keys_68, _γ_expro_68;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     s = ' a:c a:d a:21 b:c b:d b:21 15:c 15:d 15:21 ';
     o1 = {a:true,b:true,15:true};
     o2 = {c:true,d:true,21:true};
      key1 ;
 _γ_key, _γ_keys_58 = [], _γ_expro_58 = ( o1);
for (_γ_key in _γ_expro_58) _γ_keys_58.push(_γ_key);
while (_γ_keys_58.length)
if (_γ_keys_58[0] in _γ_expro_58 && !void( key1  = _γ_keys_58.shift()))
  {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
  key2 ;
 _γ_key, _γ_keys_68 = [], _γ_expro_68 = ( o2);
for (_γ_key in _γ_expro_68) _γ_keys_68.push(_γ_key);
while (_γ_keys_68.length)
if (_γ_keys_68[0] in _γ_expro_68 && !void( key2  = _γ_keys_68.shift()))
  {
        s = s.replace(' '+key1+':'+key2+' ', ' ');
      }
    }
    return s;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_88 = true, _γ_broke_88 = false;_γ_whileOnce_88; _γ_whileOnce_88 = false)
if (true)
{
_γ_ieldValue_1;
        key2 ;
 _γ_key, _γ_keys_68 = [], _γ_expro_68 = ( o2);
for (_γ_key in _γ_expro_68) _γ_keys_68.push(_γ_key);
while (_γ_keys_68.length)
if (_γ_keys_68[0] in _γ_expro_68 && !void( key2  = _γ_keys_68.shift()))
  {
        s = s.replace(' '+key1+':'+key2+' ', ' ');
      }
    }
    if (!_γ_broke_88) { while (_γ_keys_58.length)
if (_γ_keys_58[0] in _γ_expro_58 && !void( key1  = _γ_keys_58.shift()))
  {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
  key2 ;
 _γ_key, _γ_keys_68 = [], _γ_expro_68 = ( o2);
for (_γ_key in _γ_expro_68) _γ_keys_68.push(_γ_key);
while (_γ_keys_68.length)
if (_γ_keys_68[0] in _γ_expro_68 && !void( key2  = _γ_keys_68.shift()))
  {
        s = s.replace(' '+key1+':'+key2+' ', ' ');
      }
    }
    }return s;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested for in, each key only visited once

[
	undefined,
	,
	undefined,
	,
	undefined,
	,
	" a:c a:d a:21 b:c b:d b:21 15:c 15:d 15:21 "
]

  // similar to above, but checks to make sure the inner or outer loop
  // doesn't revisit all keys again (happens if keys cache is refreshed
  // after a yield).

  var expecting = [undefined, undefined, undefined, ' a:c a:d a:21 b:c b:d b:21 15:c 15:d 15:21 '];

  function g() {
var s, o1, o2, key1, _γ_key, _γ_keys_58, _γ_expro_58, key2, _γ_key, _γ_keys_68, _γ_expro_68;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     s = ' a:c a:d a:21 b:c b:d b:21 15:c 15:d 15:21 a:c a:d a:21 b:c b:d b:21 15:c 15:d 15:21 ';
     o1 = {a:true,b:true,15:true};
     o2 = {c:true,d:true,21:true};
      key1 ;
 _γ_key, _γ_keys_58 = [], _γ_expro_58 = ( o1);
for (_γ_key in _γ_expro_58) _γ_keys_58.push(_γ_key);
while (_γ_keys_58.length)
if (_γ_keys_58[0] in _γ_expro_58 && !void( key1  = _γ_keys_58.shift()))
  {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
  key2 ;
 _γ_key, _γ_keys_68 = [], _γ_expro_68 = ( o2);
for (_γ_key in _γ_expro_68) _γ_keys_68.push(_γ_key);
while (_γ_keys_68.length)
if (_γ_keys_68[0] in _γ_expro_68 && !void( key2  = _γ_keys_68.shift()))
  {
        s = s.replace(' '+key1+':'+key2+' ', ' ');
      }
    }
    return s;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_88 = true, _γ_broke_88 = false;_γ_whileOnce_88; _γ_whileOnce_88 = false)
if (true)
{
_γ_ieldValue_1;
        key2 ;
 _γ_key, _γ_keys_68 = [], _γ_expro_68 = ( o2);
for (_γ_key in _γ_expro_68) _γ_keys_68.push(_γ_key);
while (_γ_keys_68.length)
if (_γ_keys_68[0] in _γ_expro_68 && !void( key2  = _γ_keys_68.shift()))
  {
        s = s.replace(' '+key1+':'+key2+' ', ' ');
      }
    }
    if (!_γ_broke_88) { while (_γ_keys_58.length)
if (_γ_keys_58[0] in _γ_expro_58 && !void( key1  = _γ_keys_58.shift()))
  {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
  key2 ;
 _γ_key, _γ_keys_68 = [], _γ_expro_68 = ( o2);
for (_γ_key in _γ_expro_68) _γ_keys_68.push(_γ_key);
while (_γ_keys_68.length)
if (_γ_keys_68[0] in _γ_expro_68 && !void( key2  = _γ_keys_68.shift()))
  {
        s = s.replace(' '+key1+':'+key2+' ', ' ');
      }
    }
    }return s;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested for-in, check key pairs, 2

[
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	" "
]

  // while exact order can not be anticipated, all keys should be visited
  // this test checks whether all (unique) key pairs are indeed removed
  // from a string that contains them all.

  var expecting = [undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, ' '];

  function g() {
var s, o1, o2, key1, _γ_key, _γ_keys_70, _γ_expro_70, key2, _γ_key, _γ_keys_78, _γ_expro_78;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     s = ' a:c a:d a:21 b:c b:d b:21 15:c 15:d 15:21 ';
     o1 = {a:true,b:true,15:true};
     o2 = {c:true,d:true,21:true};
      key1 ;
 _γ_key, _γ_keys_70 = [], _γ_expro_70 = ( o1);
for (_γ_key in _γ_expro_70) _γ_keys_70.push(_γ_key);
while (_γ_keys_70.length)
if (_γ_keys_70[0] in _γ_expro_70 && !void( key1  = _γ_keys_70.shift()))
  {
        key2 ;
 _γ_key, _γ_keys_78 = [], _γ_expro_78 = ( o2);
for (_γ_key in _γ_expro_78) _γ_keys_78.push(_γ_key);
while (_γ_keys_78.length)
if (_γ_keys_78[0] in _γ_expro_78 && !void( key2  = _γ_keys_78.shift()))
  {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
s = s.replace(' '+key1+':'+key2+' ', ' ');
      }
    }
    return s;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_100 = true, _γ_broke_100 = false;_γ_whileOnce_100; _γ_whileOnce_100 = false)
if (true)
{
for (var _γ_whileOnce_158 = true, _γ_broke_158 = false;_γ_whileOnce_158; _γ_whileOnce_158 = false)
if (true)
{
_γ_ieldValue_1;
        s = s.replace(' '+key1+':'+key2+' ', ' ');
      }
    if (!_γ_broke_158) { while (_γ_keys_78.length)
if (_γ_keys_78[0] in _γ_expro_78 && !void( key2  = _γ_keys_78.shift()))
  {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
s = s.replace(' '+key1+':'+key2+' ', ' ');
      }
    }}
    if (!_γ_broke_100) { while (_γ_keys_70.length)
if (_γ_keys_70[0] in _γ_expro_70 && !void( key1  = _γ_keys_70.shift()))
  {
        key2 ;
 _γ_key, _γ_keys_78 = [], _γ_expro_78 = ( o2);
for (_γ_key in _γ_expro_78) _γ_keys_78.push(_γ_key);
while (_γ_keys_78.length)
if (_γ_keys_78[0] in _γ_expro_78 && !void( key2  = _γ_keys_78.shift()))
  {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
s = s.replace(' '+key1+':'+key2+' ', ' ');
      }
    }
    }return s;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested for-in, check key pairs, 3

[
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	" "
]

  // while exact order can not be anticipated, all keys should be visited
  // this test checks whether all (unique) key pairs are indeed removed
  // from a string that contains them all.

  var expecting = [undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, ' '];

  function g() {
var s, o1, o2, key1, _γ_key, _γ_keys_70, _γ_expro_70, key2, _γ_key, _γ_keys_78, _γ_expro_78;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     s = ' a:c a:d a:21 b:c b:d b:21 15:c 15:d 15:21 ';
     o1 = {a:true,b:true,15:true};
     o2 = {c:true,d:true,21:true};
      key1 ;
 _γ_key, _γ_keys_70 = [], _γ_expro_70 = ( o1);
for (_γ_key in _γ_expro_70) _γ_keys_70.push(_γ_key);
while (_γ_keys_70.length)
if (_γ_keys_70[0] in _γ_expro_70 && !void( key1  = _γ_keys_70.shift()))
  {
        key2 ;
 _γ_key, _γ_keys_78 = [], _γ_expro_78 = ( o2);
for (_γ_key in _γ_expro_78) _γ_keys_78.push(_γ_key);
while (_γ_keys_78.length)
if (_γ_keys_78[0] in _γ_expro_78 && !void( key2  = _γ_keys_78.shift()))
  {
        s = s.replace(' '+key1+':'+key2+' ', ' ');
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }
    return s;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_100 = true, _γ_broke_100 = false;_γ_whileOnce_100; _γ_whileOnce_100 = false)
if (true)
{
for (var _γ_whileOnce_158 = true, _γ_broke_158 = false;_γ_whileOnce_158; _γ_whileOnce_158 = false)
if (true)
{
_γ_ieldValue_1;
      }
    if (!_γ_broke_158) { while (_γ_keys_78.length)
if (_γ_keys_78[0] in _γ_expro_78 && !void( key2  = _γ_keys_78.shift()))
  {
        s = s.replace(' '+key1+':'+key2+' ', ' ');
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }}
    if (!_γ_broke_100) { while (_γ_keys_70.length)
if (_γ_keys_70[0] in _γ_expro_70 && !void( key1  = _γ_keys_70.shift()))
  {
        key2 ;
 _γ_key, _γ_keys_78 = [], _γ_expro_78 = ( o2);
for (_γ_key in _γ_expro_78) _γ_keys_78.push(_γ_key);
while (_γ_keys_78.length)
if (_γ_keys_78[0] in _γ_expro_78 && !void( key2  = _γ_keys_78.shift()))
  {
        s = s.replace(' '+key1+':'+key2+' ', ' ');
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }
    }return s;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested for-in, check key pairs, 4

[
	undefined,
	,
	undefined,
	,
	undefined,
	,
	" "
]

  // while exact order can not be anticipated, all keys should be visited
  // this test checks whether all (unique) key pairs are indeed removed
  // from a string that contains them all.

  var expecting = [undefined, undefined, undefined, ' '];

  function g() {
var s, o1, o2, key1, _γ_key, _γ_keys_58, _γ_expro_58, key2, _γ_key, _γ_keys_66, _γ_expro_66;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     s = ' a:c a:d a:21 b:c b:d b:21 15:c 15:d 15:21 ';
     o1 = {a:true,b:true,15:true};
     o2 = {c:true,d:true,21:true};
      key1 ;
 _γ_key, _γ_keys_58 = [], _γ_expro_58 = ( o1);
for (_γ_key in _γ_expro_58) _γ_keys_58.push(_γ_key);
while (_γ_keys_58.length)
if (_γ_keys_58[0] in _γ_expro_58 && !void( key1  = _γ_keys_58.shift()))
  {
        key2 ;
 _γ_key, _γ_keys_66 = [], _γ_expro_66 = ( o2);
for (_γ_key in _γ_expro_66) _γ_keys_66.push(_γ_key);
while (_γ_keys_66.length)
if (_γ_keys_66[0] in _γ_expro_66 && !void( key2  = _γ_keys_66.shift()))
  {
        s = s.replace(' '+key1+':'+key2+' ', ' ');
      }
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    return s;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_88 = true, _γ_broke_88 = false;_γ_whileOnce_88; _γ_whileOnce_88 = false)
if (true)
{
_γ_ieldValue_1;
    }
    if (!_γ_broke_88) { while (_γ_keys_58.length)
if (_γ_keys_58[0] in _γ_expro_58 && !void( key1  = _γ_keys_58.shift()))
  {
        key2 ;
 _γ_key, _γ_keys_66 = [], _γ_expro_66 = ( o2);
for (_γ_key in _γ_expro_66) _γ_keys_66.push(_γ_key);
while (_γ_keys_66.length)
if (_γ_keys_66[0] in _γ_expro_66 && !void( key2  = _γ_keys_66.shift()))
  {
        s = s.replace(' '+key1+':'+key2+' ', ' ');
      }
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    }return s;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

with, yield before

[
	undefined,
	,
	5
]

  var expecting = [undefined, 5];

  function g() {
var o;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
 o = {foo: 5};
    with (_γ_withVar_26 = (o)) {
      return foo;
    }
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
     o = {foo: 5};
    with (_γ_withVar_26 = (o)) {
      return foo;
    }
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

with, yield after

[
	5
]

  var expecting = [5];

  function g() {
var o;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     o = {foo: 5};
    with (_γ_withVar_22 = (o)) {
      return foo;
    }
    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

with arg

[
	5,
	undefined,
	
]

  var expecting = [5, undefined];

  function g() {
var o;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_withVar_24 = undefined;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     o = {foo: 5};
    with (_γ_withVar_24 = (o)) {
      return (_γ_ielded=true, _γ_nextId = 1,  foo)
}
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
with (_γ_withVar_24)
{
_γ_ieldValue_1;
    }
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

with complex

[
	5,
	undefined,
	
]

  var expecting = [5, undefined];

  function g() {
var o, p;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_withVar_30 = undefined;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     o = {foo: 5};
     p = {};
    with (_γ_withVar_30 = (p,o)) {
      return (_γ_ielded=true, _γ_nextId = 1,  foo)
}
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
with (_γ_withVar_30)
{
_γ_ieldValue_1;
    }
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

with after

[
	5,
	6
]

  var expecting = [5, 6];
  function g() {
var o;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_withVar_28 = undefined;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     o = {foo: 5, bar: 6};
    with (_γ_withVar_28 = (o)) {
      return (_γ_ielded=true, _γ_nextId = 1,  foo)
return bar;
    }
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
with (_γ_withVar_28)
{
_γ_ieldValue_1;
      return bar;
    }
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

with(yield)

[
	undefined,
	,
	5
]

  var o = {foo: 5};
  var send = [,o];
  var expecting = [undefined, 5];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

with (_γ_withVar_32 = (_γ_ieldValue_1)) {
      return foo;
    }
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

loop with

[
	undefined,
	,
	5
]

  var expecting = [undefined, 5];
  function g() {
var x, o;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_withVar_34 = undefined;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 5;
     o = {foo: 5};
    while (true) {
      with (_γ_withVar_34 = (o)) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
x = foo; // f1 will not wrap this in a with, causing a problem
      }
      break;
    }
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_29 = true, _γ_broke_29 = false;_γ_whileOnce_29; _γ_whileOnce_29 = false)
{
with (_γ_withVar_34)
{
_γ_ieldValue_1;
        x = foo; // f1 will not wrap this in a with, causing a problem
      }
      {_γ_broke_29 = true;
break;
};
    }
    if (!_γ_broke_29) { while (true) {
      with (_γ_withVar_34 = (o)) {
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
x = foo; // f1 will not wrap this in a with, causing a problem
      }
      break;
    }
    }return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

loop with, double yield

[
	undefined,
	,
	undefined,
	,
	10
]

  var o = {foo: 10};
  var send = [,o];
  var expecting = [undefined, undefined, 10];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_withVar_46 = undefined;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 5;
    while (x < 10) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2, undefined)
}
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_39 = true, _γ_broke_39 = false;_γ_whileOnce_39; _γ_whileOnce_39 = false)
{
with (_γ_withVar_46 = (_γ_ieldValue_1)) {
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
x = foo; // after we fix wrapping, we also need to remember value
      }
    }
    if (!_γ_broke_39) { while (x < 10) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2, undefined)
}
    }return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_39 = true, _γ_broke_39 = false;_γ_whileOnce_39; _γ_whileOnce_39 = false)
{
with (_γ_withVar_46)
{
_γ_ieldValue_2;
        x = foo; // after we fix wrapping, we also need to remember value
      }
    }
    if (!_γ_broke_39) { while (x < 10) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2, undefined)
}
    }return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

loop with double yield and break

[
	undefined,
	,
	undefined,
	,
	5
]

  var o = {foo: 5};
  var send = [,o];
  var expecting = [undefined, undefined, 5];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_withVar_44 = undefined;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 5;
    while (true) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2, undefined)
break;
    }
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_39 = true, _γ_broke_39 = false;_γ_whileOnce_39; _γ_whileOnce_39 = false)
{
with (_γ_withVar_44 = (_γ_ieldValue_1)) {
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
x = foo; // after we fix wrapping, we also need to remember value
      }
      {_γ_broke_39 = true;
break;
};
    }
    if (!_γ_broke_39) { while (true) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2, undefined)
break;
    }
    }return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_39 = true, _γ_broke_39 = false;_γ_whileOnce_39; _γ_whileOnce_39 = false)
{
with (_γ_withVar_44)
{
_γ_ieldValue_2;
        x = foo; // after we fix wrapping, we also need to remember value
      }
      {_γ_broke_39 = true;
break;
};
    }
    if (!_γ_broke_39) { while (true) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2, undefined)
break;
    }
    }return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

eval <Test disabled>

[
	<Test disabled>
]

try yield

[
	undefined,
	,
	undefined,
	
]

  var expecting = [undefined, undefined];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    try {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
} catch (e) {

    }
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
/*1*/try {
_γ_ieldValue_1;
    } catch (e) {

    }
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

catch yield

[
	1
]

  var expecting = [1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    try {
    } catch (e) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
_γ_ieldValue_1;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

catch thrown yield

[
	undefined,
	,
	1
]

  var expecting = [undefined, 1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    try {
      throw 2;
    } catch (e) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
_γ_ieldValue_1;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

catch var yield

[
	2,
	1
]

  var expecting = [2, 1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    try {
      throw 2;
    } catch (e) {
      return (_γ_ielded=true, _γ_nextId = 1,  e)
}
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
_γ_ieldValue_1;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

catch var yield return

[
	2,
	5
]

  var expecting = [2, 5];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    try {
      throw 2;
    } catch (e) {
      return (_γ_ielded=true, _γ_nextId = 1,  e)
return 5;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
_γ_ieldValue_1;
      return 5;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

finally yield <Test disabled>

[
	<Test disabled>
]

switch yield

[
	undefined,
	,
	1
]

  var expecting = [undefined, 1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (_γ_ieldValue_1) {
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

switch yield case 1

[
	undefined,
	,
	1
]

  var send = [,1];
  var expecting = [undefined, 1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (_γ_ieldValue_1) {
      case 1:
        break;
        return 2;
      case 3:
        break;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

switch yield case 3

[
	undefined,
	,
	4
]

  var send = [,3];
  var expecting = [undefined, 4];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (_γ_ieldValue_1) {
      case 1:
        break;
        return 2;
      case 3:
        return 4;
        break;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

case arg yield 1

[
	undefined,
	,
	2
]

  var send = [,1];
  var expecting = [undefined, 2];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (1) {
      case _γ_ieldValue_1:
        return 2;
        break;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

case arg yield 2

[
	undefined,
	,
	1
]

  var send = [,2];
  var expecting = [undefined, 1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (1) {
      case _γ_ieldValue_1:
        return 2;
        break;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

case arg yield fall-through 1

[
	undefined,
	,
	2
]

  var send = [,1];
  var expecting = [undefined, 2];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (1) {
      case _γ_ieldValue_1:
      case 3:
        return 2;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

case arg yield fall-through 2

[
	undefined,
	,
	1
]

  var send = [,2];
  var expecting = [undefined, 1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (1) {
      case _γ_ieldValue_1:
      case 3:
        return 2;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

case arg yield fall-through 3

[
	undefined,
	,
	2
]

  var send = [,1];
  var expecting = [undefined, 2];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (1) {
      case _γ_ieldValue_1:
      case 3:
        return 2;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

case body yield

[
	undefined,
	,
	1
]

  var expecting = [undefined, 1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_switchToken_15 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    switch (1) {
      case 1:
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
break;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_15) { case _γ_switchToken_15:
_γ_ieldValue_1;
        break;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

case body yield fall-through

[
	undefined,
	,
	2
]

  var expecting = [undefined, 2];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_switchToken_15 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    switch (1) {
      case 1:
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
case 3:
        return 2;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_15) { case _γ_switchToken_15:
_γ_ieldValue_1;
      case 3:
        return 2;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

case double yield

[
	undefined,
	,
	undefined,
	,
	5
]

  var expecting = [undefined, undefined, 5];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_switchToken_22 = {}, _γ_switchToken_22 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    switch (1) {
      case 1:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      case 3:
        return 2 + x;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_22) { case _γ_switchToken_22:
_γ_ieldValue_1;
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      case 3:
        return 2 + x;
    }
    return 1;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_22) { case _γ_switchToken_22:
_γ_ieldValue_2;
        ++x;
      case 3:
        return 2 + x;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

case skipping double yield

[
	2
]

  var expecting = [2];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_switchToken_18 = {}, _γ_switchToken_18 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    switch (3) {
      case 1:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      case 3:
        return 2 + x;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_18) { case _γ_switchToken_18:
_γ_ieldValue_1;
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      case 3:
        return 2 + x;
    }
    return 1;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_18) { case _γ_switchToken_18:
_γ_ieldValue_2;
        ++x;
      case 3:
        return 2 + x;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double case yield 1

[
	undefined,
	,
	undefined,
	,
	6
]

  var expecting = [undefined, undefined, 6];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_switchToken_22 = {}, _γ_switchToken_22 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    switch (1) {
      case 1:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
      case 3:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
        return 2 + x;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_22) { case _γ_switchToken_22:
_γ_ieldValue_1;
        ++x;
      case 3:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
        return 2 + x;
    }
    return 1;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_22) { case _γ_switchToken_22:
_γ_ieldValue_2;
        ++x;
        return 2 + x;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

double case yield 1

[
	undefined,
	,
	4
]

  var expecting = [undefined, 4];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_switchToken_20 = {}, _γ_switchToken_20 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    switch (3) {
      case 1:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
      case 3:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
        return 2 + x;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_20) { case _γ_switchToken_20:
_γ_ieldValue_1;
        ++x;
      case 3:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
        return 2 + x;
    }
    return 1;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_20) { case _γ_switchToken_20:
_γ_ieldValue_2;
        ++x;
        return 2 + x;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

default

[
	10
]

  var expecting = [10];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_switchToken_18 = {}, _γ_switchToken_18 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    switch (5) {
      case 1:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
      case 3:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
        return 2 + x;
      default:
        return 10;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_18) { case _γ_switchToken_18:
_γ_ieldValue_1;
        ++x;
      case 3:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
        return 2 + x;
      default:
        return 10;
    }
    return 1;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_18) { case _γ_switchToken_18:
_γ_ieldValue_2;
        ++x;
        return 2 + x;
      default:
        return 10;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

default yield

[
	undefined,
	,
	12
]

  var expecting = [undefined, 12];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3;

    var _γ_switchToken_20 = {}, _γ_switchToken_20 = {}, _γ_switchToken_20 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    switch (5) {
      case 1:
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
case 3:
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
return 2 + x;
      default:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        return 10 + x;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_20) { case _γ_switchToken_20:
_γ_ieldValue_1;
      case 3:
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
return 2 + x;
      default:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        return 10 + x;
    }
    return 1;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_20) { case _γ_switchToken_20:
_γ_ieldValue_2;
        return 2 + x;
      default:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        return 10 + x;
    }
    return 1;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_20) { case _γ_switchToken_20:
_γ_ieldValue_3;
        ++x;
        return 10 + x;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

weird default yield

[
	undefined,
	,
	undefined,
	,
	6
]

  var expecting = [undefined, undefined, 6];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3;

    var _γ_switchToken_22 = {}, _γ_switchToken_22 = {}, _γ_switchToken_22 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    switch (5) {
      case 1:
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
default:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      case 3:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        return 2 + x;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_22) { case _γ_switchToken_22:
_γ_ieldValue_1;
      default:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      case 3:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        return 2 + x;
    }
    return 1;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_22) { case _γ_switchToken_22:
_γ_ieldValue_2;
        ++x;
      case 3:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        return 2 + x;
    }
    return 1;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_22) { case _γ_switchToken_22:
_γ_ieldValue_3;
        ++x;
        return 2 + x;
    }
    return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

multi yields in a loop

[
	undefined,
	,
	undefined,
	,
	1
]

  var expecting = [undefined, undefined, 1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    while (true) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2, undefined)
break;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_17 = true, _γ_broke_17 = false;_γ_whileOnce_17; _γ_whileOnce_17 = false)
{
_γ_ieldValue_1;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
{_γ_broke_17 = true;
break;
};
    }
    if (!_γ_broke_17) { while (true) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2, undefined)
break;
    }
    }return 1;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_17 = true, _γ_broke_17 = false;_γ_whileOnce_17; _γ_whileOnce_17 = false)
{
_γ_ieldValue_2;
      {_γ_broke_17 = true;
break;
};
    }
    if (!_γ_broke_17) { while (true) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2, undefined)
break;
    }
    }return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

multi yields in a nested loop

[
	undefined,
	,
	undefined,
	,
	1
]

  var expecting = [undefined, undefined, 1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    while (true) {
      while (true) {
        break;
      }
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2, undefined)
break;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_17 = true, _γ_broke_17 = false;_γ_whileOnce_17; _γ_whileOnce_17 = false)
{
_γ_ieldValue_1;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
{_γ_broke_17 = true;
break;
};
    }
    if (!_γ_broke_17) { while (true) {
      while (true) {
        break;
      }
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2, undefined)
break;
    }
    }return 1;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_17 = true, _γ_broke_17 = false;_γ_whileOnce_17; _γ_whileOnce_17 = false)
{
_γ_ieldValue_2;
      {_γ_broke_17 = true;
break;
};
    }
    if (!_γ_broke_17) { while (true) {
      while (true) {
        break;
      }
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2, undefined)
break;
    }
    }return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

block yield followed by statement yield 1

[
	undefined,
	,
	1
]

  var send = [,true];
  var expecting = [undefined, 1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (false) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    return (_γ_ielded=true, _γ_nextId = 2, undefined)
return 2;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
_γ_ieldValue_1;
    }
    return (_γ_ielded=true, _γ_nextId = 2, undefined)
return 2;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;

if (_γ_ieldValue_2) {
      return 1
    }
    return 2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

block yield followed by statement yield 2

[
	undefined,
	,
	2
]

  var send = [,false];
  var expecting = [undefined, 2];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (false) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    return (_γ_ielded=true, _γ_nextId = 2, undefined)
return 2;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
_γ_ieldValue_1;
    }
    return (_γ_ielded=true, _γ_nextId = 2, undefined)
return 2;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;

if (_γ_ieldValue_2) {
      return 1
    }
    return 2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

block yield followed by statement yield 3

[
	undefined,
	,
	undefined,
	,
	1
]

  var send = [,,true];
  var expecting = [undefined, undefined, 1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    return (_γ_ielded=true, _γ_nextId = 2, undefined)
return 2;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
_γ_ieldValue_1;
    }
    return (_γ_ielded=true, _γ_nextId = 2, undefined)
return 2;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;

if (_γ_ieldValue_2) {
      return 1
    }
    return 2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

block yield followed by statement yield 4

[
	undefined,
	,
	undefined,
	,
	2
]

  var send = [,,false];
  var expecting = [undefined, undefined, 2];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    return (_γ_ielded=true, _γ_nextId = 2, undefined)
return 2;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
{
_γ_ieldValue_1;
    }
    return (_γ_ielded=true, _γ_nextId = 2, undefined)
return 2;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;

if (_γ_ieldValue_2) {
      return 1
    }
    return 2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement if yield

[
	undefined,
	,
	undefined,
	
]

  var expecting = [undefined, undefined];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

if (_γ_ieldValue_1) ;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement if yield comma before

[
	undefined,
	,
	1
]

  var send = [,false];
  var expecting = [undefined, 1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 2;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

if (_γ_ieldValue_1, true) return 1;
    return 2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement if yield comma after

[
	undefined,
	,
	2
]

  var send = [,false];
  var expecting = [undefined, 2];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 2;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

if (true, _γ_ieldValue_1) return 1;
    return 2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement switch yield

[
	undefined,
	,
	undefined,
	
]

  var expecting = [undefined, undefined];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (_γ_ieldValue_1) {}
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement switch yield comma before

[
	undefined,
	,
	3
]

  var send = [,2];
  var expecting = [undefined, 3];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (_γ_ieldValue_1, 1) {
      case 1:
        return 3;
      case 2:
        return 4;
    }
    return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement switch yield comma after

[
	undefined,
	,
	4
]

  var send = [,2];
  var expecting = [undefined, 4];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (1, _γ_ieldValue_1) {
      case 1:
        return 3;
      case 2:
        return 4;
    }
    return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement case yield

[
	undefined,
	,
	undefined,
	
]

  var expecting = [undefined, undefined];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (true) {
      case _γ_ieldValue_1:
    }
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement case yield comma 1 before

[
	undefined,
	,
	2
]

  var send = [,true];
  var expecting = [undefined, 2];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 2;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (true) {
      case _γ_ieldValue_1,false:
        return 1;
    }
    return 2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement case yield comma 1 after

[
	undefined,
	,
	1
]

  var send = [,true];
  var expecting = [undefined, 1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 2;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (true) {
      case false, _γ_ieldValue_1:
        return 1;
    }
    return 2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement case yield comma 2 before

[
	undefined,
	,
	2
]

  var send = [,false];
  var expecting = [undefined, 2];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 2;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (true) {
      case _γ_ieldValue_1,false:
        return 1;
    }
    return 2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement case yield comma 2 after

[
	undefined,
	,
	2
]

  var send = [,false];
  var expecting = [undefined, 2];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 2;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

switch (true) {
      case false, _γ_ieldValue_1:
        return 1;
    }
    return 2;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement while yield

[
	1,
	2,
	3,
	-2
]

  // yield is special in that it needs to repetitively yield
  var send = [,true,true,false];
  var expecting = [1, 2, 3, -2];

  function g() {
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
     y = 0;
    return (_γ_ielded=true, _γ_nextId = 1,  ++x)
return y;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_42 = true, _γ_broke_42;_γ_whileOnce_42; _γ_whileOnce_42 = false)
if (!(_γ_broke_42 = !(_γ_ieldValue_1))) {
        --y;
    }
    if (!_γ_broke_42) { return (_γ_ielded=true, _γ_nextId = 1,  ++x)
}return y;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement while yield comma first before

[
	1,
	0
]

  // yield is special in that it needs to repetitively yield
  var send = [,true];
  var expecting = [1, 0];

  function g() {
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
     y = 0;
    return (_γ_ielded=true, _γ_nextId = 1,  ++x)
return y;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_33 = true, _γ_broke_33;_γ_whileOnce_33; _γ_whileOnce_33 = false)
if (!(_γ_broke_33 = !(_γ_ieldValue_1, false))) {
        --y;
    }
    if (!_γ_broke_33) { return (_γ_ielded=true, _γ_nextId = 1,  ++x)
}return y;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement while yield comma first after

[
	1,
	2,
	-1
]

  // yield is special in that it needs to repetitively yield
  var send = [,true,false];
  var expecting = [1, 2, -1];

  function g() {
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
     y = 0;
    return (_γ_ielded=true, _γ_nextId = 1,  ++x)
return y;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_38 = true, _γ_broke_38;_γ_whileOnce_38; _γ_whileOnce_38 = false)
if (!(_γ_broke_38 = !(false, _γ_ieldValue_1))) {
        --y;
    }
    if (!_γ_broke_38) { return (_γ_ielded=true, _γ_nextId = 1,  ++x)
}return y;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement while yield comma first before

[
	1,
	0
]

  // yield is special in that it needs to repetitively yield
  var send = [,true,true,false];
  var expecting = [1, 0];

  function g() {
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
     y = 0;
    return (_γ_ielded=true, _γ_nextId = 1,  ++x)
return y;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_37 = true, _γ_broke_37;_γ_whileOnce_37; _γ_whileOnce_37 = false)
if (!(_γ_broke_37 = !(_γ_ieldValue_1, false))) {
        --y;
    }
    if (!_γ_broke_37) { return (_γ_ielded=true, _γ_nextId = 1,  ++x)
}return y;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement while yield comma first after

[
	1,
	2,
	3,
	-2
]

  // yield is special in that it needs to repetitively yield
  var send = [,true,true,false];
  var expecting = [1, 2, 3, -2];

  function g() {
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
     y = 0;
    return (_γ_ielded=true, _γ_nextId = 1,  ++x)
return y;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_42 = true, _γ_broke_42;_γ_whileOnce_42; _γ_whileOnce_42 = false)
if (!(_γ_broke_42 = !(false, _γ_ieldValue_1))) {
        --y;
    }
    if (!_γ_broke_42) { return (_γ_ielded=true, _γ_nextId = 1,  ++x)
}return y;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement return yield

[
	undefined,
	,
	undefined,
	
]

  var expecting = [undefined, undefined];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

return _γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement return yield 5

[
	undefined,
	,
	5
]

  var send = [,5];
  var expecting = [undefined, 5];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

return _γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement return yield comma before

[
	undefined,
	,
	5
]

  var expecting = [undefined, 5];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

return _γ_ieldValue_1, 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement return yield comma after

[
	undefined,
	,
	10
]

  var send = [,10];
  var expecting = [undefined, 10];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

return 5, _γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement throw yield <Test disabled>

[
	<Test disabled>
]

statement throw yield comma before <Test disabled>

[
	<Test disabled>
]

statement throw yield comma after <Test disabled>

[
	<Test disabled>
]

statement var yield

[
	undefined,
	,
	undefined,
	
]

  var expecting = [undefined, undefined];

  function g() {
var foo;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

 foo = _γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement double var yield

[
	undefined,
	,
	15
]

  var send = [,5];
  var expecting = [undefined, 15];

  function g() {
var foo, bar;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return foo + bar;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

 foo = _γ_ieldValue_1, bar = 10;
    return foo + bar;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement for1 yield

[
	undefined,
	,
	undefined,
	
]

  var expecting = [undefined, undefined];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    {return (_γ_ielded=true, _γ_nextId = 1, undefined)
while (false){;
  ;;}}
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
_γ_ieldValue_1;while (false){;
  ;;}}
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement for2 yield

[
	undefined,
	,
	undefined,
	
]

  var send = [,false];
  var expecting = [undefined, undefined];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    {;return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_25 = true, _γ_broke_25;_γ_whileOnce_25; _γ_whileOnce_25 = false)
if (!(_γ_broke_25 = !(_γ_ieldValue_1))){;
  ;;}if (!_γ_broke_25) { return (_γ_ielded=true, _γ_nextId = 1, undefined)
}}
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement for2 yield comma

[
	undefined,
	,
	0
]

  var send = [,false];
  var expecting = [undefined, 0];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    { x=0;return (_γ_ielded=true, _γ_nextId = 1, undefined)
}return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_29 = true, _γ_broke_29;_γ_whileOnce_29; _γ_whileOnce_29 = false)
if (!(_γ_broke_29 = !(_γ_ieldValue_1,false))){;
    ;++x;}if (!_γ_broke_29) { return (_γ_ielded=true, _γ_nextId = 1, undefined)
}}return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement for3 yield

[
	undefined,
	,
	undefined,
	
]

  var send = [,false];
  var expecting = [undefined, undefined];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    { x=true;while (x){;
  ;return (_γ_ielded=true, _γ_nextId = 1, undefined)
}}
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_29 = true, _γ_broke_29 = false;_γ_whileOnce_29; _γ_whileOnce_29 = false)
{
x=_γ_ieldValue_1;}if (!_γ_broke_29) { while (x){;
  ;return (_γ_ielded=true, _γ_nextId = 1, undefined)
}}}
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement for-in-lhs yield <Test disabled>

[
	<Test disabled>
]

statement for-in-rhs yield

[
	undefined,
	,
	undefined,
	
]

  var expecting = [undefined, undefined];

  function g() {
var x, _γ_key, _γ_keys_15, _γ_expro_15;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

      x ;
return (_γ_ielded=true, _γ_nextId = 1, undefined)
for (_γ_key in _γ_expro_15) _γ_keys_15.push(_γ_key);
while (_γ_keys_15.length)
if (_γ_keys_15[0] in _γ_expro_15 && !void( x  = _γ_keys_15.shift()))
 ;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

 _γ_key, _γ_keys_15 = [], _γ_expro_15 = ( _γ_ieldValue_1);
for (_γ_key in _γ_expro_15) _γ_keys_15.push(_γ_key);
while (_γ_keys_15.length)
if (_γ_keys_15[0] in _γ_expro_15 && !void( x  = _γ_keys_15.shift()))
 ;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement do yield

[
	undefined,
	,
	undefined,
	
]

  var send = [,false]
  var expecting = [undefined, undefined];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    { { } return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_25 = true, _γ_broke_25;_γ_whileOnce_25; _γ_whileOnce_25 = false)
if (!(_γ_broke_25 = !(_γ_ieldValue_1))){ }if (!_γ_broke_25) { return (_γ_ielded=true, _γ_nextId = 1, undefined)
}}
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement do yield comma

[
	undefined,
	,
	1
]

  var send = [,true, true, false];
  var expecting = [undefined, 1];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    { { ++x; } return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_38 = true, _γ_broke_38;_γ_whileOnce_38; _γ_whileOnce_38 = false)
if (!(_γ_broke_38 = !(_γ_ieldValue_1, false))){ ++x; }if (!_γ_broke_38) { return (_γ_ielded=true, _γ_nextId = 1, undefined)
}}
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

statement block yield

[
	undefined,
	,
	undefined,
	
]

  var expecting = [undefined, undefined];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    {return (_γ_ielded=true, _γ_nextId = 1, undefined)
}
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
_γ_ieldValue_1;}
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

switch in loop, break out before

[
	1
]

  var expecting = [1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    while (true) {
      break;
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 2;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_13 = true, _γ_broke_13 = false;_γ_whileOnce_13; _γ_whileOnce_13 = false)
{
switch (_γ_ieldValue_1) {
      }
      return 2;
    }
    if (!_γ_broke_13) { while (true) {
      break;
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 2;
    }
    }return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

switch in loop, break in

[
	undefined,
	,
	2
]

  var expecting = [undefined, 2];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    while (true) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 2;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_15 = true, _γ_broke_15 = false;_γ_whileOnce_15; _γ_whileOnce_15 = false)
{
switch (_γ_ieldValue_1) {
        default:
          break;
      }
      return 2;
    }
    if (!_γ_broke_15) { while (true) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 2;
    }
    }return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

switch in loop, break after

[
	undefined,
	,
	1
]

  var expecting = [undefined, 1];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    while (true) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
break;
      return 2;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_15 = true, _γ_broke_15 = false;_γ_whileOnce_15; _γ_whileOnce_15 = false)
{
switch (_γ_ieldValue_1) {
        default:
      }
      {_γ_broke_15 = true;
break;
};
      return 2;
    }
    if (!_γ_broke_15) { while (true) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
break;
      return 2;
    }
    }return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

switch in loop, continue check

[
	undefined,
	,
	1
]

  var expecting = [undefined, 1];

  function g() {
var c;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     c = true;
    while (c) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 2;
    }
    return 1;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_20 = true, _γ_broke_20 = false;_γ_whileOnce_20; _γ_whileOnce_20 = false)
{
switch (_γ_ieldValue_1) {
        default:
          c = false;
          continue;
      }
      return 2;
    }
    if (!_γ_broke_20) { while (c) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
return 2;
    }
    }return 1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

comma statement yield

[
	2,
	undefined,
	
]

  var expecting = [2, undefined];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1,  2)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

true,_γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

comma statement yield in block

[
	2,
	undefined,
	
]

  var expecting = [2, undefined];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    if (true) return (_γ_ielded=true, _γ_nextId = 1,  2)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
if (true)
true,_γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

comma statement yield in block yield 1

[
	undefined,
	,
	2,
	3
]

  var send = [,true,3];
  var expecting = [undefined, 2, 3];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2,  2)
return 4;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

if (_γ_ieldValue_1) return (_γ_ielded=true, _γ_nextId = 2,  2)
return 4;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
return true,_γ_ieldValue_2;
    return 4;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

comma statement yield in block yield 2

[
	undefined,
	,
	4
]

  var send = [,false];
  var expecting = [undefined, 4];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return (_γ_ielded=true, _γ_nextId = 2,  2)
return 4;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

if (_γ_ieldValue_1) return (_γ_ielded=true, _γ_nextId = 2,  2)
return 4;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
if (true)
return true,_γ_ieldValue_2;
    return 4;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

for yields

[
	1,
	2,
	4,
	3,
	2,
	5
]

  var send =      [,undefined, true, undefined, undefined, false];
  var expecting = [ 1,         2,    4,         3,         2,        5];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    {return (_γ_ielded=true, _γ_nextId = 1,  1)
return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}console.log(5);
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
_γ_ieldValue_1;return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}console.log(5);
    return 5;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_43 = true, _γ_broke_43;_γ_whileOnce_43; _γ_whileOnce_43 = false)
if (!(_γ_broke_43 = !( _γ_ieldValue_2))){ return (_γ_ielded=true, _γ_nextId = 3,  4)
; return (_γ_ielded=true, _γ_nextId = 4,  3)
}if (!_γ_broke_43) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}}console.log(5);
    return 5;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_43 = true, _γ_broke_43 = false;_γ_whileOnce_43; _γ_whileOnce_43 = false)
{
_γ_ieldValue_3;
    ; return (_γ_ielded=true, _γ_nextId = 4,  3)
}if (!_γ_broke_43) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}}console.log(5);
    return 5;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_43 = true, _γ_broke_43 = false;_γ_whileOnce_43; _γ_whileOnce_43 = false)
{
_γ_ieldValue_4;}if (!_γ_broke_43) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}}console.log(5);
    return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

for yields as while simple

[
	1,
	2,
	1,
	3
]

  var send = [,true, undefined, false];
  var expecting = [1, 2, 1, 3];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1,  1)
return (_γ_ielded=true, _γ_nextId = 2,  2)
return 3;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_31 = true, _γ_broke_31;_γ_whileOnce_31; _γ_whileOnce_31 = false)
if (!(_γ_broke_31 = !(_γ_ieldValue_1))){
      return (_γ_ielded=true, _γ_nextId = 2,  2)
}
    if (!_γ_broke_31) { return (_γ_ielded=true, _γ_nextId = 1,  1)
return (_γ_ielded=true, _γ_nextId = 2,  2)
}return 3;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_31 = true, _γ_broke_31 = false;_γ_whileOnce_31; _γ_whileOnce_31 = false)
{
_γ_ieldValue_2;
    }
    if (!_γ_broke_31) { return (_γ_ielded=true, _γ_nextId = 1,  1)
return (_γ_ielded=true, _γ_nextId = 2,  2)
}return 3;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

for yields as while single

[
	1,
	2,
	3,
	2,
	5
]

  var send =      [,undefined, true, undefined, undefined, false];
  var expecting = [ 1,         2,    3,         2,         5];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1,  1)
return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  3)
return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
    return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  3)
return 5;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_40 = true, _γ_broke_40;_γ_whileOnce_40; _γ_whileOnce_40 = false)
if (!(_γ_broke_40 = !(_γ_ieldValue_2))){
      return (_γ_ielded=true, _γ_nextId = 3,  3)
}
    if (!_γ_broke_40) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  3)
}return 5;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_40 = true, _γ_broke_40 = false;_γ_whileOnce_40; _γ_whileOnce_40 = false)
{
_γ_ieldValue_3;
    }
    if (!_γ_broke_40) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  3)
}return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

for yields comma 1

[
	1,
	2,
	4,
	3,
	2,
	5
]

  var send =      [,undefined, true, undefined, undefined, false];
  var expecting = [ 1,         2,    4,         3,         2,        5];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    {return (_γ_ielded=true, _γ_nextId = 1,  1)
return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
true,_γ_ieldValue_1;return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}return 5;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_45 = true, _γ_broke_45;_γ_whileOnce_45; _γ_whileOnce_45 = false)
if (!(_γ_broke_45 = !( _γ_ieldValue_2))){ return (_γ_ielded=true, _γ_nextId = 3,  4)
; return (_γ_ielded=true, _γ_nextId = 4,  3)
}if (!_γ_broke_45) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}}return 5;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_45 = true, _γ_broke_45 = false;_γ_whileOnce_45; _γ_whileOnce_45 = false)
{
_γ_ieldValue_3;
    ; return (_γ_ielded=true, _γ_nextId = 4,  3)
}if (!_γ_broke_45) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}}return 5;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_45 = true, _γ_broke_45 = false;_γ_whileOnce_45; _γ_whileOnce_45 = false)
{
_γ_ieldValue_4;}if (!_γ_broke_45) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}}return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

for yields comma 2

[
	1,
	2,
	4,
	3,
	2,
	5
]

  var send =      [,undefined, true, undefined, undefined, false];
  var expecting = [ 1,         2,    4,         3,         2,        5];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    {return (_γ_ielded=true, _γ_nextId = 1,  1)
return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}console.log(5);
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
_γ_ieldValue_1;return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}console.log(5);
    return 5;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_43 = true, _γ_broke_43;_γ_whileOnce_43; _γ_whileOnce_43 = false)
if (!(_γ_broke_43 = !( true,_γ_ieldValue_2))){ return (_γ_ielded=true, _γ_nextId = 3,  4)
; return (_γ_ielded=true, _γ_nextId = 4,  3)
}if (!_γ_broke_43) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}}console.log(5);
    return 5;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_43 = true, _γ_broke_43 = false;_γ_whileOnce_43; _γ_whileOnce_43 = false)
{
_γ_ieldValue_3;
    ; return (_γ_ielded=true, _γ_nextId = 4,  3)
}if (!_γ_broke_43) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}}console.log(5);
    return 5;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_43 = true, _γ_broke_43 = false;_γ_whileOnce_43; _γ_whileOnce_43 = false)
{
_γ_ieldValue_4;}if (!_γ_broke_43) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}}console.log(5);
    return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

for yields comma 3

[
	1,
	2,
	4,
	3,
	2,
	5
]

  var send =      [,undefined, true, undefined, undefined, false];
  var expecting = [ 1,         2,    4,         3,         2,        5];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    {return (_γ_ielded=true, _γ_nextId = 1,  1)
return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}console.log(5);
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
_γ_ieldValue_1;return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}console.log(5);
    return 5;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_43 = true, _γ_broke_43;_γ_whileOnce_43; _γ_whileOnce_43 = false)
if (!(_γ_broke_43 = !( _γ_ieldValue_2))){ return (_γ_ielded=true, _γ_nextId = 3,  4)
; return (_γ_ielded=true, _γ_nextId = 4,  3)
}if (!_γ_broke_43) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}}console.log(5);
    return 5;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_43 = true, _γ_broke_43 = false;_γ_whileOnce_43; _γ_whileOnce_43 = false)
{
_γ_ieldValue_3;
    ; return (_γ_ielded=true, _γ_nextId = 4,  3)
}if (!_γ_broke_43) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}}console.log(5);
    return 5;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_43 = true, _γ_broke_43 = false;_γ_whileOnce_43; _γ_whileOnce_43 = false)
{
true,_γ_ieldValue_4;}if (!_γ_broke_43) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}}console.log(5);
    return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

for yields comma 4

[
	1,
	2,
	4,
	3,
	2,
	5
]

  var send =      [,undefined, true, undefined, undefined, false];
  var expecting = [ 1,         2,    4,         3,         2,        5];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    {return (_γ_ielded=true, _γ_nextId = 1,  1)
return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}console.log(5);
    return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
{
_γ_ieldValue_1;return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}console.log(5);
    return 5;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_43 = true, _γ_broke_43;_γ_whileOnce_43; _γ_whileOnce_43 = false)
if (!(_γ_broke_43 = !( _γ_ieldValue_2))){ return (_γ_ielded=true, _γ_nextId = 3,  4)
; return (_γ_ielded=true, _γ_nextId = 4,  3)
}if (!_γ_broke_43) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}}console.log(5);
    return 5;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_43 = true, _γ_broke_43 = false;_γ_whileOnce_43; _γ_whileOnce_43 = false)
{
true,_γ_ieldValue_3;
    ; return (_γ_ielded=true, _γ_nextId = 4,  3)
}if (!_γ_broke_43) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}}console.log(5);
    return 5;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;
{
for (var _γ_whileOnce_43 = true, _γ_broke_43 = false;_γ_whileOnce_43; _γ_whileOnce_43 = false)
{
_γ_ieldValue_4;}if (!_γ_broke_43) { return (_γ_ielded=true, _γ_nextId = 2,  2)
return (_γ_ielded=true, _γ_nextId = 3,  4)
return (_γ_ielded=true, _γ_nextId = 4,  3)
}}console.log(5);
    return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

switch break

[
	undefined,
	,
	2
]

  var expecting = [undefined, 2];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_switchToken_20 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    switch (1) {
      case 1:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
        break;
      case 2:
        ++x;
        break;
    }
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_20) { case _γ_switchToken_20:
_γ_ieldValue_1;
        ++x;
        break;
      case 2:
        ++x;
        break;
    }
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested switch break before

[
	undefined,
	,
	undefined,
	,
	4
]

  var expecting = [undefined, undefined, 4];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_switchToken_30 = {}, _γ_switchToken_22 = {}, _γ_switchToken_22 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    switch (1) {
      case 1:
        switch (1) {
          case 1:
            ++x;
            return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
            break;
          case 2:
            ++x;
            break;
        }
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
        break;
      case 2:
        ++x;
        break;
    }
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_22) { case _γ_switchToken_22:
switch (_γ_switchToken_30) { case _γ_switchToken_30:
_γ_ieldValue_1;
            ++x;
            break;
          case 2:
            ++x;
            break;
        }
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
        break;
      case 2:
        ++x;
        break;
    }
    return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_22) { case _γ_switchToken_22:
_γ_ieldValue_2;
        ++x;
        break;
      case 2:
        ++x;
        break;
    }
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested switch break after

[
	undefined,
	,
	undefined,
	,
	4
]

  var expecting = [undefined, undefined, 4];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_switchToken_22 = {}, _γ_switchToken_38 = {}, _γ_switchToken_22 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    switch (1) {
      case 1:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
        switch (1) {
          case 1:
            ++x;
            return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
            break;
          case 2:
            ++x;
            break;
        }
        break;
      case 2:
        ++x;
        break;
    }
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_22) { case _γ_switchToken_22:
_γ_ieldValue_1;
        ++x;
        switch (1) {
          case 1:
            ++x;
            return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
            break;
          case 2:
            ++x;
            break;
        }
        break;
      case 2:
        ++x;
        break;
    }
    return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_22) { case _γ_switchToken_22:
switch (_γ_switchToken_38) { case _γ_switchToken_38:
_γ_ieldValue_2;
            ++x;
            break;
          case 2:
            ++x;
            break;
        }
        break;
      case 2:
        ++x;
        break;
    }
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested loops break

[
	undefined,
	,
	4
]

  var expecting = [undefined, 4];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    while (true) {
        ++x;
        while (true) {
          ++x;
          return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
          break;
          x += 10;
        }
        ++x;
        break;
        x += 100;
    }
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_20 = true, _γ_broke_20 = false;_γ_whileOnce_20; _γ_whileOnce_20 = false)
{
for (var _γ_whileOnce_28 = true, _γ_broke_28 = false;_γ_whileOnce_28; _γ_whileOnce_28 = false)
{
_γ_ieldValue_1;
          ++x;
          {_γ_broke_28 = true;
break;
};
          x += 10;
        }
        if (!_γ_broke_28) { while (true) {
          ++x;
          return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
          break;
          x += 10;
        }
        }++x;
        {_γ_broke_20 = true;
break;
};
        x += 100;
    }
    if (!_γ_broke_20) { while (true) {
        ++x;
        while (true) {
          ++x;
          return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
          break;
          x += 10;
        }
        ++x;
        break;
        x += 100;
    }
    }return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

funcexpr in yield function

[
	undefined,
	,
	5
]

  var expecting = [undefined, 5];

  function g() {
var f;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
 f = function(){ return 5; };
    return f();
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
     f = function(){ return 5; };
    return f();
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

yielding a function literal

[
	function(){},
	undefined,
	
]

  var expecting = ['to be replaced', undefined];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1,  expecting[0] = function(){})

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

IIF yield

[
	undefined,
	,
	10
]

  var send = [,5];
  var expecting = [undefined, 10];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

return (function(n){ return n*2; })(_γ_ieldValue_1);
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

IIF yield, no parens

[
	undefined,
	,
	10
]

  var send = [,5];
  var expecting = [undefined, 10];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

return function(n){ return n*2; }(_γ_ieldValue_1);
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

break in while, double yield

[
	undefined,
	,
	undefined,
	,
	3
]

  var send = [,5];
  var expecting = [undefined, undefined, 3];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      break;
      x = -400;
    }
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_30 = true, _γ_broke_30 = false;_γ_whileOnce_30; _γ_whileOnce_30 = false)
{
_γ_ieldValue_1;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      {_γ_broke_30 = true;
break;
};
      x = -400;
    }
    if (!_γ_broke_30) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      break;
      x = -400;
    }
    }return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_30 = true, _γ_broke_30 = false;_γ_whileOnce_30; _γ_whileOnce_30 = false)
{
_γ_ieldValue_2;
      ++x;
      {_γ_broke_30 = true;
break;
};
      x = -400;
    }
    if (!_γ_broke_30) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      break;
      x = -400;
    }
    }return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

break in while, preceeding yield

[
	undefined,
	,
	2
]

  var send = [,5];
  var expecting = [undefined, 2];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
 x = 0;
    while (true) {
      ++x;
      break;
      x = -400;
    }
    ++x;
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
     x = 0;
    while (true) {
      ++x;
      {_γ_broke_30 = true;
break;
};
      x = -400;
    }
    ++x;
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

break in while, succeeding yield

[
	undefined,
	,
	2
]

  var send = [,5];
  var expecting = [undefined, 2];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    while (true) {
      ++x;
      break;
      x = -400;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 1, undefined)
return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

break in while, in and after yield

[
	undefined,
	,
	undefined,
	,
	5
]

  // tests that appending a loop after a partial loop only happens if the yield happens in/before that loop
  var send = [,5];
  var expecting = [undefined, undefined, 5];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    while (true) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
break;
    }
    return (_γ_ielded=true, _γ_nextId = 2, undefined)
return 5;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_25 = true, _γ_broke_25 = false;_γ_whileOnce_25; _γ_whileOnce_25 = false)
{
_γ_ieldValue_1;
      {_γ_broke_25 = true;
break;
};
    }
    if (!_γ_broke_25) { while (true) {
      return (_γ_ielded=true, _γ_nextId = 1, undefined)
break;
    }
    }return (_γ_ielded=true, _γ_nextId = 2, undefined)
return 5;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_2;
    return 5;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

break in while, multi yield

[
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	4
]

  var send = [,5];
  var expecting = [undefined, undefined, undefined, undefined, 4];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
 x = 0;
    while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
      break;
      x = -400;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 4, undefined)
return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
     x = 0;
    while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
      {_γ_broke_36 = true;
break;
};
      x = -400;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 4, undefined)
return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_36 = true, _γ_broke_36 = false;_γ_whileOnce_36; _γ_whileOnce_36 = false)
{
_γ_ieldValue_2;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
      {_γ_broke_36 = true;
break;
};
      x = -400;
    }
    if (!_γ_broke_36) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
      break;
      x = -400;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 4, undefined)
return x;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_36 = true, _γ_broke_36 = false;_γ_whileOnce_36; _γ_whileOnce_36 = false)
{
_γ_ieldValue_3;
      ++x;
      {_γ_broke_36 = true;
break;
};
      x = -400;
    }
    if (!_γ_broke_36) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
      break;
      x = -400;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 4, undefined)
return x;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_4;
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

switch in loop break

[
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	7
]

  var send = [,5];
  var expecting = [undefined, undefined, undefined, undefined, undefined, 7];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4, _γ_ieldValue_5;

    var _γ_switchToken_51 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
 x = 0;
    while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      switch (1) {
        case 1:
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          break;
          x = -100;
        case 2:
          x = -200;
          break;
          x = -300;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
      break;
      x = -400;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
     x = 0;
    while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      switch (1) {
        case 1:
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          {_γ_broke_38 = true;
break;
};
          x = -100;
        case 2:
          x = -200;
          {_γ_broke_38 = true;
break;
};
          x = -300;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
      {_γ_broke_38 = true;
break;
};
      x = -400;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_38 = true, _γ_broke_38 = false;_γ_whileOnce_38; _γ_whileOnce_38 = false)
{
_γ_ieldValue_2;
      ++x;
      switch (1) {
        case 1:
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          {_γ_broke_38 = true;
break;
};
          x = -100;
        case 2:
          x = -200;
          {_γ_broke_38 = true;
break;
};
          x = -300;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
      {_γ_broke_38 = true;
break;
};
      x = -400;
    }
    if (!_γ_broke_38) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      switch (1) {
        case 1:
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          break;
          x = -100;
        case 2:
          x = -200;
          break;
          x = -300;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
      break;
      x = -400;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_38 = true, _γ_broke_38 = false;_γ_whileOnce_38; _γ_whileOnce_38 = false)
{
switch (_γ_switchToken_51) { case _γ_switchToken_51:
_γ_ieldValue_3;
          ++x;
          {_γ_broke_38 = true;
break;
};
          x = -100;
        case 2:
          x = -200;
          {_γ_broke_38 = true;
break;
};
          x = -300;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
      {_γ_broke_38 = true;
break;
};
      x = -400;
    }
    if (!_γ_broke_38) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      switch (1) {
        case 1:
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          break;
          x = -100;
        case 2:
          x = -200;
          break;
          x = -300;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
      break;
      x = -400;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_38 = true, _γ_broke_38 = false;_γ_whileOnce_38; _γ_whileOnce_38 = false)
{
_γ_ieldValue_4;
      ++x;
      {_γ_broke_38 = true;
break;
};
      x = -400;
    }
    if (!_γ_broke_38) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      switch (1) {
        case 1:
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          break;
          x = -100;
        case 2:
          x = -200;
          break;
          x = -300;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
      break;
      x = -400;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[5] = function _γ_f5(_γ_ieldValue){
_γ_ieldValue_5 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_5;
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

switch in loop continue break

[
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	13
]

  var expecting = [undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, 13];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4, _γ_ieldValue_5;

    var _γ_switchToken_49 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)
 x = 0;
    while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      switch (1) {
        case 1:
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          break;
          x = -100;
        case 2:
          x = -200;
          break;
          x = -300;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;

      if (x < 10) continue;

      break;
      x = -400;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
     x = 0;
    while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      switch (1) {
        case 1:
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          {_γ_broke_36 = true;
break;
};
          x = -100;
        case 2:
          x = -200;
          {_γ_broke_36 = true;
break;
};
          x = -300;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;

      if (x < 10) continue;;

      {_γ_broke_36 = true;
break;
};
      x = -400;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_36 = true, _γ_broke_36 = false;_γ_whileOnce_36; _γ_whileOnce_36 = false)
{
_γ_ieldValue_2;
      ++x;
      switch (1) {
        case 1:
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          {_γ_broke_36 = true;
break;
};
          x = -100;
        case 2:
          x = -200;
          {_γ_broke_36 = true;
break;
};
          x = -300;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;

      if (x < 10) break;;

      {_γ_broke_36 = true;
break;
};
      x = -400;
    }
    if (!_γ_broke_36) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      switch (1) {
        case 1:
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          break;
          x = -100;
        case 2:
          x = -200;
          break;
          x = -300;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;

      if (x < 10) continue;

      break;
      x = -400;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_36 = true, _γ_broke_36 = false;_γ_whileOnce_36; _γ_whileOnce_36 = false)
{
switch (_γ_switchToken_49) { case _γ_switchToken_49:
_γ_ieldValue_3;
          ++x;
          {_γ_broke_36 = true;
break;
};
          x = -100;
        case 2:
          x = -200;
          {_γ_broke_36 = true;
break;
};
          x = -300;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;

      if (x < 10) break;;

      {_γ_broke_36 = true;
break;
};
      x = -400;
    }
    if (!_γ_broke_36) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      switch (1) {
        case 1:
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          break;
          x = -100;
        case 2:
          x = -200;
          break;
          x = -300;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;

      if (x < 10) continue;

      break;
      x = -400;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_36 = true, _γ_broke_36 = false;_γ_whileOnce_36; _γ_whileOnce_36 = false)
{
_γ_ieldValue_4;
      ++x;

      if (x < 10) break;;

      {_γ_broke_36 = true;
break;
};
      x = -400;
    }
    if (!_γ_broke_36) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
      switch (1) {
        case 1:
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          break;
          x = -100;
        case 2:
          x = -200;
          break;
          x = -300;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;

      if (x < 10) continue;

      break;
      x = -400;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[5] = function _γ_f5(_γ_ieldValue){
_γ_ieldValue_5 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_5;
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

loop in switch break

[
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	7
]

  var expecting = [undefined, undefined, undefined, undefined, 7];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4, _γ_ieldValue_5;

    var _γ_switchToken_26 = {}, _γ_switchToken_26 = {}, _γ_switchToken_26 = {}, _γ_switchToken_26 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    switch (1) {
      case 0:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
        break;
      case 1:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
        while (true) {
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          break;
        }
        ++x;
        return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
        break;
        x = -100;
      case 2:
        x = -200;
        break;
        x = -300;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_26) { case _γ_switchToken_26:
_γ_ieldValue_1;
        ++x;
        break;
      case 1:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
        while (true) {
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          {_γ_broke_55 = true;
break;
};
        }
        ++x;
        return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
        break;
        x = -100;
      case 2:
        x = -200;
        break;
        x = -300;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_26) { case _γ_switchToken_26:
_γ_ieldValue_2;
        ++x;
        while (true) {
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          {_γ_broke_55 = true;
break;
};
        }
        ++x;
        return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
        break;
        x = -100;
      case 2:
        x = -200;
        break;
        x = -300;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_26) { case _γ_switchToken_26:
for (var _γ_whileOnce_55 = true, _γ_broke_55 = false;_γ_whileOnce_55; _γ_whileOnce_55 = false)
{
_γ_ieldValue_3;
          ++x;
          {_γ_broke_55 = true;
break;
};
        }
        if (!_γ_broke_55) { while (true) {
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          break;
        }
        }++x;
        return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
        break;
        x = -100;
      case 2:
        x = -200;
        break;
        x = -300;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_26) { case _γ_switchToken_26:
_γ_ieldValue_4;
        ++x;
        break;
        x = -100;
      case 2:
        x = -200;
        break;
        x = -300;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[5] = function _γ_f5(_γ_ieldValue){
_γ_ieldValue_5 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_5;
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

loop in switch break continue

[
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	9
]

  var expecting = [undefined, undefined, undefined, undefined, undefined, 9];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4, _γ_ieldValue_5;

    var _γ_switchToken_28 = {}, _γ_switchToken_28 = {}, _γ_switchToken_28 = {}, _γ_switchToken_28 = {};

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 0;
    switch (1) {
      case 0:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
        break;
      case 1:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
        while (true) {
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          if (x < 5) continue;
          break;
        }
        ++x;
        return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
        break;
        x = -100;
      case 2:
        x = -200;
        break;
        x = -300;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_28) { case _γ_switchToken_28:
_γ_ieldValue_1;
        ++x;
        break;
      case 1:
        ++x;
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
        while (true) {
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          if (x < 5) continue;;
          {_γ_broke_57 = true;
break;
};
        }
        ++x;
        return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
        break;
        x = -100;
      case 2:
        x = -200;
        break;
        x = -300;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_28) { case _γ_switchToken_28:
_γ_ieldValue_2;
        ++x;
        while (true) {
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          if (x < 5) continue;;
          {_γ_broke_57 = true;
break;
};
        }
        ++x;
        return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
        break;
        x = -100;
      case 2:
        x = -200;
        break;
        x = -300;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_28) { case _γ_switchToken_28:
for (var _γ_whileOnce_57 = true, _γ_broke_57 = false;_γ_whileOnce_57; _γ_whileOnce_57 = false)
{
_γ_ieldValue_3;
          ++x;
          if (x < 5) break;;
          {_γ_broke_57 = true;
break;
};
        }
        if (!_γ_broke_57) { while (true) {
          ++x;
          return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
          if (x < 5) continue;
          break;
        }
        }++x;
        return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
        break;
        x = -100;
      case 2:
        x = -200;
        break;
        x = -300;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;
switch (_γ_switchToken_28) { case _γ_switchToken_28:
_γ_ieldValue_4;
        ++x;
        break;
        x = -100;
      case 2:
        x = -200;
        break;
        x = -300;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
return x;
  
    };

    _γ_funcs[5] = function _γ_f5(_γ_ieldValue){
_γ_ieldValue_5 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_5;
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested loop break, multi yields, 1

[
	undefined,
	,
	undefined,
	,
	5
]

  var expecting = [undefined, undefined, 5];

  function g() {
var x, x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4, _γ_ieldValue_5;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 1;
    return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
    while (true) {
      ++x;
      break;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       x = 0;
      while (x < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
    ++x;
    while (true) {
      ++x;
      {_γ_broke_27 = true;
break;
};
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       x = 0;
      while (x < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_27 = true, _γ_broke_27 = false;_γ_whileOnce_27; _γ_whileOnce_27 = false)
{
_γ_ieldValue_2;
      ++x;
       x = 0;
      while (x < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    if (!_γ_broke_27) { while (true) {
      ++x;
      break;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       x = 0;
      while (x < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_27 = true, _γ_broke_27 = false;_γ_whileOnce_27; _γ_whileOnce_27 = false)
{
for (var _γ_whileOnce_50 = true, _γ_broke_50 = false;_γ_whileOnce_50; _γ_whileOnce_50 = false)
{
_γ_ieldValue_3;
        ++x;
      }
      if (!_γ_broke_50) { while (x < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
      }
      }++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    if (!_γ_broke_27) { while (true) {
      ++x;
      break;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       x = 0;
      while (x < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_27 = true, _γ_broke_27 = false;_γ_whileOnce_27; _γ_whileOnce_27 = false)
{
_γ_ieldValue_4;
      ++x;
    }
    if (!_γ_broke_27) { while (true) {
      ++x;
      break;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       x = 0;
      while (x < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[5] = function _γ_f5(_γ_ieldValue){
_γ_ieldValue_5 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_5;
    ++x;
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested loop break, multi yields, 2

[
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	17
]

  var expecting = [undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, 17];

  function g() {
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4, _γ_ieldValue_5;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 1;
    return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
    while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        ++y;
      }
      ++x;
      break;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
    ++x;
    while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        ++y;
      }
      ++x;
      {_γ_broke_39 = true;
break;
};
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_39 = true, _γ_broke_39 = false;_γ_whileOnce_39; _γ_whileOnce_39 = false)
{
_γ_ieldValue_2;
      ++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        ++y;
      }
      ++x;
      {_γ_broke_39 = true;
break;
};
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    if (!_γ_broke_39) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        ++y;
      }
      ++x;
      break;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_39 = true, _γ_broke_39 = false;_γ_whileOnce_39; _γ_whileOnce_39 = false)
{
for (var _γ_whileOnce_57 = true, _γ_broke_57 = false;_γ_whileOnce_57; _γ_whileOnce_57 = false)
{
_γ_ieldValue_3;
        ++x;
        ++y;
      }
      if (!_γ_broke_57) { while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        ++y;
      }
      }++x;
      {_γ_broke_39 = true;
break;
};
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    if (!_γ_broke_39) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        ++y;
      }
      ++x;
      break;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_39 = true, _γ_broke_39 = false;_γ_whileOnce_39; _γ_whileOnce_39 = false)
{
_γ_ieldValue_4;
      ++x;
    }
    if (!_γ_broke_39) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        ++y;
      }
      ++x;
      break;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[5] = function _γ_f5(_γ_ieldValue){
_γ_ieldValue_5 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_5;
    ++x;
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested loop break, multi yields, 3

[
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	9
]

  var expecting = [undefined, undefined, undefined, undefined, 9];

  function g() {
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4, _γ_ieldValue_5;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 1;
    return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
    while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        break;
        ++y;
      }
      ++x;
      break;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
    ++x;
    while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        {_γ_broke_49 = true;
break;
};
        ++y;
      }
      ++x;
      {_γ_broke_31 = true;
break;
};
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_31 = true, _γ_broke_31 = false;_γ_whileOnce_31; _γ_whileOnce_31 = false)
{
_γ_ieldValue_2;
      ++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        {_γ_broke_49 = true;
break;
};
        ++y;
      }
      ++x;
      {_γ_broke_31 = true;
break;
};
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    if (!_γ_broke_31) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        break;
        ++y;
      }
      ++x;
      break;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_31 = true, _γ_broke_31 = false;_γ_whileOnce_31; _γ_whileOnce_31 = false)
{
for (var _γ_whileOnce_49 = true, _γ_broke_49 = false;_γ_whileOnce_49; _γ_whileOnce_49 = false)
{
_γ_ieldValue_3;
        ++x;
        {_γ_broke_49 = true;
break;
};
        ++y;
      }
      if (!_γ_broke_49) { while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        break;
        ++y;
      }
      }++x;
      {_γ_broke_31 = true;
break;
};
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    if (!_γ_broke_31) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        break;
        ++y;
      }
      ++x;
      break;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_31 = true, _γ_broke_31 = false;_γ_whileOnce_31; _γ_whileOnce_31 = false)
{
_γ_ieldValue_4;
      ++x;
    }
    if (!_γ_broke_31) { while (true) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        break;
        ++y;
      }
      ++x;
      break;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[5] = function _γ_f5(_γ_ieldValue){
_γ_ieldValue_5 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_5;
    ++x;
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested loop break, multi yields, 3

[
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	undefined,
	,
	10
]

  var expecting = [undefined, undefined, undefined, undefined, undefined, 10];

  function g() {
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4, _γ_ieldValue_5;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 1;
    return (_γ_ielded=true, _γ_nextId = 1, undefined)
++x;
    while (x < 6) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        break;
        ++y;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
    ++x;
    while (x < 6) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        {_γ_broke_53 = true;
break;
};
        ++y;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_33 = true, _γ_broke_33 = false;_γ_whileOnce_33; _γ_whileOnce_33 = false)
{
_γ_ieldValue_2;
      ++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        {_γ_broke_53 = true;
break;
};
        ++y;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    if (!_γ_broke_33) { while (x < 6) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        break;
        ++y;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_33 = true, _γ_broke_33 = false;_γ_whileOnce_33; _γ_whileOnce_33 = false)
{
for (var _γ_whileOnce_53 = true, _γ_broke_53 = false;_γ_whileOnce_53; _γ_whileOnce_53 = false)
{
_γ_ieldValue_3;
        ++x;
        {_γ_broke_53 = true;
break;
};
        ++y;
      }
      if (!_γ_broke_53) { while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        break;
        ++y;
      }
      }++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    if (!_γ_broke_33) { while (x < 6) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        break;
        ++y;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_33 = true, _γ_broke_33 = false;_γ_whileOnce_33; _γ_whileOnce_33 = false)
{
_γ_ieldValue_4;
      ++x;
    }
    if (!_γ_broke_33) { while (x < 6) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2, undefined)
++x;
       y = 0;
      while (y < 5) {
        ++x;
        return (_γ_ielded=true, _γ_nextId = 3, undefined)
++x;
        break;
        ++y;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4, undefined)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5, undefined)
++x;
    return x;
  
    };

    _γ_funcs[5] = function _γ_f5(_γ_ieldValue){
_γ_ieldValue_5 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_5;
    ++x;
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested loop continue regression

[
	undefined,
	,
	6
]

  var expecting = [undefined, 6];

  function g() {
var x;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 1;
    return (_γ_ielded=true, _γ_nextId = 1, undefined)
while (x < 6) {
      ++x;
      continue;
      while (y < 5) {
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
}
    }
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
    while (x < 6) {
      ++x;
      continue;;
      while (y < 5) {
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
}
    }
    return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_22 = true, _γ_broke_22 = false;_γ_whileOnce_22; _γ_whileOnce_22 = false)
{
for (var _γ_whileOnce_34 = true, _γ_broke_34 = false;_γ_whileOnce_34; _γ_whileOnce_34 = false)
{
_γ_ieldValue_2;
      }
    if (!_γ_broke_34) { while (y < 5) {
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
}
    }}
    if (!_γ_broke_22) { while (x < 6) {
      ++x;
      continue;
      while (y < 5) {
        return (_γ_ielded=true, _γ_nextId = 2, undefined)
}
    }
    }return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested loop continue, multi yields, 3

[
	1,
	2,
	3,
	3,
	3,
	4,
	5,
	16
]

  var expecting = [1, 2, 3, 3, 3, 4, 5, 16];

  function g() {
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4, _γ_ieldValue_5;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 1;
    return (_γ_ielded=true, _γ_nextId = 1,  1)
++x;
    while (x < 6) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2,  2)
++x;
       y = 0;
      while (y < 5) {
        ++y;
        ++x;
        if (y < 3) continue;
        return (_γ_ielded=true, _γ_nextId = 3,  3)
++x;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4,  4)
++x;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5,  5)
++x;
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
    ++x;
    while (x < 6) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2,  2)
++x;
       y = 0;
      while (y < 5) {
        ++y;
        ++x;
        if (y < 3) continue;;
        return (_γ_ielded=true, _γ_nextId = 3,  3)
++x;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4,  4)
++x;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5,  5)
++x;
    return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_38 = true, _γ_broke_38 = false;_γ_whileOnce_38; _γ_whileOnce_38 = false)
{
_γ_ieldValue_2;
      ++x;
       y = 0;
      while (y < 5) {
        ++y;
        ++x;
        if (y < 3) continue;;
        return (_γ_ielded=true, _γ_nextId = 3,  3)
++x;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4,  4)
++x;
    }
    if (!_γ_broke_38) { while (x < 6) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2,  2)
++x;
       y = 0;
      while (y < 5) {
        ++y;
        ++x;
        if (y < 3) continue;
        return (_γ_ielded=true, _γ_nextId = 3,  3)
++x;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4,  4)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5,  5)
++x;
    return x;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_38 = true, _γ_broke_38 = false;_γ_whileOnce_38; _γ_whileOnce_38 = false)
{
for (var _γ_whileOnce_59 = true, _γ_broke_59 = false;_γ_whileOnce_59; _γ_whileOnce_59 = false)
{
_γ_ieldValue_3;
        ++x;
      }
      if (!_γ_broke_59) { while (y < 5) {
        ++y;
        ++x;
        if (y < 3) continue;
        return (_γ_ielded=true, _γ_nextId = 3,  3)
++x;
      }
      }++x;
      return (_γ_ielded=true, _γ_nextId = 4,  4)
++x;
    }
    if (!_γ_broke_38) { while (x < 6) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2,  2)
++x;
       y = 0;
      while (y < 5) {
        ++y;
        ++x;
        if (y < 3) continue;
        return (_γ_ielded=true, _γ_nextId = 3,  3)
++x;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4,  4)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5,  5)
++x;
    return x;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_38 = true, _γ_broke_38 = false;_γ_whileOnce_38; _γ_whileOnce_38 = false)
{
_γ_ieldValue_4;
      ++x;
    }
    if (!_γ_broke_38) { while (x < 6) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2,  2)
++x;
       y = 0;
      while (y < 5) {
        ++y;
        ++x;
        if (y < 3) continue;
        return (_γ_ielded=true, _γ_nextId = 3,  3)
++x;
      }
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4,  4)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5,  5)
++x;
    return x;
  
    };

    _γ_funcs[5] = function _γ_f5(_γ_ieldValue){
_γ_ieldValue_5 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_5;
    ++x;
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

nested loop double continue, multi yields, 3

[
	1,
	2,
	3,
	3,
	3,
	5,
	14
]

  var expecting = [1, 2, 3, 3, 3, 5, 14];

  function g() {
var x, y;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1, _γ_ieldValue_2, _γ_ieldValue_3, _γ_ieldValue_4, _γ_ieldValue_5;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

     x = 1;
    return (_γ_ielded=true, _γ_nextId = 1,  1)
++x;
    while (x < 6) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2,  2)
++x;
       y = 0;
      while (y < 5) {
        ++y;
        ++x;
        if (y < 3) continue;
        return (_γ_ielded=true, _γ_nextId = 3,  3)
++x;
      }
      if (x > 3) continue;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4,  4)
++x;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5,  5)
++x;
    return x;
  
      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_1;
    ++x;
    while (x < 6) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2,  2)
++x;
       y = 0;
      while (y < 5) {
        ++y;
        ++x;
        if (y < 3) continue;;
        return (_γ_ielded=true, _γ_nextId = 3,  3)
++x;
      }
      if (x > 3) continue;;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4,  4)
++x;
    }
    ++x;
    return (_γ_ielded=true, _γ_nextId = 5,  5)
++x;
    return x;
  
    };

    _γ_funcs[2] = function _γ_f2(_γ_ieldValue){
_γ_ieldValue_2 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_36 = true, _γ_broke_36 = false;_γ_whileOnce_36; _γ_whileOnce_36 = false)
{
_γ_ieldValue_2;
      ++x;
       y = 0;
      while (y < 5) {
        ++y;
        ++x;
        if (y < 3) continue;;
        return (_γ_ielded=true, _γ_nextId = 3,  3)
++x;
      }
      if (x > 3) break;;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4,  4)
++x;
    }
    if (!_γ_broke_36) { while (x < 6) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2,  2)
++x;
       y = 0;
      while (y < 5) {
        ++y;
        ++x;
        if (y < 3) continue;
        return (_γ_ielded=true, _γ_nextId = 3,  3)
++x;
      }
      if (x > 3) continue;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4,  4)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5,  5)
++x;
    return x;
  
    };

    _γ_funcs[3] = function _γ_f3(_γ_ieldValue){
_γ_ieldValue_3 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_36 = true, _γ_broke_36 = false;_γ_whileOnce_36; _γ_whileOnce_36 = false)
{
for (var _γ_whileOnce_57 = true, _γ_broke_57 = false;_γ_whileOnce_57; _γ_whileOnce_57 = false)
{
_γ_ieldValue_3;
        ++x;
      }
      if (!_γ_broke_57) { while (y < 5) {
        ++y;
        ++x;
        if (y < 3) continue;
        return (_γ_ielded=true, _γ_nextId = 3,  3)
++x;
      }
      }if (x > 3) break;;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4,  4)
++x;
    }
    if (!_γ_broke_36) { while (x < 6) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2,  2)
++x;
       y = 0;
      while (y < 5) {
        ++y;
        ++x;
        if (y < 3) continue;
        return (_γ_ielded=true, _γ_nextId = 3,  3)
++x;
      }
      if (x > 3) continue;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4,  4)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5,  5)
++x;
    return x;
  
    };

    _γ_funcs[4] = function _γ_f4(_γ_ieldValue){
_γ_ieldValue_4 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_36 = true, _γ_broke_36 = false;_γ_whileOnce_36; _γ_whileOnce_36 = false)
{
_γ_ieldValue_4;
      ++x;
    }
    if (!_γ_broke_36) { while (x < 6) {
      ++x;
      return (_γ_ielded=true, _γ_nextId = 2,  2)
++x;
       y = 0;
      while (y < 5) {
        ++y;
        ++x;
        if (y < 3) continue;
        return (_γ_ielded=true, _γ_nextId = 3,  3)
++x;
      }
      if (x > 3) continue;
      ++x;
      return (_γ_ielded=true, _γ_nextId = 4,  4)
++x;
    }
    }++x;
    return (_γ_ielded=true, _γ_nextId = 5,  5)
++x;
    return x;
  
    };

    _γ_funcs[5] = function _γ_f5(_γ_ieldValue){
_γ_ieldValue_5 = _γ_ieldValue;
_γ_ielded=false;

_γ_ieldValue_5;
    ++x;
    return x;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

for-in inc inheritance

[
	"foo",
	undefined,
	
]

  var expecting = ['foo', undefined];

  function g() {
var key, _γ_key, _γ_keys_29, _γ_expro_29;

    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    function A() {}
    A.prototype.foo = 5;
      key ;
 _γ_key, _γ_keys_29 = [], _γ_expro_29 = ( new A);
for (_γ_key in _γ_expro_29) _γ_keys_29.push(_γ_key);
while (_γ_keys_29.length)
if (_γ_keys_29[0] in _γ_expro_29 && !void( key  = _γ_keys_29.shift()))
  return (_γ_ielded=true, _γ_nextId = 1,  key)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;
for (var _γ_whileOnce_60 = true, _γ_broke_60 = false;_γ_whileOnce_60; _γ_whileOnce_60 = false)
if (true)
_γ_ieldValue_1;
  if (!_γ_broke_60) { while (_γ_keys_29.length)
if (_γ_keys_29[0] in _γ_expro_29 && !void( key  = _γ_keys_29.shift()))
  return (_γ_ielded=true, _γ_nextId = 1,  key)
}
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

func call arg

[
	undefined,
	,
	30
]

  var send = [, 30];
  var expecting = [undefined, 30];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

return Math.max(_γ_ieldValue_1, 20);
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

addition

[
	undefined,
	,
	35
]

  var send = [, 30];
  var expecting = [undefined, 35];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1, undefined)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

return 5 + _γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

addition yield arg

[
	10,
	35
]

  var send = [, 30];
  var expecting = [10, 35];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1,  10)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

return 5 + _γ_ieldValue_1;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

addition yield arg parens

[
	10,
	35
]

  var send = [, 30];
  var expecting = [10, 35];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1,  10)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

return 5 + (_γ_ieldValue_1);
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}

addition yield arg parens before after

[
	10,
	55
]

  var send = [, 30];
  var expecting = [10, 55];

  function g() {
    var _γ_that = this;
    var _γ_ielded = true;
    var _γ_nextId = 0;
    var _γ_ieldValue_1;

    var _γ_funcs = [
      function _γ_f0(){
_γ_ielded=false;

    return (_γ_ielded=true, _γ_nextId = 1,  10)

      }
    ];

    _γ_funcs[1] = function _γ_f1(_γ_ieldValue){
_γ_ieldValue_1 = _γ_ieldValue;
_γ_ielded=false;

return 5 + (_γ_ieldValue_1) + 20;
  
    };

    return {
      next: function(v){
        if (arguments.length > 1) throw "next() only accepts zero or one arguments...";
        if (!_γ_ielded) throw 'unable to next, iterator finished';
        return {value:_γ_funcs[_γ_nextId].call(_γ_that, v), _γ_ielded: _γ_ielded,_γ_nextId: _γ_nextId,done:!_γ_ielded};
      },
    };
}